{
  "schema_version": 1,
  "server_id": "tencentcloudbase-cloudbase-mcp",
  "package": "@cloudbase/cloudbase-mcp",
  "version": "2.37.5",
  "collected_at": "2026-11-16T23:28:14.169Z",
  "analyzed_at": "2026-11-16T23:28:14.169Z",
  "modelara_version": "v0.1.8",
  "fingerprint": "sha256:d1b49c1a3cfca090974d48103ae1ee729b09bd652430602809165f70d2a50145",
  "tool_count": 42,
  "interface": {
    "format": "modelara.inspect/v0",
    "capability_set": {
      "source": {
        "type": "mcp",
        "name": "cloudbase-mcp",
        "version": "2.37.5",
        "protocol_version": "2025-11-25"
      },
      "discovered_at": "2026-11-16T23:28:13.68777526Z",
      "capabilities": [
        {
          "id": "mcp:cloudbase-mcp/auth",
          "name": "auth",
          "title": "CloudBase 开发阶段登录与环境",
          "description": "CloudBase（腾讯云开发）开发阶段登录与环境绑定。不确定该从哪开始？先调一次 auth(status)（只读、不用参数），确认登录态和当前环境。登录后即可访问云资源；环境(env)是云函数、数据库、静态托管等资源的隔离单元，绑定环境后其他 MCP 工具才能操作该环境。还没有环境时：国内站新用户可以免费开通一个体验环境，开通后再用 set_env 绑定。支持：查询状态、发起登录、API Key登录、绑定环境(set_env)、退出登录。auth(status) 会返回 credential_scope（account=账号级 / single_env=环境级 API Key）与当前 region；环境级 API Key 只能看到绑定的 envId，查不到其他地域环境是权限边界而非环境不存在。可选 site/region/lang 参数：site=站点(domestic/intl)，region=地域，lang=输出语言(zh/en)。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "auth"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "动作：status=查询状态，start_auth=发起登录，login_by_api_key=API Key登录，set_env=绑定环境(传envId)，logout=退出登录",
                "enum": [
                  "status",
                  "start_auth",
                  "set_env",
                  "logout",
                  "get_temp_credentials",
                  "login_by_api_key"
                ],
                "type": "string"
              },
              "apiKey": {
                "description": "CloudBase API Key，action=login_by_api_key 时必填",
                "type": "string"
              },
              "apiKeyEnvId": {
                "description": "CloudBase 环境ID(EnvId)，action=login_by_api_key 时必填，用于指定 API Key 所属环境",
                "type": "string"
              },
              "authMode": {
                "description": "认证模式：device=设备码授权，web=浏览器回调授权",
                "enum": [
                  "device",
                  "web"
                ],
                "type": "string"
              },
              "clientId": {
                "description": "高级可选：自定义 device-code 登录 client_id，不传则使用默认值",
                "type": "string"
              },
              "confirm": {
                "const": "yes",
                "description": "action=logout 时确认操作，传 yes",
                "type": "string"
              },
              "envId": {
                "description": "环境ID(CloudBase 环境唯一标识)，绑定后工具将操作该环境。action=set_env 时必填",
                "type": "string"
              },
              "lang": {
                "description": "输出语言：zh=中文（默认），en=英文。覆盖实例级语言（createCloudBaseMcpServer lang 选项 / TCB_LANG / project.json）",
                "enum": [
                  "zh",
                  "en"
                ],
                "type": "string"
              },
              "oauthCustom": {
                "description": "高级可选：自定义 endpoint 返回格式开关。未配置 endpoint 时默认 false；配置 endpoint 后默认 true。标准 {code,result} 包装格式的端点（如国际站 tcb-api.tencentcloud.com）应显式传 false",
                "type": "boolean"
              },
              "oauthEndpoint": {
                "description": "高级可选：自定义 device-code 登录 endpoint。配置后 oauthCustom 默认按 true 处理",
                "type": "string"
              },
              "region": {
                "description": "地域（如 ap-shanghai / ap-guangzhou / ap-singapore）。用于 region→site 推断与 API Key 换取网关选择；显式 site 优先",
                "type": "string"
              },
              "reveal": {
                "description": "action=get_temp_credentials 时可选。true=返回明文临时密钥；默认 false 仅返回脱敏结果",
                "type": "boolean"
              },
              "site": {
                "description": "站点：domestic=国内站，intl=国际站。环境开通在腾讯云国际站时，登录（start_auth/login_by_api_key）需显式传 intl，否则会走国内站链路、看不到国际站环境；调用级显式传入优先于 TCB_SITE 环境变量 / region 映射表 / 项目配置，影响登录端点、授权页与 API Key 换取网关",
                "enum": [
                  "domestic",
                  "intl"
                ],
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:27862bf1d62837a0bb1718698abab7625b6570bf1fca3c2f32ad266009304884"
        },
        {
          "id": "mcp:cloudbase-mcp/callCloudApi",
          "name": "callCloudApi",
          "title": "调用云API",
          "description": "通用的云 API 调用工具，主要用于 CloudBase / 腾讯云管控面与依赖资源相关 API 调用。**调用前必读接口索引** https://docs.cloudbase.net/ai/cloudbase-ai-toolkit/api-reference.md （每日自动同步的 Action 级索引，含 rate limit；先查此索引确认 service/Action/参数，避免猜测 Action 名称；索引未覆盖的产品再去该产品官方 API 文档核对）。如果你的目标是通过 HTTP 协议直接集成 auth/functions/cloudrun/storage/mysqldb 等 CloudBase 业务 API，请不要优先使用 callCloudApi，而应优先查看对应 OpenAPI / Swagger。现有 OpenAPI / Swagger 能力不是通用的管控面 Action 集合；管控面 API 请优先参考 CloudBase API 概览 https://cloud.tencent.com/document/product/876/34809 与云开发依赖资源接口指引 https://cloud.tencent.com/document/product/876/34808。对于 tcb service，常用 Action 分类如下：\n\n**环境管理**: `CreateEnv`、`ModifyEnv`、`DescribeEnvs`、`DestroyEnv`\n**用户管理**: `CreateUser`、`ModifyUser`、`DescribeUserList`、`DeleteUsers`\n**认证配置**: `EditAuthConfig`、`DescribeAuthDomains`\n**云函数**: `DescribeFunctions`、`CreateFunction`、`UpdateFunctionCode`、`DeleteFunction`\n**数据库**: `CreateMySQLInstance`、`DescribeMySQLInstances`、`DestroyMySQLInstance`\n\n⚠️ 云托管（CloudBase Run）统一走 tcbr service（CreateCloudRunEnv / CreateCloudRunServer / DescribeEnvBaseInfo / DescribeCloudRunEnvs，version=\"2022-02-17\"），tcb 旧小租户接口 CreateCloudBaseRunResource 等已被禁用；部署请用 manageCloudRun。查询单个环境基础信息/是否已开通云托管用 DescribeEnvBaseInfo（EnvId 必填），查询环境列表及资源信息用 DescribeCloudRunEnvs（EnvId 可选过滤）。\n\n⚠️ Region 必须作为本工具顶层参数 `region` 传入（对应 X-TC-Region / 地域 endpoint），不要放进 params。params 里的 Region 会被剥离并当作顶层 region 使用。\n\n销毁环境时，常见做法是至少带上 `EnvId` 和 `BypassCheck: true`，如果环境已经处于隔离期再按文档补 `IsForce: true`。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "callCloudApi"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "具体 Action 名称，需符合对应服务的官方 API 定义。**不确定时先查官方文档，不要用近义词或历史命名猜测**（猜错会被服务端报成 action invalid，很难排查）。常用 Action 见 skill cloud-api-operations。",
                "minLength": 1,
                "type": "string"
              },
              "params": {
                "additionalProperties": {},
                "description": "Action 对应的参数对象，键名与官方 API 定义一致，不确定时先查文档。**不要把 Region 放这里**，跨地域用顶层 region。CloudBase 业务 API 请优先用 searchKnowledgeBase(mode=\"openapi\")，不要用本工具。示例见 skill cloud-api-operations。",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "region": {
                "description": "云 API 地域（X-TC-Region），如 ap-shanghai。跨地域必须传此顶层参数，不要写进 params。⚠️ ap-singapore 同属国内站与国际站，未指定站点按国际站（site=intl）处理：要操作国内站该地域环境，先 auth(action=\"start_auth\", site=\"domestic\") 或设 TCB_SITE=domestic。",
                "type": "string"
              },
              "service": {
                "enum": [
                  "tcb",
                  "tcbr",
                  "scf",
                  "sts",
                  "cam",
                  "cloudaudit",
                  "tag",
                  "billing",
                  "region",
                  "ba",
                  "cvm",
                  "lighthouse",
                  "tke",
                  "cbs",
                  "cfs",
                  "tcr",
                  "cdb",
                  "mariadb",
                  "postgres",
                  "sqlserver",
                  "redis",
                  "mongodb",
                  "cynosdb",
                  "dcdb",
                  "tcaplusdb",
                  "keewidb",
                  "vpc",
                  "clb",
                  "cdn",
                  "ecdn",
                  "dnspod",
                  "privatedns",
                  "domain",
                  "ssl",
                  "teo",
                  "gaap",
                  "kms",
                  "ssm",
                  "waf",
                  "cwp",
                  "tcss",
                  "ckafka",
                  "tdmq",
                  "tdmysql",
                  "apigateway",
                  "monitor",
                  "cls",
                  "apm",
                  "tsf",
                  "tat",
                  "hunyuan",
                  "lkeap",
                  "tts",
                  "trtc",
                  "live",
                  "vod",
                  "sms",
                  "ses"
                ],
                "type": "string"
              },
              "version": {
                "type": "string"
              }
            },
            "required": [
              "service",
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:09a8a52e483c79ee31276c4d5ae085667f333ff7a4c63baea9f8999c64f4ab87"
        },
        {
          "id": "mcp:cloudbase-mcp/deployApply",
          "name": "deployApply",
          "title": "执行 CloudBase 声明式部署（本地 apply）",
          "description": "解析 cloudbaserc 并按 database→functions→app→hosting→gateway 顺序执行声明式部署。这是 deployPlan 的执行对仗工具（plan 预演 / deployApply 执行同一份 cloudbaserc），属于本地形态的 apply（读本地 cloudbaserc 并在本地构建上传），是会变更云端资源的写操作，必须显式传 confirm=true 才会执行。建议先用 deployPlan 预演，确认计划无误后再执行。\n适用边界：本工具用于项目级声明式编排（一份 cloudbaserc 统一 plan/apply）；单资源临时直传请用 manageFunctions/manageHosting/manageApps。\n- confirm：必须显式传 true 才执行部署，否则直接拒绝\n- confirmDestructive：当本次待执行的数据库迁移含破坏性语句（DROP/TRUNCATE/DELETE、ALTER…DROP/RENAME）时，除 confirm 外还必须显式传 confirmDestructive=true 才会执行；否则拒绝并列出命中的迁移与语句。无破坏性迁移时该参数不生效\n- cwd：项目根目录，默认当前工作目录\n- mode：环境名，命中 envOverrides.<mode> 时合并对应的多环境覆盖配置\n- envId：目标环境 ID，优先级高于 cloudbaserc 中的 envId；不传则用配置值或当前绑定环境\n- only：仅部署指定资源类型\n- skip：跳过指定资源类型\n- yes：遇到已存在资源时的处理方式。true=直接覆盖更新；false（默认）=保守跳过，在无法交互确认的场景下已存在资源不会被覆盖（与 deployPlan 的 yes 语义一致）\n- concurrency：同类型资源最大并行数，默认 1（串行）\n- continueOnError：某个资源失败后继续部署其余资源（database 失败仍强制中断）",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "deployApply"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "concurrency": {
                "description": "同类型资源最大并行数，默认 1（串行）；仅作用于同类型资源，跨类型依赖顺序不变",
                "maximum": 9007199254740991,
                "minimum": 1,
                "type": "integer"
              },
              "confirm": {
                "description": "危险操作确认开关。部署会变更云端资源，必须显式传 confirm=true 才会执行",
                "type": "boolean"
              },
              "confirmDestructive": {
                "description": "破坏性数据库变更确认开关。当待执行迁移含 DROP/TRUNCATE/DELETE 或 ALTER…DROP/RENAME 时，必须在 confirm=true 之外额外显式传 confirmDestructive=true；无破坏性迁移时不生效",
                "type": "boolean"
              },
              "continueOnError": {
                "description": "某个资源失败后是否继续部署其余资源；database 失败始终强制中断",
                "type": "boolean"
              },
              "cwd": {
                "description": "项目根目录，从此目录向下搜索 cloudbaserc；默认当前工作目录",
                "type": "string"
              },
              "envId": {
                "description": "目标环境 ID，优先级高于 cloudbaserc 中的 envId；不传则用配置值或当前绑定环境",
                "type": "string"
              },
              "mode": {
                "description": "环境名（如 production/staging），命中 envOverrides.<mode> 时合并覆盖",
                "type": "string"
              },
              "only": {
                "description": "仅部署指定资源类型，可选值：database/functions/app/hosting/gateway",
                "items": {
                  "enum": [
                    "database",
                    "functions",
                    "app",
                    "hosting",
                    "gateway"
                  ],
                  "type": "string"
                },
                "maxItems": 5,
                "type": "array"
              },
              "skip": {
                "description": "跳过指定资源类型，可选值：database/functions/app/hosting/gateway",
                "items": {
                  "enum": [
                    "database",
                    "functions",
                    "app",
                    "hosting",
                    "gateway"
                  ],
                  "type": "string"
                },
                "maxItems": 5,
                "type": "array"
              },
              "yes": {
                "description": "遇到已存在资源时是否直接覆盖更新。true=覆盖；false（默认）=保守跳过已存在资源",
                "type": "boolean"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8df86d2f864ef1c23c643e21d17998297d296d7b4844206d8236d768e663cad9"
        },
        {
          "id": "mcp:cloudbase-mcp/deployBuild",
          "name": "deployBuild",
          "title": "构建声明式配置中的静态托管项目（本地构建）",
          "description": "解析 cloudbaserc 并对 hosting[] 中配置了 buildCommand 的项目执行本地构建（仅执行 buildCommand，不安装依赖、不上传）。对应 CLI 的 tcb app build，但只处理 hosting[] 静态托管项，与 cloudbaserc 的 app 资源类型（云端构建管线）无关。声明式 hosting 部署拆分为「build → plan → apply」三步，本工具是第一步：先本地构建产物，再 deployPlan 预演，最后 deployApply 上传产物。deployApply 不再隐式本地构建 —— 带构建命令的 hosting 项在产物缺失时会报错引导先执行本工具。纯静态托管（未配置 buildCommand 且无法探测框架）自动跳过。构建为纯本地操作：不解析环境、不要求登录，也不需要 confirm。\n- cwd：项目根目录，默认当前工作目录\n- mode：环境名，命中 envOverrides.<mode> 时合并对应的多环境覆盖配置",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "deployBuild"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "cwd": {
                "description": "项目根目录，从此目录向下搜索 cloudbaserc；默认当前工作目录",
                "type": "string"
              },
              "mode": {
                "description": "环境名（如 production/staging），命中 envOverrides.<mode> 时合并覆盖",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:82ca61a4cadae640df7c9d6e7a395cc3bed77bdbb45cc55206c64b7c0aea7b34"
        },
        {
          "id": "mcp:cloudbase-mcp/deployPlan",
          "name": "deployPlan",
          "title": "预演 CloudBase 声明式部署计划",
          "description": "解析 cloudbaserc 并计算声明式部署计划（dry-run，不产生任何变更）。这是 deployApply 的预演对仗工具：plan 计算、deployApply 执行同一份 cloudbaserc。返回每个资源的动作分类：create=新建，update=覆盖更新，skip=无变更/不会执行，conflict=检测到冲突需中断，deploy=直传覆盖。计划已按 yes 复算为「实际会发生的动作」：不传 yes=true 时，云端已存在的函数会标为 skip（并在 declaredStatus 保留 update），与 deployApply 的实际执行结果一致，避免预演与执行相反。\n适用边界：本工具用于项目级声明式编排（一份 cloudbaserc 统一 plan/apply）；单资源临时直传请用 manageFunctions/manageHosting/manageApps。\n- cwd：项目根目录，默认当前工作目录\n- mode：环境名，命中 envOverrides.<mode> 时合并对应的多环境覆盖配置\n- envId：目标环境 ID，优先级高于 cloudbaserc 中的 envId；不传则用配置值或当前绑定环境\n- only：仅计算指定资源类型的计划\n- skip：跳过指定资源类型\n- yes：与 deployApply 的 yes 对齐，用于复算已存在函数的有效动作。true=预演为覆盖更新(update)；false（默认）=预演为保守跳过(skip)",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "deployPlan"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "cwd": {
                "description": "项目根目录，从此目录向下搜索 cloudbaserc；默认当前工作目录",
                "type": "string"
              },
              "envId": {
                "description": "目标环境 ID，优先级高于 cloudbaserc 中的 envId；不传则用配置值或当前绑定环境",
                "type": "string"
              },
              "mode": {
                "description": "环境名（如 production/staging），命中 envOverrides.<mode> 时合并覆盖",
                "type": "string"
              },
              "only": {
                "description": "仅计算指定资源类型的计划，可选值：database/functions/app/hosting/gateway",
                "items": {
                  "enum": [
                    "database",
                    "functions",
                    "app",
                    "hosting",
                    "gateway"
                  ],
                  "type": "string"
                },
                "maxItems": 5,
                "type": "array"
              },
              "skip": {
                "description": "跳过指定资源类型，可选值：database/functions/app/hosting/gateway",
                "items": {
                  "enum": [
                    "database",
                    "functions",
                    "app",
                    "hosting",
                    "gateway"
                  ],
                  "type": "string"
                },
                "maxItems": 5,
                "type": "array"
              },
              "yes": {
                "description": "与 deployApply 的 yes 对齐，用于复算已存在函数的有效动作。true=预演为覆盖更新；false（默认）=预演为保守跳过",
                "type": "boolean"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:1630828bb8d66ddafd234e986cdc6d1be52c388e5a1250e25c94b35c3dc3a677"
        },
        {
          "id": "mcp:cloudbase-mcp/downloadTemplate",
          "name": "downloadTemplate",
          "title": "下载项目模板",
          "description": "自动下载并部署CloudBase项目模板。\n**Note**: Call this tool when the user requests to create a new project using a CloudBase template.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板\n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（Cursor、CodeBuddy、Claude Code 等主流编辑器），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器（仅 MCP 配置，不含规则文件）\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器（仅 MCP 配置，不含规则文件）\n- aider: Aider AI编辑器\n- iflow-cli: iFlow CLI（仅 MCP 配置，不含规则文件）\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n\n特别说明：\n- rules 模板会自动包含当前 MCP 版本号信息，便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "downloadTemplate"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "ide": {
                "description": "指定要下载的IDE类型。",
                "enum": [
                  "all",
                  "cursor",
                  "codebuddy",
                  "claude-code",
                  "gemini-cli",
                  "opencode",
                  "qwen-code",
                  "baidu-comate",
                  "openai-codex-cli",
                  "github-copilot",
                  "roocode",
                  "tongyi-lingma",
                  "trae",
                  "qoder",
                  "antigravity",
                  "vscode",
                  "kiro",
                  "aider",
                  "iflow-cli"
                ],
                "type": "string"
              },
              "overwrite": {
                "description": "是否覆盖已存在的文件，默认为false（不覆盖）",
                "type": "boolean"
              },
              "template": {
                "description": "要下载的模板类型",
                "enum": [
                  "react",
                  "vue",
                  "miniprogram",
                  "uniapp",
                  "rules"
                ],
                "type": "string"
              }
            },
            "required": [
              "template",
              "ide"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:598bffd6af59119214667ca3c0fe386c8ed2e89ec4d4d8065e2b1baced77c1ab"
        },
        {
          "id": "mcp:cloudbase-mcp/envDomainManagement",
          "name": "envDomainManagement",
          "title": "CloudBase 环境安全域名管理（浏览器 CORS 白名单）【已废弃】",
          "description": "⚠️ DEPRECATED：此工具已废弃并收编进 manageEnv，请改用 manageEnv(action=\"addSecurityDomain\") / manageEnv(action=\"removeSecurityDomain\")（入参 domains 完全一致）。本别名将在下个版本移除。\n\n管理【环境安全域名】＝浏览器跨域（CORS）白名单：控制允许哪些网页 origin（host:port）从浏览器直接调用本环境的 CloudBase 资源。只做 CORS 来源验证，不提供访问域名，不涉及 HTTPS 证书。⚠️ 与【网关自定义域名】是两套完全独立的配置，互不相干：如需给自己的域名绑定 HTTPS 访问入口（云托管 / 网关服务），那属于 manageGateway 的职责——先 queryGateway(listCustomDomains)；已有域名则 manageGateway(createRoute) 显式传 domain（无需证书）；仅首次绑定新域名才用 bindCustomDomain（需 certificateId）。不要用本工具做这件事。\n\n操作指引：（原工具名 createEnvDomain/deleteEnvDomain，为兼容旧 AI 规则可继续使用这些名称）当浏览器 Web 应用需要从本地 Vite / dev server 直接访问 CloudBase 资源时，先用 queryEnv(action=domains) 检查当前实际浏览器 origin 对应的 host:port 是否已在白名单中，再按该实际值添加。新增或删除后请每约 10 秒轮询 queryEnv(action=domains) 确认状态收敛，勿一次 sleep 满 10 分钟；多数环境数分钟内可收敛。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "envDomainManagement"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：create=添加安全域名，delete=删除安全域名",
                "enum": [
                  "create",
                  "delete"
                ],
                "type": "string"
              },
              "domains": {
                "description": "安全域名数组（格式：host:port，例如 localhost:5173 或 127.0.0.1:4173）。注意：不是自定义域名，不需要证书。",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              }
            },
            "required": [
              "action",
              "domains"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:6935b37abad2727694ba060f0d9b62c50be6d83f85ebd6252ee64b9179964bcf"
        },
        {
          "id": "mcp:cloudbase-mcp/manageAgents",
          "name": "manageAgents",
          "title": "管理 CloudBase Agent",
          "description": "CloudBase Agent 域统一写入口。支持创建、更新和删除远端 Agent。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageAgents"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "createAgent",
                  "updateAgent",
                  "deleteAgent"
                ],
                "type": "string"
              },
              "agentId": {
                "type": "string"
              },
              "cosBucketRegion": {
                "type": "string"
              },
              "cwd": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "installDependency": {
                "type": "boolean"
              },
              "memorySize": {
                "type": "number"
              },
              "name": {
                "type": "string"
              },
              "params": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "runtime": {
                "type": "string"
              },
              "sessionConfig": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "tempCosObjectName": {
                "type": "string"
              },
              "timeout": {
                "type": "number"
              },
              "zipFile": {
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:e243a2a0fad6fdee143a31a028282da486ed1b4aab7c238aecac8291f29edd85"
        },
        {
          "id": "mcp:cloudbase-mcp/manageAppAuth",
          "name": "manageAppAuth",
          "title": "管理 CloudBase 应用认证配置",
          "description": "CloudBase 应用侧认证配置写入口。用于修改登录方式、provider、client 配置，确保 publishable key，以及创建或删除 API key、自定义登录密钥。⚠️ 本工具为管理端配置工具，不执行用户登录。当任务要求编写客户端登录代码时（例如「用 JS SDK 登录」），应先通过本工具完成配置（如启用 usernamePassword、获取 publishable key），再在项目代码中编写 @cloudbase/js-sdk 客户端登录代码（如 auth.signInWithPassword()），而非使用本工具完成登录。若前端要接受普通用户名样式标识符，应先执行 action=patchLoginStrategy 并传入 patch={ usernamePassword: true }，再实现对应前端登录逻辑。⚠️ 短信验证码登录（patch={ phone: true }）使用云开发默认短信通道，开启后即可收发验证码，不需要配置短信签名/模板/自定义 Provider；仅当需要自定义模板/签名或更换短信服务商时才需配置 SmsVerificationConfig 或自定义短信通道。⚠️ action=createApiKey 返回体中的 created 字段表示是否真正新建：created=false 说明复用了环境中已存在的 key，此时 keyName/expireIn 入参不会生效，返回的 keyName/expireAt 均为服务端真实值，并会附带 warnings，切勿把它当作临时凭证分发。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageAppAuth"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "patchLoginStrategy",
                  "addProvider",
                  "updateProvider",
                  "deleteProvider",
                  "updateClientConfig",
                  "ensurePublishableKey",
                  "createApiKey",
                  "deleteApiKey",
                  "createCustomLoginKeys"
                ],
                "type": "string"
              },
              "clientId": {
                "description": "updateClientConfig 时的客户端 Id；省略时默认使用当前环境 ID",
                "type": "string"
              },
              "config": {
                "additionalProperties": {},
                "description": "provider / client 的配置对象",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "displayName": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "additionalProperties": {},
                    "propertyNames": {
                      "type": "string"
                    },
                    "type": "object"
                  }
                ],
                "description": "addProvider 时的展示名称，可传字符串或多语言对象"
              },
              "expireIn": {
                "description": "createApiKey 时的有效期，单位秒；0 表示不过期。复用已有 key 时该值不生效，此时返回体会带 created=false 与 warnings",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "keyId": {
                "description": "deleteApiKey 时的 API key 唯一标识",
                "type": "string"
              },
              "keyName": {
                "description": "createApiKey 时的 API key 名称；服务端可能忽略该值（如 publish_key 每环境唯一时），返回体中的 keyName 一律为服务端实际存储的名称",
                "type": "string"
              },
              "keyType": {
                "description": "createApiKey 时的 API key 类型，默认 publish_key",
                "enum": [
                  "publish_key",
                  "api_key"
                ],
                "type": "string"
              },
              "patch": {
                "additionalProperties": {},
                "description": "patchLoginStrategy 使用的简化登录策略 patch，如 { usernamePassword: true }",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "providerId": {
                "description": "provider 标识，如 email、google；addProvider 时也可作为自定义 provider Id",
                "type": "string"
              },
              "providerType": {
                "description": "addProvider 时的 provider 协议类型",
                "enum": [
                  "OAUTH",
                  "OIDC",
                  "SAML",
                  "WX_MICRO_APP",
                  "WX_QRCODE_MICRO_APP",
                  "WX_CLOUDBASE_MICRO_APP",
                  "WX_MP",
                  "WX_OPEN",
                  "WX_WORK_INTERNAL",
                  "WX_WORK_AGENT",
                  "WX_WORK_THIRD_PARTY",
                  "WX_WORK_THIRD_PARTY_ASSOCIATION",
                  "CUSTOM",
                  "EMAIL"
                ],
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:c2ff14c6a59a99791f2567f70ec0fbdc20837b0e1b1942c20057b1757d15176e"
        },
        {
          "id": "mcp:cloudbase-mcp/manageApps",
          "name": "manageApps",
          "title": "部署应用到 CloudBase（独立子域名）",
          "description": "部署 Web 应用到 CloudBase（构建前后端，部署到独立子域名）。\n云端上传通道（cloud mode，无本地文件系统）：queryApps(action=getUploadUrl) 或 manageApps(action=getUploadUrl) 获取预签名上传 URL → agent 自行 PUT 代码 zip 到 uploadUrl（带 uploadHeaders 与 Content-Type: application/zip）→ 用返回的 unixTimestamp 作为 cosTimestamp 调 deployApp 触发部署。\naction=getUploadUrl 获取预签名上传 URL（cloud mode 下使用），返回上传地址和 cosTimestamp。\naction=deployApp 上传源码 ZIP 并触发远端构建部署管道：\n  1. 远端 npm install（可通过 installCmd=\"\" 跳过）\n  2. 远端 npm run build（可通过 buildCmd=\"\" 跳过）\n  3. 远端 tcb hosting deploy\n\n域名格式：`<serviceName>-<envId>.webapps.tcloudbase.com`（每个 serviceName 一个独立子域名）\n\n✅ 推荐用法（新项目／需要独立域名的 Web 应用，首选此工具）：\n  新建项目首次部署时，传 framework=static, installCmd=\"\", buildCmd=\"\" 跳过远端构建，\n  只执行 tcb hosting deploy。部署后获得独立子域名，支持版本管理。\n\n⚠️ 兼容性说明：\n- 已有项目若之前用 manageHosting 部署过（域名格式：`<envId>-<appId>.tcloudbaseapp.com`），\n  切换到 manageApps 会产生全新的 URL，老链接失效。请保持原部署方式不变。\n- 如需判断：调用 queryHosting 检查是否已有托管文件。\n\n与 manageHosting 对比：\n- manageApps（本工具，新项目首选）：域名 `<serviceName>-<envId>.webapps.tcloudbase.com`，独立子域名，支持版本管理\n- manageHosting（已有项目或 fallback）：域名 `<envId>-<appId>.tcloudbaseapp.com/<path>`，共享环境域名\n两者均可绑定自定义域名。\n\n⚠️ 如果 manageApps 构建失败，先用 queryApps(action=\"getBuildLog\") 查日志；仍不行再 fallback 到 manageHosting。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageApps"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "deployApp",
                  "getUploadUrl",
                  "deleteApp",
                  "deleteAppVersion"
                ],
                "type": "string"
              },
              "appPath": {
                "description": "应用线上访问路径（hosting mount path），例如 /my-web-app。不是本地目录路径；CloudApp 已有独立子域名，省略时默认为 /（根路径）。",
                "type": "string"
              },
              "buildCmd": {
                "description": "构建命令，例如 npm run build。不传时默认 npm run build。本地已构建好可传空字符串 '' 跳过构建步骤。若希望完全跳过远端管道，请改用 manageHosting。",
                "type": "string"
              },
              "buildPath": {
                "description": "构建产物目录，相对于 filePath，例如 dist 或 build。\n⚠️ 传此值后远端构建系统会 cd 到此目录再执行 tcb hosting deploy，因此 deployCmd 会自动使用 .（当前目录）而非目录名，避免路径重复（如 dist/dist 错误）。\n纯静态 HTML 如果在项目根目录可省略，但注意 deployCmd 默认用 dist。",
                "type": "string"
              },
              "cosTimestamp": {
                "description": "COS 时间戳（getUploadUrl 返回的 unixTimestamp，字符串或数字均可）。传入则直接用已上传的代码创建应用，跳过本地打包上传；需先 getUploadUrl 拿预签名 URL 并 PUT ZIP。cloud mode 必填。与 filePath 严格二选一，同时提供或都不提供都会报错。",
                "type": [
                  "string",
                  "number"
                ]
              },
              "deployCmd": {
                "description": "自定义部署命令。通常无需填写，默认自动生成 tcb hosting deploy 命令。有 buildPath 时远端已 cd 到该目录，默认用 . 作为源码路径；无 buildPath 时默认用 dist。",
                "type": "string"
              },
              "filePath": {
                "description": "要上传并部署的本地项目根目录绝对路径。本地模式下 deployApp 时必填；通常传源码所在目录（含 package.json 和源码），不是 dist 目录。构建产物目录请用 buildPath 指定。cloud mode 下无需传此参数，改用 cosTimestamp。",
                "type": "string"
              },
              "framework": {
                "description": "前端框架类型。可选值：vue、react、next、nuxt、vite、angular、static。\n即使传 static，仍会经过远端构建管道。如果本地已构建好，建议改用 manageHosting 直接上传，可完全跳过远端构建。",
                "enum": [
                  "vue",
                  "react",
                  "next",
                  "nuxt",
                  "vite",
                  "angular",
                  "static"
                ],
                "type": "string"
              },
              "ignore": {
                "description": "上传时忽略的文件/目录 glob 模式，例如 **/node_modules/**。\n⚠️ 打包的是项目根目录（filePath）而非 buildPath 产物目录：若项目根含 target/（Rust）、.next/、dist-old/、build/ 等大构建产物，必须加进 ignore（如 **/target/**），否则整个目录被打进上传 zip（实证 54GB target → 34GB zip）。默认已排除 node_modules/.git/.DS_Store/**/target/**/.next/**/.next.bak/**。",
                "items": {
                  "type": "string"
                },
                "maxItems": 200,
                "type": "array"
              },
              "installCmd": {
                "description": "依赖安装命令，例如 npm install。不传时默认 npm install。本地已安装或无需安装可传空字符串 '' 跳过，但远端仍会执行 tcb hosting deploy。",
                "type": "string"
              },
              "nodeJsVersion": {
                "description": "构建时使用的 Node.js 版本；不传时由 CloudBase 使用默认值。",
                "type": "string"
              },
              "serviceName": {
                "description": "CloudBase 应用服务名，会体现在域名中：`<serviceName>-<envId>.webapps.tcloudbase.com`。deployApp 时复用现有 serviceName 会新增一个部署版本并触发重新部署，而不是删除重建。首次部署请用新名称。",
                "type": "string"
              },
              "versionName": {
                "description": "要删除的历史版本名，仅 action=deleteAppVersion 时必填。",
                "type": "string"
              }
            },
            "required": [
              "action",
              "serviceName"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:461e81d9250246f7787f4bd1811979de8b5447174cf962748f63a364ed577bb4"
        },
        {
          "id": "mcp:cloudbase-mcp/manageCloudRun",
          "name": "manageCloudRun",
          "title": "管理 CloudRun 服务",
          "description": "管理云托管服务，按开发顺序支持：开通云托管环境（initEnv）、初始化项目（可从模板开始，模板列表可通过 queryCloudRun 查询）、下载服务代码、本地运行（仅函数型服务）、部署代码、仅更新配置（updateConfig，无需重新上传代码）、删除服务。deploy 支持两种方式：1) 源码构建（传入 targetPath，本地代码打包上传，默认路径）；2) 已有镜像部署（传入 imageUrl，如 ccr.ccs.tencentyun.com/ns/img:v1，走 DeployType=image 容器型部署，targetPath 可省略）。deploy 语义为「触发部署 + 轻量等待任务注册」（最多约 45s；不需要 buildId 时可传 waitRegistration=false 跳过等待）。源码构建返回 buildId，用 getDeployLog 轮询构建进度后再 getProcessLog；镜像部署（imageUrl）BuildId 常为 0，跳过 getDeployLog，返回 runId/next_step 引导 getProcessLog（或先 getDeployRecords 取 RunId）。若用户明确指定镜像或无需重新构建，必须传 imageUrl，不要仅因本地有源码目录就回退到源码构建。deploy 对已存在服务会先读取远程配置再合并（保留 VpcConf/EnvParams/OpenAccessTypes）。updateConfig 对齐控制台服务设置页。删除操作需要确认，建议设置force=true。新环境首次部署前若提示未开通云托管，先调用 initEnv 开通（异步、幂等）。部署前请确认镜像里没有静态内容：媒体文件（视频、大图、字体）、用户上传的文件、以及频繁更新的静态资源，都应放进云存储按 URL 引用，不要打进镜像——否则每次部署都要全量重推、每个扩容实例都要重拉，一个 demo 视频就能把 30 秒的部署拖成几分钟。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageCloudRun"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "云托管服务管理操作类型：init=从模板初始化新的云托管项目代码（在targetPath目录下创建以serverName命名的子目录，支持多种语言和框架模板），download=从云端下载现有服务的代码到本地进行开发，run=在本地运行函数型云托管服务（用于开发和调试，仅支持函数型服务），deploy=触发部署并轻量等待任务注册（不会 hang 等完整构建）。源码构建（targetPath）返回 buildId，用 getDeployLog 轮询后再 getProcessLog；已有镜像部署（imageUrl，DeployType=image，BuildId 常为 0）跳过 getDeployLog，用 detail/getDeployRecords 取 RunId 后 getProcessLog。传 imageUrl 时 targetPath 可省略；已存在服务会 Read-Merge-Write 保留远程 VpcConf/EnvParams/OpenAccessTypes），updateConfig=仅更新服务配置不重新上传代码（对齐控制台服务设置，走 SubmitServerConfigChangeDiff；不需要 targetPath），delete=删除指定的云托管服务（不可恢复，需要确认），createAgent=创建函数型Agent（基于函数型云托管开发AI智能体），initEnv=开通当前环境的云托管（异步创建云托管环境，幂等：已开通直接返回；适合新环境首次部署前使用），traffic=流量管理与灰度发布（set=调整稳定版/灰度版流量比例，promote=将灰度版本升级为全量，rollback=回滚到上一个稳定版本；对应 tcb cloudrun traffic 命令）",
                "enum": [
                  "init",
                  "download",
                  "run",
                  "deploy",
                  "delete",
                  "createAgent",
                  "updateConfig",
                  "initEnv",
                  "traffic"
                ],
                "type": "string"
              },
              "agentConfig": {
                "description": "Agent配置项，仅在createAgent操作时使用",
                "properties": {
                  "agentName": {
                    "description": "Agent名称，用于生成BotId",
                    "type": "string"
                  },
                  "botTag": {
                    "description": "Bot标签，用于生成BotId，不提供时自动生成",
                    "type": "string"
                  },
                  "description": {
                    "description": "Agent描述信息",
                    "type": "string"
                  },
                  "template": {
                    "default": "blank",
                    "description": "Agent模板类型，默认为blank（空白模板）",
                    "type": "string"
                  }
                },
                "required": [
                  "agentName"
                ],
                "type": "object"
              },
              "canaryPercent": {
                "description": "灰度版本流量比例（trafficOp=set 时使用），取值范围0-100。与 stablePercent 之和必须等于100。例如希望 90% 流量打到稳定版、10% 打到灰度版，则 stablePercent=90, canaryPercent=10",
                "maximum": 100,
                "minimum": 0,
                "type": "number"
              },
              "envId": {
                "description": "环境 ID（action=initEnv 时使用；不传则使用当前配置的环境）。格式如 env-xxxxxx",
                "type": "string"
              },
              "envParamsReplaceAll": {
                "default": false,
                "description": "EnvParams 合并策略（deploy / updateConfig）：false（默认）= 与远程按 key 合并（输入覆盖同名 key，远程其余 key 保留）；true= 用输入 EnvParams 整包替换远程。仅当显式传入 EnvParams 时生效",
                "type": "boolean"
              },
              "force": {
                "default": false,
                "description": "强制操作开关，用于跳过确认提示。默认false（需要确认），设置为true时跳过所有确认步骤。删除操作时强烈建议设置为true以避免误操作",
                "type": "boolean"
              },
              "imageUrl": {
                "description": "已有镜像部署（action=deploy 时使用）：直接指定容器镜像地址，如 ccr.ccs.tencentyun.com/ns/img:v1 或公网 registry 地址。传入后走 DeployType=\"image\"（容器型）部署，无需本地源码目录（targetPath 可省略）。支持：1) 公网匿名可拉取的镜像直填地址；2) 私有/需登录的镜像（如 ghcr.io）需先在本地 docker pull → docker tag/push 到腾讯云 CCR → 填入 CCR 地址。不传则维持源码构建（本地代码打包上传）。约束：若用户明确提到使用某个镜像、或无需重新构建代码，则必须传 imageUrl 走镜像部署，不要回退到源码构建。注意：无论哪种部署方式，环境都需先开通云托管（未开通时先调用 initEnv，Status=normal 后再部署）",
                "type": "string"
              },
              "packageType": {
                "default": "Trial",
                "description": "云托管环境套餐类型（action=initEnv 时使用）：Trial=试用，Standard=标准，Professional=专业，Enterprise=企业。默认 Trial",
                "enum": [
                  "Trial",
                  "Standard",
                  "Professional",
                  "Enterprise"
                ],
                "type": "string"
              },
              "runOptions": {
                "description": "本地运行参数配置，仅函数型云托管服务支持。用于配置本地开发环境的运行参数，不影响云端部署",
                "properties": {
                  "agentId": {
                    "description": "Agent ID，在agent模式下使用，用于标识特定的Agent实例",
                    "type": "string"
                  },
                  "envParams": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "本地运行时的附加环境变量配置，用于本地开发和调试。格式为键值对，如{\"DEBUG\":\"true\",\"LOG_LEVEL\":\"debug\"}。这些变量仅在本地运行时生效",
                    "propertyNames": {
                      "type": "string"
                    },
                    "type": "object"
                  },
                  "port": {
                    "default": 3000,
                    "description": "本地运行端口配置，仅函数型服务有效。指定服务在本地运行时监听的端口号，默认3000。确保端口未被其他程序占用",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": "number"
                  },
                  "runMode": {
                    "default": "normal",
                    "description": "运行模式：normal=普通函数模式，agent=Agent模式（用于AI智能体开发）",
                    "enum": [
                      "normal",
                      "agent"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "serverConfig": {
                "description": "服务配置项，用于 deploy / updateConfig。包括资源规格、访问权限、环境变量、日志、网络等。deploy 未提供时对已存在服务仍会从远程合并保留 VpcConf/EnvParams/OpenAccessTypes；updateConfig 至少需要一个配置字段",
                "properties": {
                  "BuildDir": {
                    "description": "构建目录配置，指定代码构建的目录路径。当代码结构与标准不同时使用，默认为项目根目录",
                    "type": "string"
                  },
                  "Cmd": {
                    "description": "Dockerfile Cmd参数配置，仅容器型服务需要。指定容器启动时的默认命令数组，如[\"npm\",\"start\"]",
                    "items": {
                      "type": "string"
                    },
                    "maxItems": 100,
                    "type": "array"
                  },
                  "Cpu": {
                    "description": "CPU规格配置，单位为核。可选值：0.25、0.5、1、2、4、8等。注意：内存规格必须是CPU规格的2倍（如CPU=0.25时内存=0.5，CPU=1时内存=2）。影响服务性能和计费",
                    "exclusiveMinimum": 0,
                    "type": "number"
                  },
                  "CustomLogs": {
                    "description": "自定义日志配置，用于配置服务的日志收集和存储策略",
                    "type": "string"
                  },
                  "Dockerfile": {
                    "description": "Dockerfile文件名配置，仅容器型服务需要。指定用于构建容器镜像的Dockerfile文件路径，默认为项目根目录下的Dockerfile",
                    "type": "string"
                  },
                  "EntryPoint": {
                    "description": "Dockerfile EntryPoint参数配置，仅容器型服务需要。指定容器启动时的入口程序数组，如[\"node\",\"app.js\"]",
                    "items": {
                      "type": "string"
                    },
                    "maxItems": 100,
                    "type": "array"
                  },
                  "EnvParams": {
                    "description": "环境变量配置，JSON字符串格式。用于传递配置信息给服务代码，如'{\"DATABASE_URL\":\"postgres://user:pass@10.x.x.x:5432/db\",\"NODE_ENV\":\"production\"}'。SDK v5.6.1+ 会自动对传入的环境变量进行 AES-256-CBC 加密传输。⚠️ 若 EnvParams 含 DATABASE_URL / MYSQL_* / POSTGRES_* / REDIS_* 等传统 TCP 连库变量，必须同时配置 VpcConf，否则实例通常无法访问 VPC 内数据库",
                    "type": "string"
                  },
                  "InitialDelaySeconds": {
                    "description": "端口健康检查初始延迟（秒）。部署完成后先等待 N 秒才开始端口探测，之后约每 5s 检查一次、连续约 30 次；30 次全失败才判定部署失败（约 150s 探测窗口），不是「N 秒后立即失败」。启动耗时长的应用建议调到 60–120",
                    "minimum": 0,
                    "type": "number"
                  },
                  "InternalAccess": {
                    "description": "内网访问开关配置，控制是否启用内网访问。true=启用内网访问（可通过云开发SDK直接调用），false=关闭内网访问（仅公网访问）",
                    "type": "string"
                  },
                  "InternalDomain": {
                    "description": "内网域名配置，用于配置服务的内网访问域名。仅在启用内网访问时有效",
                    "type": "string"
                  },
                  "LogParseType": {
                    "description": "日志解析类型配置，指定日志的解析方式。用于将原始日志解析为结构化数据",
                    "type": "string"
                  },
                  "LogSetId": {
                    "description": "CLS日志集ID配置，指定日志服务（CLS）的日志集ID。需要先开通CLS日志服务",
                    "type": "string"
                  },
                  "LogTopicId": {
                    "description": "CLS日志主题ID配置，指定日志服务（CLS）的日志主题ID。需要先开通CLS日志服务",
                    "type": "string"
                  },
                  "LogType": {
                    "description": "日志类型配置，指定服务的日志收集类型。影响日志的采集方式和存储格式",
                    "type": "string"
                  },
                  "MaxNum": {
                    "description": "最大实例数配置，控制服务的最大运行实例数量。当请求量增加时，服务最多可以扩展到指定数量的实例，超过此数量后将拒绝新的请求。建议根据业务峰值设置",
                    "minimum": 1,
                    "type": "number"
                  },
                  "Mem": {
                    "description": "内存规格配置，单位为GB。可选值：0.5、1、2、4、8、16等。注意：必须是CPU规格的2倍。影响服务性能和计费",
                    "exclusiveMinimum": 0,
                    "type": "number"
                  },
                  "MinNum": {
                    "description": "最小实例数配置，控制服务的最小运行实例数量。设置为0时支持缩容到0（无请求时不产生费用），设置为大于0时始终保持指定数量的实例运行（确保快速响应但会增加成本）。建议设置为1以降低冷启动延迟，提升用户体验",
                    "minimum": 0,
                    "type": "number"
                  },
                  "OpenAccessTypes": {
                    "description": "公网访问类型配置，控制服务的访问权限：OA=办公网访问，PUBLIC=公网访问（默认，可通过HTTPS域名访问），MINIAPP=小程序访问，VPC=VPC访问（仅同VPC内可访问）。可配置多个类型",
                    "items": {
                      "enum": [
                        "OA",
                        "PUBLIC",
                        "MINIAPP",
                        "VPC"
                      ],
                      "type": "string"
                    },
                    "maxItems": 4,
                    "type": "array"
                  },
                  "OperationMode": {
                    "description": "运行模式配置，指定服务的运行模式。影响服务的调度和资源分配方式",
                    "type": "string"
                  },
                  "PolicyDetails": {
                    "description": "扩缩容配置数组，用于配置服务的自动扩缩容策略。可配置多个扩缩容策略",
                    "items": {
                      "properties": {
                        "PolicyThreshold": {
                          "description": "扩缩容阈值，单位为百分比。如60表示当资源使用率达到60%时触发扩缩容",
                          "maximum": 100,
                          "minimum": 1,
                          "type": "number"
                        },
                        "PolicyType": {
                          "description": "扩缩容类型：cpu=基于CPU使用率扩缩容，mem=基于内存使用率扩缩容，cpu/mem=基于CPU和内存使用率扩缩容",
                          "enum": [
                            "cpu",
                            "mem",
                            "cpu/mem"
                          ],
                          "type": "string"
                        }
                      },
                      "required": [
                        "PolicyType",
                        "PolicyThreshold"
                      ],
                      "type": "object"
                    },
                    "maxItems": 10,
                    "type": "array"
                  },
                  "Port": {
                    "description": "服务监听端口配置。函数型服务固定为3000（函数框架自身监听该端口，业务代码不要自行 app.listen）；容器型服务可自定义，业务代码必须监听此端口",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": "number"
                  },
                  "PublicNetConf": {
                    "additionalProperties": false,
                    "description": "公网访问配置",
                    "properties": {
                      "PublicNetStatus": {
                        "description": "公网访问开关，取值 ENABLE=开启公网访问、DISABLE=关闭公网访问",
                        "enum": [
                          "ENABLE",
                          "DISABLE"
                        ],
                        "type": "string"
                      }
                    },
                    "type": "object"
                  },
                  "SessionAffinity": {
                    "description": "会话保持配置，用于控制是否启用会话保持功能。启用后会将同一客户端的请求路由到同一实例",
                    "type": "string"
                  },
                  "Tag": {
                    "description": "服务标签配置，用于标识服务类型。如设置为\"function:\"表示函数型服务。SDK会自动根据配置生成",
                    "type": "string"
                  },
                  "TimerScale": {
                    "description": "定时扩缩容配置数组，用于配置服务的定时自动扩缩容策略。可配置多个时间段的扩缩容计划，支持每日/每周/每月循环",
                    "items": {
                      "properties": {
                        "CycleType": {
                          "description": "循环类型：none=无循环，daily=每日循环，weekly=每周循环，monthly=每月循环",
                          "enum": [
                            "none",
                            "daily",
                            "weekly",
                            "monthly"
                          ],
                          "type": "string"
                        },
                        "EndDate": {
                          "description": "循环结束日期，格式：YYYY-MM-DD",
                          "type": "string"
                        },
                        "EndTime": {
                          "description": "结束时间，格式：HH:mm:ss",
                          "type": "string"
                        },
                        "ReplicaNum": {
                          "description": "定时扩缩容的目标副本数，最小值0（缩容到0）",
                          "minimum": 0,
                          "type": "number"
                        },
                        "StartDate": {
                          "description": "循环起始日期，格式：YYYY-MM-DD",
                          "type": "string"
                        },
                        "StartTime": {
                          "description": "起始时间，格式：HH:mm:ss",
                          "type": "string"
                        }
                      },
                      "required": [
                        "CycleType",
                        "StartTime",
                        "EndTime",
                        "ReplicaNum"
                      ],
                      "type": "object"
                    },
                    "maxItems": 10,
                    "type": "array"
                  },
                  "VolumesConf": {
                    "description": "存储挂载配置数组，按 Type 二选一：COS（对象存储桶）或 CFS（文件存储实例），两者必填字段不同",
                    "items": {
                      "oneOf": [
                        {
                          "additionalProperties": false,
                          "properties": {
                            "BucketName": {
                              "description": "COS 存储桶名称，仅 Type=COS 时必填",
                              "type": "string"
                            },
                            "DstPath": {
                              "description": "容器内的挂载目标路径，例如 /mnt/data",
                              "type": "string"
                            },
                            "Endpoint": {
                              "description": "COS 访问域名（Endpoint），仅 Type=COS 时可选填，不填走默认区域域名",
                              "type": "string"
                            },
                            "ReadOnly": {
                              "description": "是否只读挂载，默认读写",
                              "type": "boolean"
                            },
                            "SrcPath": {
                              "description": "远端源路径，留空表示挂载整个桶或实例根目录",
                              "type": "string"
                            },
                            "Type": {
                              "const": "COS",
                              "description": "挂载类型：COS=对象存储，CFS=云文件存储。Type 不同，需要的字段也不同",
                              "type": "string"
                            }
                          },
                          "required": [
                            "Type",
                            "BucketName",
                            "DstPath"
                          ],
                          "type": "object"
                        },
                        {
                          "additionalProperties": false,
                          "properties": {
                            "DstPath": {
                              "description": "容器内的挂载目标路径，例如 /mnt/data",
                              "type": "string"
                            },
                            "InstanceId": {
                              "description": "CFS 文件存储实例 ID，仅 Type=CFS 时必填",
                              "type": "string"
                            },
                            "KeyID": {
                              "description": "CFS 访问密钥 ID，仅 Type=CFS 时可选填",
                              "type": "string"
                            },
                            "MountIP": {
                              "description": "CFS 挂载 IP，仅 Type=CFS 时可选填",
                              "type": "string"
                            },
                            "ReadOnly": {
                              "description": "是否只读挂载，默认读写",
                              "type": "boolean"
                            },
                            "SrcPath": {
                              "description": "远端源路径，留空表示挂载整个桶或实例根目录",
                              "type": "string"
                            },
                            "Type": {
                              "const": "CFS",
                              "description": "挂载类型：COS=对象存储，CFS=云文件存储。Type 不同，需要的字段也不同",
                              "type": "string"
                            }
                          },
                          "required": [
                            "Type",
                            "InstanceId",
                            "DstPath"
                          ],
                          "type": "object"
                        }
                      ]
                    },
                    "maxItems": 10,
                    "type": "array"
                  },
                  "VpcConf": {
                    "description": "VPC网络配置（实例出网/私有网络）。用于让云托管实例接入指定 VPC，从而内网访问 MySQL/PostgreSQL/Redis/CVM 等资源。与 OpenAccessTypes（外部如何访问本服务）是不同概念。TCP 连库场景必须配置。禁止猜测 VpcId/SubnetId，须来自数据库控制台、已有资源详情、callCloudApi 或用户确认。创建时映射为 SDK vpcInfo(CreateType=2)；已存在服务可用 updateConfig 或 deploy（RMW 会保留未传入的远程 VpcConf）。部署/更新后必须用 queryCloudRun detail 复核 ServerConfig.VpcConf",
                    "properties": {
                      "SubnetId": {
                        "description": "子网ID，格式如 subnet-xxxxxxxx。云托管实例将占用该子网 IP，需确保有足够可用 IP",
                        "type": "string"
                      },
                      "VpcId": {
                        "description": "VPC网络ID，格式如 vpc-xxxxxxxx。必须与目标数据库/Redis 处于同一地域，并优先选择同一 VPC。禁止猜测或使用占位符；须来自数据库控制台、已有资源详情、callCloudApi 或用户确认。建议首次创建即配置；已存在服务也可在 deploy 时传入，部署后必须用 queryCloudRun detail 复核是否生效",
                        "type": "string"
                      }
                    },
                    "required": [
                      "VpcId",
                      "SubnetId"
                    ],
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "serverName": {
                "description": "云托管服务名称，用于标识和管理服务。命名规则：支持大小写字母、数字、连字符和下划线，必须以字母开头，长度3-45个字符。在init操作中会作为在targetPath下创建的子目录名，在其他操作中作为目标服务名。initEnv 操作不需要此参数",
                "pattern": "^[a-zA-Z][a-zA-Z0-9_-]{2,44}$",
                "type": "string"
              },
              "serverType": {
                "description": "服务类型配置：function=函数型云托管（仅支持Node.js，有特殊的开发要求和限制，适合简单的API服务），container=容器型服务（推荐使用，支持任意语言和框架如Java/Go/Python/PHP/.NET等，适合大多数应用场景）。不提供时自动检测：1)现有服务类型 2)有Dockerfile→container 3)有@cloudbase/aiagent-framework依赖→function 4)其他情况→container",
                "enum": [
                  "function",
                  "container"
                ],
                "type": "string"
              },
              "stablePercent": {
                "description": "稳定版本流量比例（trafficOp=set 时使用），取值范围0-100。与 canaryPercent 之和必须等于100。例如希望 90% 流量打到稳定版、10% 打到灰度版，则 stablePercent=90, canaryPercent=10",
                "maximum": 100,
                "minimum": 0,
                "type": "number"
              },
              "subnetIds": {
                "description": "子网 ID 列表（action=initEnv 时可选）。当需指定自有 VPC 时必填，如 [\"subnet-xxxxxxxx\"]。与 vpcId 一起透传给 CreateCloudRunEnv 的 SubNetIds",
                "items": {
                  "type": "string"
                },
                "maxItems": 20,
                "type": "array"
              },
              "targetPath": {
                "description": "本地代码路径，必须是绝对路径。在deploy操作中指定要部署的代码目录，在download操作中指定下载目标目录，在init操作中指定云托管服务的上级目录（会在该目录下创建以serverName命名的子目录）。updateConfig 不需要此参数。建议约定：项目根目录下的cloudrun/目录，例如：/Users/username/projects/my-project/cloudrun。必须指向具体的项目目录：文件系统根、家目录本身、/Users 本身、系统目录（含 /bin、/etc），以及 .ssh / Library / .config/.cloudbase 这类凭据或主机数据目录都会被拒绝。使用 imageUrl 部署已有镜像时此参数可省略。注意：本地有源码目录不等于必须走源码构建；若用户指定镜像请优先传 imageUrl，不要仅因存在 targetPath 就回退到源码构建",
                "type": "string"
              },
              "template": {
                "default": "helloworld",
                "description": "项目模板标识符，用于指定初始化项目时使用的模板。可通过queryCloudRun的templates操作获取可用模板列表。常用模板：helloworld=Hello World示例，nodejs=Node.js项目模板，python=Python项目模板等",
                "type": "string"
              },
              "trafficOp": {
                "description": "流量管理子操作（action=traffic 时使用）：set=调整灰度流量比例（需先部署新版本至灰度，通过 stablePercent/canaryPercent 设置稳定版与灰度版流量比例，两者之和必须等于100）；promote=将灰度版本全量发布（灰度版本流量置为100%并关闭灰度发布，等价于 tcb cloudrun traffic promote）；rollback=回滚到上一个稳定版本（停止当前灰度/发布中的版本，回到稳定版本，等价于 tcb cloudrun traffic rollback）",
                "enum": [
                  "set",
                  "promote",
                  "rollback"
                ],
                "type": "string"
              },
              "vpcId": {
                "description": "VPC 网络 ID（action=initEnv 时可选）。当平台拒绝系统创建网络时必填，格式如 vpc-xxxxxxxx。与 subnetIds 一起透传给 CreateCloudRunEnv 的 VpcId/SubNetIds。多数场景可不传（由系统创建网络）",
                "type": "string"
              },
              "waitRegistration": {
                "default": true,
                "description": "deploy 时是否等待平台登记本次发布（默认 true，最多约 45 秒）。等待是为了拿到后续查询所需的标识（源码构建的 BuildId / 镜像部署的 RunId）；设为 false 时只做一次探测就返回，响应更快，适合不需要 buildId、之后再按需查询发布任务状态的场景",
                "type": "boolean"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:a7450357c813c961c8aa6f786afbba7ffccdab36459450937ac7a1e4687aebaf"
        },
        {
          "id": "mcp:cloudbase-mcp/manageDataModel",
          "name": "manageDataModel",
          "title": "数据模型管理",
          "description": "数据模型查询工具，支持查询和列表数据模型（只读操作）。通过 action 参数区分操作类型：list=获取模型列表（不含Schema，可选 names 参数过滤），get=查询单个模型详情（含Schema字段列表、格式、关联关系等，需要提供 name 参数），docs=生成SDK使用文档（需要提供 name 参数）",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageDataModel"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：get=查询单个模型（含Schema字段列表、格式、关联关系，需要提供 name 参数），list=获取模型列表（不含Schema，可选 names 参数过滤），docs=生成SDK使用文档（需要提供 name 参数）",
                "enum": [
                  "get",
                  "list",
                  "docs"
                ],
                "type": "string"
              },
              "name": {
                "description": "要查询的数据模型名称。当 action='get' 或 action='docs' 时，此参数为必填项，必须提供已存在的数据模型名称。可通过 action='list' 操作获取可用的模型名称列表",
                "type": "string"
              },
              "names": {
                "description": "模型名称数组（list操作时可选，用于过滤）",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8c3511502187109a384856989d1bdc5a69fd1081a0752f1f06033c008f0fc6e7"
        },
        {
          "id": "mcp:cloudbase-mcp/manageEnv",
          "name": "manageEnv",
          "title": "CloudBase 环境管理（创建/变配/续费/安全域名）",
          "description": "管理 CloudBase 环境，支持：listPackages=查询可选套餐列表，create=创建新环境（需确认），modifyPlan=变更套餐（升降配，需确认），renew=续费环境（需确认），addSecurityDomain=添加环境安全域名（浏览器 CORS 白名单，不计费、无需确认），removeSecurityDomain=删除环境安全域名（不计费、无需确认）。\n\n⚠️ 涉及费用的操作（create/modifyPlan/renew），执行前必须展示配置摘要并等待用户通过 confirm=\"yes\" 确认；安全域名操作（addSecurityDomain/removeSecurityDomain）不计费，无需 confirm。\n\nℹ️ 安全域名＝浏览器跨域（CORS）白名单，控制允许哪些网页 origin（host:port）从浏览器直接调用本环境的 CloudBase 资源，不提供访问域名、不涉及 HTTPS 证书。给自己的域名绑定 HTTPS 访问入口（云托管/网关服务）属于 manageGateway（listCustomDomains/bindCustomDomain）的职责，与本工具无关。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageEnv"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：listPackages=查询可选套餐，create=创建环境，modifyPlan=变更套餐，renew=续费，addSecurityDomain=添加安全域名（CORS 白名单条目），removeSecurityDomain=删除安全域名",
                "enum": [
                  "listPackages",
                  "create",
                  "modifyPlan",
                  "renew",
                  "addSecurityDomain",
                  "removeSecurityDomain"
                ],
                "type": "string"
              },
              "alias": {
                "description": "环境别名（action=create 时必填）。要求：小写字母/数字/减号，不能以减号开头或结尾，最长 20 位",
                "type": "string"
              },
              "confirm": {
                "const": "yes",
                "description": "确认操作。所有付费操作（create/modifyPlan/renew）必须传 \"yes\" 确认",
                "type": "string"
              },
              "domains": {
                "description": "安全域名数组（格式：host:port，例如 localhost:5173 或 127.0.0.1:4173）。仅 action=addSecurityDomain/removeSecurityDomain 时有效且必填。注意：这是 CORS 白名单条目，不是自定义域名，不需要证书。添加前应先用 queryEnv(action=domains) 检查浏览器实际 origin 是否已在白名单中。",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "duration": {
                "description": "购买或续费时长（月），action=create/renew 时可选，默认 1",
                "maximum": 36,
                "minimum": 1,
                "type": "integer"
              },
              "envId": {
                "description": "环境 ID（action=modifyPlan/renew 时必填）",
                "type": "string"
              },
              "externalStorage": {
                "description": "云存储共享桶配置（action=create 时可选）。传入该对象表示该环境不再自动分配独立 COS 桶，而是使用指定桶作为云存储介质，通过 basePath 与同桶其他环境隔离；仅作用于云存储，静态托管的存储桶由平台在开通托管时分配。三个字段必须完整传入。⚠️ 与 region 同理：二次调用（confirm=\"yes\"）只读本次参数，漏传会创建出使用独立桶的环境且不报错。",
                "properties": {
                  "basePath": {
                    "description": "基础路径前缀，在同一共享桶内需唯一，用于与同桶其他环境隔离",
                    "minLength": 1,
                    "type": "string"
                  },
                  "bucketName": {
                    "description": "共享桶名称（COS 桶名）",
                    "minLength": 1,
                    "type": "string"
                  },
                  "region": {
                    "description": "共享桶所属地域，例如 ap-shanghai",
                    "minLength": 1,
                    "type": "string"
                  }
                },
                "required": [
                  "bucketName",
                  "region",
                  "basePath"
                ],
                "type": "object"
              },
              "packageId": {
                "description": "套餐 ID（action=create/modifyPlan 时必填）。取 manageEnv(action=\"listPackages\") 返回的 PackageName —— 那是新购 / 新建菜单里可选的套餐（个人版 baas_personal、标准版 baas_pf_standard、企业版 baas_pf_enterprise、企业高级版 baas_pf_enterprise_senior、体验版 baas_trial、集成版 baas_integration）。平台仍接受其它合法 packageId（旧版套餐族、需白名单的套餐），以实际创建结果为准。各站点可售套餐不同，不要凭记忆填写。",
                "type": "string"
              },
              "region": {
                "description": "创建地域（仅 action=create 时有效）。按 X-TC-Region 语义透传，决定新环境所在地域；等价 CLI：tcb env create --region ap-shanghai。不传则用当前会话地域（cloudBaseOptions.region → TCB_REGION → 项目配置 / rc 绑定 → 站点默认地域：国内站 ap-shanghai、国际站 ap-singapore）。注意：region 不写进 CreateEnv 请求体，而是通过请求层地域上下文生效——这与「请勿把 Region 放进 params」的 callCloudApi 约定一致。⚠️ ap-singapore 同时属于国内站与国际站，未显式指定站点时会被判定为国际站（site=intl）；如需在国内站该地域创建，请先 auth(site=\"domestic\") 或设置 TCB_SITE=domestic。",
                "enum": [
                  "ap-shanghai",
                  "ap-guangzhou",
                  "ap-singapore"
                ],
                "type": "string"
              },
              "resources": {
                "description": "启用的资源类型（action=create 时可选）。可选值：storage(存储)、function(云函数)、postgresql(PostgreSQL)，省略时默认全部三项。CreateEnv 要求 Resources 非空，MCP 会始终下发该字段。不再包含 flexdb(文档数据库)：新建环境不会创建 NoSQL 实例，其可用性以 queryEnv(action=\"info\") 返回的 EnvInfo.RuntimeBackends 为准。",
                "items": {
                  "enum": [
                    "storage",
                    "function",
                    "postgresql"
                  ],
                  "type": "string"
                },
                "maxItems": 3,
                "type": "array"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8f87f85071cbad9f8f0d647d1f3c0482a732ac4afd24e5946b62d167e0087f09"
        },
        {
          "id": "mcp:cloudbase-mcp/manageFunctions",
          "name": "manageFunctions",
          "title": "管理 CloudBase 云函数",
          "description": "CloudBase 云函数统一写入口。支持创建函数、更新代码、更新配置、调用函数、发布版本、配置流量别名、管理定时跑 / 定时任务 / scheduled job 的 timer 触发器和层绑定。部署包体积有硬上限：请勿把静态内容打进包里——媒体文件（视频、大图、字体）、用户上传的文件、以及频繁更新的静态资源都应放云存储按 URL 引用，否则每次改动都要重新部署函数，包还可能超限。如果要创建 cron 定时任务，先用 createFunction 创建函数，再用 createFunctionTrigger 创建 timer 触发器（支持7段cron表达式），deleteFunctionTrigger 删除触发器。版本发布：`publishVersion` 对齐 tcb fn publish-version / SDK publishVersion；灰度/切流：`updateFunctionAliasConfig` 对齐 tcb fn config-route / SDK updateFunctionAliasConfig（aliasName 默认 `$DEFAULT`）。HTTP 云函数镜像构建部署：createFunction / updateFunctionCode 通过 func.buildStrategy 区分。func.buildStrategy=image（已有镜像，填 func.imageConfig.imageUri）直接创建/更新 HTTP 函数；func.buildStrategy=local（本地 Docker 构建推送）、cloud（CloudApp 云端构建）走镜像构建部署编排（需要 func.imageConfig；build 非必填，缺省仓库坐标自动补齐：namespace 默认 envId、repository 默认函数名），默认仅生成 dry-run 计划；传入 dryRun=false 且 confirm=true 后执行真实部署。真实部署可传 wait=false 立即返回 taskId，再通过 queryFunctions 的 getFunctionDeployStatus 查询进度和结果。wait=false 仅表示当前 Tool 不等待完整部署；调用方不得在 status=running 时结束流程，必须自动轮询到 succeeded/failed 后再向用户汇报，除非达到轮询上限。local 始终要求本地 MCP 模式；cloud 的真实执行需要读取本地构建上下文，也要求本地 MCP 模式；cloud mode 仅支持 cloud dry-run 和 image 策略。func.buildStrategy 省略或为 zip 时按传统代码包部署。危险操作需要显式 confirm=true。\n\n**个人版 TCR 凭证**：imageType=personal 的 local/cloud 构建需要推送凭证。若 MCP 配置的 env 中已设置 TCB_TCR_USERNAME 与 TCB_TCR_PASSWORD（与 TENCENTCLOUD_SECRETID 等密钥同样的配置方式），则不需要在请求参数中传递 func.imageConfig.build.registryCredential，留空即可自动读取。不要向用户索要密码明文，也不要把密码写进工具参数。\n注意这条 env 通道只在**本地 stdio MCP、且客户端的 mcp.json 支持自定义 env 块**时可用：部分 GUI 客户端不继承 shell 的 export，IDE 内置型 MCP 的凭据注入通常是硬编码白名单（例如只放行 TENCENTCLOUD_*），这类用户没有配置自定义 env 的通道，「在 MCP 配置的 env 中设置」对他们是无效指引。面向内置 MCP 用户应改为引导：使用企业版（imageType=enterprise，走实例临时令牌，不需要固定密码），或改用 buildStrategy=image 直接部署已推送的镜像。\n**企业版登录态要求**：enterprise 的 cloud/local 构建要经 CAM 铸造 TCR 临时令牌，环境级 API Key 与 OAuth 换出的临时凭据都不带 CAM 策略，会被前置拦截并提示改用账号级密钥或 image 策略；个人版走静态密码直接 docker login，不经过 CAM，反而是 API Key 用户唯一能走通的构建路径。\n\n**层（Layer）说明**：\n- 层为 SCF 账号级共享命名空间：不同环境创建同名层会共享同一层的版本序列；删除某版本会影响所有绑定该版本的环境的函数\n- 创建层必须用带环境标识的唯一层名，固定格式：`{layerName}_{当前envId}`（如 `common_cloud1-d9ghadgak3edf6b36`）。不要在不同环境使用相同裸层名，创建前先 `listLayers` 查重\n- 相关 action：`createLayerVersion` / `deleteLayerVersion` / `attachLayer` / `detachLayer` / `updateFunctionLayers`（只读查询见 queryFunctions 的 listLayers / listLayerVersions / getLayerVersionDetail）",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageFunctions"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "写操作类型，例如 createFunction、updateFunctionCode、incrementalDeployFunction、invokeFunction、deleteFunction、createFunctionTrigger（定时任务 / cron / timer）、deleteFunctionTrigger、createLayerVersion、deleteLayerVersion、attachLayer、detachLayer、updateFunctionLayers、publishVersion（发布新版本，对齐 tcb fn publish-version）、updateFunctionAliasConfig（更新别名/流量路由，对齐 tcb fn config-route）。层名推荐固定格式 `{layerName}_{当前envId}`（如 common_cloud1-d9ghadgak3edf6b36）",
                "enum": [
                  "createFunction",
                  "updateFunctionCode",
                  "updateFunctionConfig",
                  "invokeFunction",
                  "deleteFunction",
                  "createFunctionTrigger",
                  "deleteFunctionTrigger",
                  "createLayerVersion",
                  "deleteLayerVersion",
                  "attachLayer",
                  "detachLayer",
                  "updateFunctionLayers",
                  "publishVersion",
                  "updateFunctionAliasConfig",
                  "incrementalDeployFunction"
                ],
                "type": "string"
              },
              "aliasName": {
                "description": "`updateFunctionAliasConfig` 的别名名称。省略时默认 `$DEFAULT`（与 tcb fn config-route 一致）",
                "type": "string"
              },
              "autoGrant": {
                "default": false,
                "description": "镜像部署是否允许 manager-node 自动补齐固定白名单 CAM 策略。默认 false；仅在明确确认权限变更时设为 true。",
                "type": "boolean"
              },
              "base64Content": {
                "description": "层内容的 base64 编码",
                "type": "string"
              },
              "code": {
                "additionalProperties": false,
                "description": "ZIP 两段式部署阶段 B：代码包已通过 queryFunctions action=getFunctionUploadUrl 上传到环境 COS 桶。三元组（cosBucketName/cosObjectName/cosBucketRegion）直接使用 getFunctionUploadUrl 返回值原样透传。传入 code 后 createFunction/updateFunctionCode 不再读取本地目录（functionRootPath/zipFile 均不需要），默认不触发云端依赖安装（可用 func.installDependency 覆盖）。code 三元组的桶与地域必须是本环境自有存储桶，对象 key 必须是 getFunctionUploadUrl 返回的 fnzip-upload/... 形式；自行拼装、指向其它存储桶或跨环境复用会被拒绝并要求重新取地址。",
                "properties": {
                  "cosBucketName": {
                    "description": "环境存储桶短名（不含 -appid 后缀），直接使用 getFunctionUploadUrl 返回的 cosBucketName，不要自填",
                    "type": "string"
                  },
                  "cosBucketRegion": {
                    "description": "存储桶地域，省略时自动使用当前环境存储桶地域",
                    "type": "string"
                  },
                  "cosObjectName": {
                    "description": "上传对象 key，直接使用 getFunctionUploadUrl 返回的 cosObjectName",
                    "type": "string"
                  }
                },
                "required": [
                  "cosBucketName",
                  "cosObjectName"
                ],
                "type": "object"
              },
              "codeSecret": {
                "description": "层绑定时的代码保护密钥",
                "type": "string"
              },
              "confirm": {
                "description": "危险操作确认开关。deleteFunction、deleteFunctionTrigger、deleteLayerVersion、detachLayer 等删除类操作以及镜像构建部署（func.buildStrategy=cloud/local）真实执行需要显式传入 confirm=true",
                "type": "boolean"
              },
              "contentPath": {
                "description": "仅 createLayerVersion 使用：层内容路径，可为目录或 ZIP 文件。更新函数代码请改用 functionRootPath / zipFile / code。",
                "type": "string"
              },
              "description": {
                "description": "描述信息。createLayerVersion 时为层版本描述；publishVersion / updateFunctionAliasConfig 时为版本或别名描述",
                "type": "string"
              },
              "dryRun": {
                "default": true,
                "description": "镜像构建部署（func.buildStrategy=cloud/local）是否只生成部署计划。默认 true；传 false 时必须同时传 confirm=true。",
                "type": "boolean"
              },
              "envVariables": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "配置更新时要合并的环境变量。若含 DATABASE_URL / MYSQL_* / POSTGRES_* / REDIS_* 等 TCP 连库变量，必须同时提供真实 vpc（或函数已绑定完整 VPC）。禁止猜测 vpcId/subnetId。",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "force": {
                "description": "createFunction 时是否覆盖",
                "type": "boolean"
              },
              "func": {
                "description": "createFunction / updateFunctionCode 的函数配置。镜像/构建部署通过 func.buildStrategy（zip/cloud/local/image）区分，镜像相关字段收敛在 func.imageConfig 命名空间下。",
                "properties": {
                  "buildStrategy": {
                    "description": "HTTP 函数部署策略：zip=代码包部署（默认，缺省即 zip）；image=使用已有镜像（imageConfig.imageUri 必填）；cloud=云端构建镜像；local=本地 Docker 构建镜像。cloud/local 走镜像构建部署编排，需要 imageConfig；其中 build 非必填：目标仓库坐标（namespace 默认 envId、repository 默认函数名）等缺省可自动补齐，仅在需要指定构建细节或个人版 build.registryCredential 等特定字段时才提供 build。",
                    "enum": [
                      "zip",
                      "cloud",
                      "local",
                      "image"
                    ],
                    "type": "string"
                  },
                  "envVariables": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "环境变量。若包含 DATABASE_URL / MYSQL_* / POSTGRES_* / REDIS_* 等传统 TCP 连库变量，必须同时配置 vpc（vpcId+subnetId），且 ID 必须来自真实库/网络信息，禁止猜测。原生 app.rdb()/app.database() 不需要 VPC。",
                    "propertyNames": {
                      "type": "string"
                    },
                    "type": "object"
                  },
                  "handler": {
                    "description": "函数入口",
                    "type": "string"
                  },
                  "ignore": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 200,
                        "type": "array"
                      }
                    ],
                    "description": "忽略文件"
                  },
                  "imageConfig": {
                    "additionalProperties": false,
                    "description": "镜像配置（buildStrategy=image/cloud/local 或 runtime=CustomImage 时使用），镜像相关字段全部收敛在此命名空间下。image：填 imageUri 使用已有镜像；cloud/local：可填 build 描述如何构建，省略时用默认仓库坐标自动补齐。传入已有镜像（imageUri）即按镜像部署处理，函数无需打包本地代码、scf_bootstrap 或 Handler。",
                    "properties": {
                      "args": {
                        "description": "覆盖镜像启动参数，空格分隔，例如 -u app.py。",
                        "type": "string"
                      },
                      "argsList": {
                        "description": "镜像启动参数的数组写法，元素已按参数切分，适用于参数本身含空格的场景。",
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "build": {
                        "additionalProperties": false,
                        "description": "镜像构建目标。buildStrategy=cloud（云端构建）或 local（本地 Docker 构建）时使用；buildStrategy=image（已有镜像）不填。cloud/local 下 build 非必填：缺省仓库坐标可自动补齐（namespace 默认 envId、repository 默认函数名），仅需指定构建细节或个人版 build.registryCredential 等字段时才填。",
                        "properties": {
                          "buildArgs": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "description": "Docker 构建参数。禁止传递密钥或凭证。",
                            "propertyNames": {
                              "type": "string"
                            },
                            "type": "object"
                          },
                          "cwd": {
                            "description": "镜像构建上下文的绝对目录。",
                            "type": "string"
                          },
                          "dockerfile": {
                            "description": "Dockerfile 相对 build.cwd 的路径，默认 Dockerfile。",
                            "type": "string"
                          },
                          "forceBuild": {
                            "description": "是否忽略同摘要复用并强制重新构建。",
                            "type": "boolean"
                          },
                          "namespace": {
                            "description": "目标镜像命名空间；不传时默认使用当前环境 ID（envId）。",
                            "minLength": 1,
                            "type": "string"
                          },
                          "platform": {
                            "const": "linux/amd64",
                            "description": "目标镜像平台，当前仅支持 linux/amd64。",
                            "type": "string"
                          },
                          "registryCredential": {
                            "additionalProperties": false,
                            "description": "个人版 TCR 推送凭证（personal local/cloud 需要）。推荐整体省略，改为在 MCP 配置的 env 中设置 TCB_TCR_USERNAME 与 TCB_TCR_PASSWORD，与 TENCENTCLOUD_SECRETID 等密钥的配置方式一致；已设置环境变量时不需要在请求参数中传递凭证。字段级回退：显式传入的字段优先，未传字段读环境变量。",
                            "properties": {
                              "password": {
                                "description": "个人版 CCR 固定密码。**不要在此字段填写明文密码**：请在 MCP 配置的 env 中设置 TCB_TCR_PASSWORD，本字段留空即可自动读取。敏感字段，禁止写入日志或响应。",
                                "maxLength": 16384,
                                "minLength": 1,
                                "type": "string"
                              },
                              "username": {
                                "description": "个人版 CCR 登录用户名，必须为腾讯云账号 UIN。省略时回退读取 MCP 进程的 TCB_TCR_USERNAME 环境变量。",
                                "pattern": "^\\d{5,20}$",
                                "type": "string"
                              }
                            },
                            "type": "object"
                          },
                          "registryId": {
                            "description": "企业版 TCR 实例 ID；personal 镜像构建不填。",
                            "minLength": 1,
                            "type": "string"
                          },
                          "repository": {
                            "description": "不含 tag/digest 的目标仓库路径；不传时默认使用函数名。local personal 需填写完整 registry/namespace/repository。",
                            "minLength": 1,
                            "type": "string"
                          },
                          "retainedTags": {
                            "description": "个人版 TCR 构建完成后保留的最新镜像标签数量。",
                            "exclusiveMinimum": 0,
                            "maximum": 9007199254740991,
                            "type": "integer"
                          },
                          "tag": {
                            "description": "local 策略的目标镜像 tag；cloud 策略由平台生成，不填。",
                            "pattern": "^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$",
                            "type": "string"
                          }
                        },
                        "required": [
                          "cwd"
                        ],
                        "type": "object"
                      },
                      "command": {
                        "description": "覆盖镜像启动命令，例如 python；不填则使用镜像 Dockerfile 中的默认值。",
                        "type": "string"
                      },
                      "commandList": {
                        "description": "镜像启动命令的数组写法，元素已按参数切分，适用于命令本身含空格的场景。",
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "containerImageAccelerate": {
                        "description": "是否开启镜像加速；镜像较大时建议开启以缩短冷启动时间。",
                        "type": "boolean"
                      },
                      "entryPoint": {
                        "description": "覆盖镜像入口点（ENTRYPOINT），一般不需要单独设置。",
                        "minLength": 1,
                        "type": "string"
                      },
                      "imagePort": {
                        "const": 9000,
                        "description": "HTTP 镜像函数监听端口，SDK 仅允许 9000；省略即用该值，不要填其他端口。",
                        "type": "number"
                      },
                      "imageType": {
                        "description": "镜像仓库类型：enterprise=企业版 TCR，personal=个人版 CCR；省略时由 SDK 推断——填了 registryId 推断为 enterprise，否则推断为 personal。",
                        "enum": [
                          "enterprise",
                          "personal"
                        ],
                        "type": "string"
                      },
                      "imageUri": {
                        "description": "完整镜像地址（必须含 tag），格式 {domain}/{namespace}/{image}:{tag}，例如 ccr.ccs.tencentyun.com/your-ns/demo-app:demo-app-001。不要使用 :latest。buildStrategy=image（已有镜像）时必填；buildStrategy=cloud/local 可以不填：镜像地址由构建流程产出并回传；目标仓库由 build.repository/build.namespace 决定，显式提供时优先使用你提供的配置，省略时由 manager-node 用默认值自动补齐并创建/复用（namespace 默认 envId、repository 默认函数名）。",
                        "type": "string"
                      },
                      "localFallback": {
                        "description": "buildStrategy=local 时本地构建不可用的处理方式，默认 error。",
                        "enum": [
                          "cloud",
                          "error"
                        ],
                        "type": "string"
                      },
                      "registryId": {
                        "description": "企业版 TCR 实例 ID，形如 tcr-xxxxxxxx；imageType=enterprise 时必填，个人版镜像不填。",
                        "minLength": 1,
                        "type": "string"
                      }
                    },
                    "type": "object"
                  },
                  "instanceConcurrencyConfig": {
                    "properties": {
                      "dynamicEnabled": {
                        "type": "boolean"
                      },
                      "maxConcurrency": {
                        "type": "number"
                      }
                    },
                    "type": "object"
                  },
                  "isWaitInstall": {
                    "description": "是否等待依赖安装",
                    "type": "boolean"
                  },
                  "layers": {
                    "description": "Layer 配置",
                    "items": {
                      "properties": {
                        "name": {
                          "type": "string"
                        },
                        "version": {
                          "type": "number"
                        }
                      },
                      "required": [
                        "name",
                        "version"
                      ],
                      "type": "object"
                    },
                    "maxItems": 10,
                    "type": "array"
                  },
                  "name": {
                    "description": "函数名称",
                    "type": "string"
                  },
                  "protocolParams": {
                    "properties": {
                      "wsParams": {
                        "properties": {
                          "idleTimeOut": {
                            "description": "WebSocket 空闲超时时间（秒）",
                            "type": "number"
                          }
                        },
                        "type": "object"
                      }
                    },
                    "type": "object"
                  },
                  "protocolType": {
                    "description": "HTTP 函数访问协议，当前仅支持 WebSockets，取值为 WS（配合 protocolParams.wsParams 使用）。普通 HTTP 函数不要传此字段；传其他值（如 HTTP）会报 InvalidParameterValue.ProtocolType。",
                    "enum": [
                      "WS"
                    ],
                    "type": "string"
                  },
                  "runtime": {
                    "description": "运行时环境。Event 函数支持多种运行时:\n  Nodejs: Nodejs22.21, Nodejs20.19, Nodejs18.15, Nodejs16.13, Nodejs14.18, Nodejs12.16, Nodejs10.15, Nodejs8.9\n  Python: Python3.10, Python3.9, Python3.7, Python3.6, Python2.7\n  Php: Php8.0, Php7.4, Php7.2\n  Java: Java8, Java11\n  Golang: Golang1\n\n推荐运行时:\n  Node.js: Nodejs18.15\n  Python: Python3.9\n  PHP: Php7.4\n  Java: Java11\n  Go: Golang1\n\n镜像部署（基于 TCR 镜像创建函数）时填 \"CustomImage\"，并提供 imageConfig；此时无需 functionRootPath/zipFile。",
                    "type": "string"
                  },
                  "timeout": {
                    "description": "函数超时时间",
                    "type": "number"
                  },
                  "triggers": {
                    "description": "触发器配置数组",
                    "items": {
                      "properties": {
                        "config": {
                          "description": "触发器配置。timer 必须使用 CloudBase 7 段 cron 格式：秒 分 时 日 月 星期 年。⚠️ 不支持标准 5 段 cron（如 */5 * * * * 是错误的）。正确示例：0 */5 * * * * *（每5分钟）、0 0 2 1 * * *（每月1号2点）、0 30 9 * * * *（每天9:30）",
                          "type": "string"
                        },
                        "name": {
                          "description": "触发器名称",
                          "type": "string"
                        },
                        "type": {
                          "description": "触发器类型",
                          "enum": [
                            "timer"
                          ],
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "type",
                        "config"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  },
                  "type": {
                    "description": "函数类型",
                    "enum": [
                      "Event",
                      "HTTP"
                    ],
                    "type": "string"
                  },
                  "vpc": {
                    "description": "私有网络配置（出网）。非原生 SDK、用 TCP 访问 VPC 内 MySQL/PostgreSQL/Redis 时必填。vpcId/subnetId 必须与数据库内网 VPC 一致；未知时先查控制台或询问用户，禁止填占位符。",
                    "properties": {
                      "subnetId": {
                        "description": "Subnet ID in the same VPC as the private DB endpoint (e.g. subnet-xxxxxxxx). Do NOT invent or use placeholders.",
                        "type": "string"
                      },
                      "vpcId": {
                        "description": "VPC ID from the real database/network console (e.g. vpc-xxxxxxxx). Required for non-native TCP DB access. Do NOT invent or use placeholders.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "vpcId",
                      "subnetId"
                    ],
                    "type": "object"
                  }
                },
                "required": [
                  "name"
                ],
                "type": "object"
              },
              "functionName": {
                "description": "目标函数名称（顶层）。updateFunctionCode / updateFunctionConfig / invokeFunction / publishVersion / updateFunctionAliasConfig 等 action 使用此字段。不要只写在 func.name：createFunction 用 func.name，其它 action 用顶层 functionName。若误传 func.name，也会被识别为 functionName。",
                "type": "string"
              },
              "functionRootPath": {
                "description": "创建或更新函数代码时默认推荐的本地目录方式。必须是直接包含函数文件夹的目录绝对路径（如 /abs/path/cloudfunctions 或 /abs/path/functions），不要传项目根目录（如 /abs/path），也不要传到函数名子目录（如 /abs/path/cloudfunctions/hello）。本地应按 cloudfunctions/<functionName>/index.js 或 functions/<functionName>/index.js 布局，此参数传 cloudfunctions 或 functions 目录的绝对路径。SDK 会自动拼接函数名子目录，无需预先压缩 zip 或 base64 编码。",
                "type": "string"
              },
              "functionVersion": {
                "description": "`updateFunctionAliasConfig` 的主版本。可为具体版本号或 `$LATEST`",
                "type": "string"
              },
              "handler": {
                "description": "函数入口",
                "type": "string"
              },
              "incrementalFile": {
                "description": "incrementalDeployFunction 增量部署时的变更文件路径",
                "type": "string"
              },
              "layerName": {
                "description": "层名称。创建层推荐固定格式 `{layerName}_{当前envId}`（如 common_cloud1-d9ghadgak3edf6b36）；不要跨环境复用裸层名。层为账号级共享命名空间",
                "type": "string"
              },
              "layerVersion": {
                "description": "层版本号",
                "type": "number"
              },
              "layers": {
                "description": "updateFunctionLayers 的目标层列表，顺序即最终顺序",
                "items": {
                  "properties": {
                    "layerName": {
                      "description": "层名称",
                      "type": "string"
                    },
                    "layerVersion": {
                      "description": "层版本号",
                      "type": "number"
                    }
                  },
                  "required": [
                    "layerName",
                    "layerVersion"
                  ],
                  "type": "object"
                },
                "maxItems": 10,
                "type": "array"
              },
              "licenseInfo": {
                "description": "层许可证信息",
                "type": "string"
              },
              "params": {
                "additionalProperties": {},
                "description": "invokeFunction 的调用参数",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "routingConfig": {
                "description": "`updateFunctionAliasConfig` 的流量路由配置。AdditionalVersionWeights 用于灰度权重；AddtionVersionMatchs 为 SCF/SDK 历史字段名（含拼写）",
                "properties": {
                  "AdditionalVersionWeights": {
                    "description": "附加版本权重列表（灰度发布）",
                    "items": {
                      "properties": {
                        "Version": {
                          "description": "附加流量版本号",
                          "type": "string"
                        },
                        "Weight": {
                          "description": "附加流量权重（0-1 或百分比，按 SCF 约定）",
                          "type": "number"
                        }
                      },
                      "required": [
                        "Version",
                        "Weight"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  },
                  "AddtionVersionMatchs": {
                    "description": "附加版本匹配规则列表（字段名保持 SCF AddtionVersionMatchs）",
                    "items": {
                      "properties": {
                        "Expression": {
                          "description": "匹配表达式",
                          "type": "string"
                        },
                        "Key": {
                          "description": "匹配规则的 Header/Query Key",
                          "type": "string"
                        },
                        "Method": {
                          "description": "匹配方法，如 Exact / Regex",
                          "type": "string"
                        },
                        "Version": {
                          "description": "匹配规则指向的版本号",
                          "type": "string"
                        }
                      },
                      "required": [
                        "Version",
                        "Key",
                        "Method",
                        "Expression"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  }
                },
                "type": "object"
              },
              "runtimes": {
                "description": "层适用的运行时列表",
                "items": {
                  "type": "string"
                },
                "maxItems": 50,
                "type": "array"
              },
              "timeout": {
                "description": "配置更新时的超时时间",
                "type": "number"
              },
              "triggerName": {
                "description": "deleteFunctionTrigger 的目标触发器名称",
                "type": "string"
              },
              "triggers": {
                "description": "createFunctionTrigger 的触发器列表，用于定时跑 / 定时任务 / scheduled job。timer 触发器使用7段 cron 表达式（秒 分 时 日 月 星期 年），如 \"0 */5 * * * * *\" 表示每5分钟执行一次",
                "items": {
                  "properties": {
                    "config": {
                      "description": "触发器配置。timer 必须使用 CloudBase 7 段 cron 格式：秒 分 时 日 月 星期 年。⚠️ 不支持标准 5 段 cron（如 */5 * * * * 是错误的）。正确示例：0 */5 * * * * *（每5分钟）、0 0 2 1 * * *（每月1号2点）、0 30 9 * * * *（每天9:30）",
                      "type": "string"
                    },
                    "name": {
                      "description": "触发器名称",
                      "type": "string"
                    },
                    "type": {
                      "description": "触发器类型",
                      "enum": [
                        "timer"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "name",
                    "type",
                    "config"
                  ],
                  "type": "object"
                },
                "maxItems": 20,
                "type": "array"
              },
              "vpc": {
                "description": "配置更新时的 VPC 信息。非原生 TCP 连库场景必填真实 vpcId+subnetId；不要用占位符。",
                "properties": {
                  "subnetId": {
                    "description": "Subnet ID in the same VPC as the private DB endpoint (e.g. subnet-xxxxxxxx). Do NOT invent or use placeholders.",
                    "type": "string"
                  },
                  "vpcId": {
                    "description": "VPC ID from the real database/network console (e.g. vpc-xxxxxxxx). Required for non-native TCP DB access. Do NOT invent or use placeholders.",
                    "type": "string"
                  }
                },
                "required": [
                  "vpcId",
                  "subnetId"
                ],
                "type": "object"
              },
              "wait": {
                "default": true,
                "description": "真实镜像部署是否等待完整部署；设为 false 立即返回 taskId 并后台执行。默认 true 是为了兼容既有调用方，但同步等待最长可达约 15 分钟，很容易先撞上 MCP Client 的请求超时——客户端超时只是断开这次请求，云端部署仍在继续，却拿不到 taskId 追踪。因此执行真实构建部署（buildStrategy=cloud/local，dryRun=false）时建议显式传 wait=false。",
                "type": "boolean"
              },
              "zipFile": {
                "description": "仅兼容特殊场景：预先准备好的代码包 base64 编码。普通 createFunction/updateFunctionCode 默认不要先压缩 zip，优先使用 functionRootPath。",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:73044279cb1cb01974824b02dd3c475794b9b122440c42d819d4e71fd3fd9ddb"
        },
        {
          "id": "mcp:cloudbase-mcp/manageGateway",
          "name": "manageGateway",
          "title": "管理 CloudBase 网关",
          "description": "CloudBase HTTP 网关统一写入口（Domain/Route）。createRoute/updateRoute/deleteRoute 把域名下的 path 转到上游；enableRoute/disableRoute 启用或禁用已有路由（底层 ModifyHTTPServiceRoute 的 Routes[].Enable，不是 ModifyGatewayRoute）。未传 domain 时用 DomainType=HTTPSERVICE 的 IsDefault 默认 HTTP 域名（形如 *.{region}.app.tcloudbase.com），不会使用静态托管 CDN 域名（*.tcloudbaseapp.com，DomainType=STATIC_STORE）。这是网关默认域上的路径路由，不是 STATIC_STORE 上游绑定；STATIC_STORE 上游必须显式传 upstreamResourceType=STATIC_STORE。关闭静态托管默认域名（*.tcloudbaseapp.com）：先 queryGateway(listRoutes) 找到 DomainType=STATIC_STORE 且 IsDefault=true 的 domain，再 manageGateway(action=\"disableRoute\", domain=该域名, path=\"/\")；勿用 manageHosting。创建后可用 queryGateway(action=\"listRoutes\") 核对 Domain / DomainType / Path / UpstreamResourceType。上游类型只用一个参数 upstreamResourceType（也可写在 route.upstreamResourceType，route 优先）：WEB_SCF=HTTP云函数，SCF=Event云函数，CBR=云托管，STATIC_STORE=静态托管，STORAGE=云存储，LH=轻量应用服务器；配合 targetName 或 route.serviceName（云函数名/云托管服务名/静态托管实例名，常见 staticstore/云存储实例名）。createRoute 只建网关入口，不改上游权限。enablePathTransmission：默认 false 剥触发路径前缀；true 透传完整路径（CBR 多路由、WEB_SCF 自管子路径常需 true；STATIC_STORE 自定义触发路径映射站点根通常 false）。⚠️ 自定义域名访问：若环境已有自定义域名（先 queryGateway listCustomDomains），优先 createRoute 并显式传入该 domain，无需 certificateId；仅首次绑定全新自定义域名时用 bindCustomDomain（certificateId 可选：未传时按域名自动检索证书，单证书自动选用、多证书返回选择指引）。createRoute / bindCustomDomain 创建前会调用 VerifyHTTPServiceRoute 做归属权等预检（探测→创建）；失败时返回 data.checks 与 DNS TXT 指引，配置后重试。CORS/安全域名（浏览器跨域白名单，与本工具的网关自定义域名无关）用 manageEnv(action=addSecurityDomain/removeSecurityDomain)。enableService/authSwitch：HTTP 网关总开关与访问鉴权开关；createRoute 后若访问报 HTTPSERVICE_NONACTIVATED，通常是总开关未开启（用 queryGateway getPrivilege 查询、enableService 开启）。purgeCache：清除域名缓存（CDN/EO，按 URL/前缀/整站），返回 TaskId 后用 queryGateway cachePurgeTask 查进度。路由级还支持 enableSafeDomain（跨域/合法域名校验）、pathRewrite（路径重写）、qpsPolicy（限频）、extension（自定义请求/响应头与缓存规则）；域名级支持 protocol 与 domainExtension。updateRoute 只传要改的字段即可，未传的 CORS/重写/限频/扩展配置会保持原值。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageGateway"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "accessType": {
                "description": "绑定类型（仅 bindCustomDomain，默认 DIRECT）。DIRECT=直连（普通绑域名用这个）；CDN=云开发 CDN；CUSTOM=自有 CDN/WAF（需 customCname）。详见 https://docs.cloudbase.net/service/custom-domain",
                "enum": [
                  "DIRECT",
                  "CDN",
                  "CUSTOM"
                ],
                "type": "string"
              },
              "action": {
                "description": "写操作：createRoute/updateRoute/deleteRoute 管理路由；enableRoute/disableRoute 启用或禁用已有路由（需 path，建议显式传 domain）；bindCustomDomain/deleteCustomDomain 管理自定义域名；enableService/authSwitch 开关 HTTP 网关总开关与访问鉴权（需配合 enable 参数）。createRoute/updateRoute 必须提供 upstreamResourceType；enableRoute/disableRoute 会先 listRoutes 定位已有路由，通常不必重填上游。updateRoute 也可传 enable/route.enable 直接改 Routes[].Enable。关闭 *.tcloudbaseapp.com 默认静态托管域：disableRoute + domain=该 STATIC_STORE IsDefault 域名 + path=\"/\"。已有自定义域名时优先 createRoute(domain=已有域名) 实现访问，不必再次 bindCustomDomain / 传入 certificateId；bindCustomDomain 仅用于首次绑定新域名（certificateId 可选，未传则按域名自动检索；可选 accessType=DIRECT|CDN|CUSTOM，CUSTOM 需 customCname；普通场景用默认 DIRECT）。createRoute/bindCustomDomain 创建前会 VerifyHTTPServiceRoute 预检；失败时按返回的 DNS TXT 指引配置后重试。purgeCache 清除域名缓存：需 domain 与 targets（配 purgeType=PURGE_URL|PURGE_PREFIX|PURGE_HOST，可选 cacheType=CDN|EO）。接入说明：https://docs.cloudbase.net/service/custom-domain",
                "enum": [
                  "createRoute",
                  "updateRoute",
                  "deleteRoute",
                  "enableRoute",
                  "disableRoute",
                  "bindCustomDomain",
                  "deleteCustomDomain",
                  "enableService",
                  "authSwitch",
                  "purgeCache"
                ],
                "type": "string"
              },
              "auth": {
                "description": "网关路径鉴权（EnableAuth）。匿名/浏览器公网访问通常 false。只控制网关入口；云函数安全规则、云托管鉴权、静态托管权限需各自工具另行配置。",
                "type": "boolean"
              },
              "cacheType": {
                "description": "缓存层（仅 purgeCache）：CDN 或 EO。省略时按域名接入方式自动匹配（EO→EO、CDN→CDN）；DIRECT / CUSTOM / NONE 的域没有 CloudBase 托管的缓存，会直接拒绝并说明原因。",
                "enum": [
                  "CDN",
                  "EO"
                ],
                "type": "string"
              },
              "certificateId": {
                "description": "证书 ID。仅 bindCustomDomain 使用：显式传入时跳过自动检索；省略时按 domain 调用 describeCertificates(SearchKey=domain)——单证书自动选用，无证书报错，多证书返回结构化选择指引（MCP 非交互）。在已有自定义域名上 createRoute / updateRoute / deleteRoute 不需要 certificateId。",
                "type": "string"
              },
              "customCname": {
                "description": "自有 CDN/WAF 的回源/回填地址（仅 bindCustomDomain 且 accessType=CUSTOM）。不是 DNS 里用户域名要解析到的那个 CNAME；DIRECT/CDN 不要传。详见 https://docs.cloudbase.net/service/custom-domain",
                "type": "string"
              },
              "domain": {
                "description": "域名。省略时自动使用环境 DomainType=HTTPSERVICE 的 IsDefault 默认 HTTP 域名（*.{region}.app.tcloudbase.com），不会回退到静态托管 CDN 域名（*.tcloudbaseapp.com，DomainType=STATIC_STORE）；也不是 STATIC_STORE 上游绑定。可用 queryGateway(action=\"listRoutes\") 核对实际 Domain / DomainType。enableRoute/disableRoute 操作 *.tcloudbaseapp.com 时必须显式传入该域名。已有自定义域名时请显式传入该域名并 createRoute/updateRoute/deleteRoute，即可实现自定义域名访问且无需证书 ID；仅 bindCustomDomain 时表示要新绑定的域名。",
                "type": "string"
              },
              "domainExtension": {
                "description": "域名级扩展（Extension），作用于整个域名（含该域名下所有路径）的自定义头与缓存规则，结构同 extension。缓存规则通常配在域名级；仅 createRoute/updateRoute/bindCustomDomain 生效。⚠️ 同 extension：默认域不支持自定义响应头，需自定义域名。",
                "properties": {
                  "cache": {
                    "properties": {
                      "rules": {
                        "items": {
                          "properties": {
                            "actions": {
                              "description": "缓存动作数组：type=Cache 配 cache{followOrigin,noCache,cacheTime,maxAgeTime}（三者互斥，需开启其一）；type=CacheKey 配 cacheKey{fullUrlCache,queryStringSwitch,queryStringAction,queryStringValues}",
                              "items": {
                                "properties": {
                                  "cache": {
                                    "properties": {
                                      "cacheTime": {
                                        "maximum": 9007199254740991,
                                        "minimum": 0,
                                        "type": "integer"
                                      },
                                      "followOrigin": {
                                        "type": "boolean"
                                      },
                                      "maxAgeTime": {
                                        "maximum": 9007199254740991,
                                        "minimum": 0,
                                        "type": "integer"
                                      },
                                      "noCache": {
                                        "type": "boolean"
                                      }
                                    },
                                    "type": "object"
                                  },
                                  "cacheKey": {
                                    "properties": {
                                      "fullUrlCache": {
                                        "enum": [
                                          "on",
                                          "off"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringAction": {
                                        "enum": [
                                          "includeCustom",
                                          "excludeCustom"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringSwitch": {
                                        "enum": [
                                          "on",
                                          "off"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringValues": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "maxItems": 50,
                                        "type": "array"
                                      }
                                    },
                                    "type": "object"
                                  },
                                  "type": {
                                    "enum": [
                                      "Cache",
                                      "CacheKey"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "type": "object"
                              },
                              "maxItems": 20,
                              "type": "array"
                            },
                            "condition": {
                              "description": "缓存规则匹配条件：target=url_path/file_extension/full_uri，matchType=prefix/suffix/contains/exact，values=匹配值数组",
                              "properties": {
                                "matchType": {
                                  "enum": [
                                    "prefix",
                                    "suffix",
                                    "contains",
                                    "exact"
                                  ],
                                  "type": "string"
                                },
                                "target": {
                                  "enum": [
                                    "url_path",
                                    "file_extension",
                                    "full_uri"
                                  ],
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "maxItems": 50,
                                  "type": "array"
                                }
                              },
                              "type": "object"
                            },
                            "description": {
                              "type": "string"
                            },
                            "enable": {
                              "type": "boolean"
                            }
                          },
                          "required": [
                            "condition",
                            "actions"
                          ],
                          "type": "object"
                        },
                        "maxItems": 50,
                        "type": "array"
                      }
                    },
                    "type": "object"
                  },
                  "headersHandler": {
                    "properties": {
                      "requestHeadersToAdd": {
                        "items": {
                          "properties": {
                            "action": {
                              "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                              "enum": [
                                "APPEND_IF_EXISTS_OR_ADD",
                                "ADD_IF_ABSENT",
                                "OVERWRITE_IF_EXISTS_OR_ADD",
                                "OVERWRITE_IF_EXISTS"
                              ],
                              "type": "string"
                            },
                            "key": {
                              "description": "请求/响应头名称，如 X-Frame-Options",
                              "type": "string"
                            },
                            "value": {
                              "description": "请求/响应头取值，如 SAMEORIGIN",
                              "type": "string"
                            }
                          },
                          "required": [
                            "key",
                            "value"
                          ],
                          "type": "object"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "requestHeadersToRemove": {
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "responseHeadersToAdd": {
                        "items": {
                          "properties": {
                            "action": {
                              "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                              "enum": [
                                "APPEND_IF_EXISTS_OR_ADD",
                                "ADD_IF_ABSENT",
                                "OVERWRITE_IF_EXISTS_OR_ADD",
                                "OVERWRITE_IF_EXISTS"
                              ],
                              "type": "string"
                            },
                            "key": {
                              "description": "请求/响应头名称，如 X-Frame-Options",
                              "type": "string"
                            },
                            "value": {
                              "description": "请求/响应头取值，如 SAMEORIGIN",
                              "type": "string"
                            }
                          },
                          "required": [
                            "key",
                            "value"
                          ],
                          "type": "object"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "responseHeadersToRemove": {
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      }
                    },
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "enable": {
                "description": "开关目标状态：enableService / authSwitch 必填（true 开启 / false 关闭）；bindCustomDomain 可选：enable=false 表示绑定后禁用域名（默认启用）；updateRoute 可选：映射到 Routes[].Enable（也可用 route.enable，route 优先；也可用专用 action enableRoute/disableRoute）。省略或非布尔值在 enableService/authSwitch 会返回参数错误。",
                "type": "boolean"
              },
              "enablePathTransmission": {
                "description": "路径透传（EnablePathTransmission），平台默认 false。例 path=/api 且请求 /api/users：false→上游收到 /users；true→上游收到 /api/users。CBR 云托管（Express 等自管子路由）与 WEB_SCF 多路径函数常需 true；STATIC_STORE 把触发路径映射到站点根目录（如 /app → 托管 /）时通常 false；单入口/根路径处理保持 false。也可用 route.enablePathTransmission（route 优先）。",
                "type": "boolean"
              },
              "enableSafeDomain": {
                "description": "跨域/合法域名校验（EnableSafeDomain），即控制台的「跨域设置」。true 时校验请求来源域名，false 时不校验（浏览器直连调用 API 的常见选择）。也可用 route.enableSafeDomain（route 优先）。",
                "type": "boolean"
              },
              "extension": {
                "description": "路由级扩展（Extension），可配自定义请求/响应头与缓存规则。{headersHandler:{requestHeadersToAdd,requestHeadersToRemove,responseHeadersToAdd,responseHeadersToRemove},cache:{rules:[{description,enable,condition:{target,matchType,values},actions:[{type:\"Cache\"|\"CacheKey\",cache,cacheKey}]}]}}。⚠️ 默认域（*.{region}.app.tcloudbase.com）不支持自定义响应头，后端会拒绝（实测 2026-10-21），需要自定义域名才能配。也可用 route.extension（route 优先）。",
                "properties": {
                  "cache": {
                    "properties": {
                      "rules": {
                        "items": {
                          "properties": {
                            "actions": {
                              "description": "缓存动作数组：type=Cache 配 cache{followOrigin,noCache,cacheTime,maxAgeTime}（三者互斥，需开启其一）；type=CacheKey 配 cacheKey{fullUrlCache,queryStringSwitch,queryStringAction,queryStringValues}",
                              "items": {
                                "properties": {
                                  "cache": {
                                    "properties": {
                                      "cacheTime": {
                                        "maximum": 9007199254740991,
                                        "minimum": 0,
                                        "type": "integer"
                                      },
                                      "followOrigin": {
                                        "type": "boolean"
                                      },
                                      "maxAgeTime": {
                                        "maximum": 9007199254740991,
                                        "minimum": 0,
                                        "type": "integer"
                                      },
                                      "noCache": {
                                        "type": "boolean"
                                      }
                                    },
                                    "type": "object"
                                  },
                                  "cacheKey": {
                                    "properties": {
                                      "fullUrlCache": {
                                        "enum": [
                                          "on",
                                          "off"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringAction": {
                                        "enum": [
                                          "includeCustom",
                                          "excludeCustom"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringSwitch": {
                                        "enum": [
                                          "on",
                                          "off"
                                        ],
                                        "type": "string"
                                      },
                                      "queryStringValues": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "maxItems": 50,
                                        "type": "array"
                                      }
                                    },
                                    "type": "object"
                                  },
                                  "type": {
                                    "enum": [
                                      "Cache",
                                      "CacheKey"
                                    ],
                                    "type": "string"
                                  }
                                },
                                "type": "object"
                              },
                              "maxItems": 20,
                              "type": "array"
                            },
                            "condition": {
                              "description": "缓存规则匹配条件：target=url_path/file_extension/full_uri，matchType=prefix/suffix/contains/exact，values=匹配值数组",
                              "properties": {
                                "matchType": {
                                  "enum": [
                                    "prefix",
                                    "suffix",
                                    "contains",
                                    "exact"
                                  ],
                                  "type": "string"
                                },
                                "target": {
                                  "enum": [
                                    "url_path",
                                    "file_extension",
                                    "full_uri"
                                  ],
                                  "type": "string"
                                },
                                "values": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "maxItems": 50,
                                  "type": "array"
                                }
                              },
                              "type": "object"
                            },
                            "description": {
                              "type": "string"
                            },
                            "enable": {
                              "type": "boolean"
                            }
                          },
                          "required": [
                            "condition",
                            "actions"
                          ],
                          "type": "object"
                        },
                        "maxItems": 50,
                        "type": "array"
                      }
                    },
                    "type": "object"
                  },
                  "headersHandler": {
                    "properties": {
                      "requestHeadersToAdd": {
                        "items": {
                          "properties": {
                            "action": {
                              "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                              "enum": [
                                "APPEND_IF_EXISTS_OR_ADD",
                                "ADD_IF_ABSENT",
                                "OVERWRITE_IF_EXISTS_OR_ADD",
                                "OVERWRITE_IF_EXISTS"
                              ],
                              "type": "string"
                            },
                            "key": {
                              "description": "请求/响应头名称，如 X-Frame-Options",
                              "type": "string"
                            },
                            "value": {
                              "description": "请求/响应头取值，如 SAMEORIGIN",
                              "type": "string"
                            }
                          },
                          "required": [
                            "key",
                            "value"
                          ],
                          "type": "object"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "requestHeadersToRemove": {
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "responseHeadersToAdd": {
                        "items": {
                          "properties": {
                            "action": {
                              "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                              "enum": [
                                "APPEND_IF_EXISTS_OR_ADD",
                                "ADD_IF_ABSENT",
                                "OVERWRITE_IF_EXISTS_OR_ADD",
                                "OVERWRITE_IF_EXISTS"
                              ],
                              "type": "string"
                            },
                            "key": {
                              "description": "请求/响应头名称，如 X-Frame-Options",
                              "type": "string"
                            },
                            "value": {
                              "description": "请求/响应头取值，如 SAMEORIGIN",
                              "type": "string"
                            }
                          },
                          "required": [
                            "key",
                            "value"
                          ],
                          "type": "object"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "responseHeadersToRemove": {
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      }
                    },
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "path": {
                "description": "触发路径（网关匹配前缀），默认 /{上游名}。例：云函数 /api/hello、云托管 /api、静态托管 / 或 /app。只建网关入口；与 enablePathTransmission 共同决定上游实际收到的路径。",
                "type": "string"
              },
              "pathRewrite": {
                "description": "路径重写（PathRewrite），形如 {prefix:\"/v1\", staticStorePrefix:\"app\"}。prefix=命中路径前缀后替换为的内容；staticStorePrefix=静态托管场景下的目标前缀。不需要改写就省略；也可用 route.pathRewrite（route 优先）。",
                "properties": {
                  "prefix": {
                    "type": "string"
                  },
                  "staticStorePrefix": {
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "protocol": {
                "description": "域名协议（Protocol），仅 createRoute/updateRoute/bindCustomDomain 生效：HTTP / HTTPS / HTTP_AND_HTTPS / HTTP_TO_HTTPS / HTTPS_TO_HTTP。省略则沿用域名现有配置。",
                "enum": [
                  "HTTP",
                  "HTTPS",
                  "HTTP_AND_HTTPS",
                  "HTTP_TO_HTTPS",
                  "HTTPS_TO_HTTP"
                ],
                "type": "string"
              },
              "purgeType": {
                "description": "清除方式（仅 purgeCache，默认 PURGE_URL）：PURGE_URL=按完整 URL、PURGE_PREFIX=按路径前缀、PURGE_HOST=整个域名",
                "enum": [
                  "PURGE_URL",
                  "PURGE_PREFIX",
                  "PURGE_HOST"
                ],
                "type": "string"
              },
              "qpsPolicy": {
                "description": "限频（QPSPolicy），即控制台的「频限」。{total:总 QPS, perClient:{limitBy:\"ClientIP\"|\"UserID\", limitValue:单客户端 QPS}}。不传则不限频；也可用 route.qpsPolicy（route 优先）。",
                "properties": {
                  "perClient": {
                    "properties": {
                      "limitBy": {
                        "enum": [
                          "ClientIP",
                          "UserID"
                        ],
                        "type": "string"
                      },
                      "limitValue": {
                        "maximum": 9007199254740991,
                        "minimum": 1,
                        "type": "integer"
                      }
                    },
                    "type": "object"
                  },
                  "total": {
                    "maximum": 9007199254740991,
                    "minimum": 0,
                    "type": "integer"
                  }
                },
                "type": "object"
              },
              "route": {
                "description": "路由对象（可选写法）。例：云函数 {upstreamResourceType:\"WEB_SCF\",serviceName:\"fn\",path:\"/api\"}；云托管 {upstreamResourceType:\"CBR\",serviceName:\"svc\",path:\"/api\"}；静态托管 {upstreamResourceType:\"STATIC_STORE\",serviceName:\"staticstore\",path:\"/\"}；禁用路由 {path:\"/\",enable:false}（配合 updateRoute，或直接用 disableRoute）。",
                "properties": {
                  "auth": {
                    "type": "boolean"
                  },
                  "enable": {
                    "description": "路由级开关（Routes[].Enable / Route.Enable）。createRoute/updateRoute 可用：enable=false 禁用该 Domain+Path（访问返回 GATEWAY_ROUTE_DISABLED）；enable=true 重新启用。updateRoute 也可用顶层 enable 表达同一语义；也可用专用 action enableRoute/disableRoute。route.enable 优先于顶层 enable。",
                    "type": "boolean"
                  },
                  "enablePathTransmission": {
                    "description": "同顶层 enablePathTransmission。route 内设置时优先于顶层。",
                    "type": "boolean"
                  },
                  "enableSafeDomain": {
                    "description": "同顶层 enableSafeDomain（跨域/合法域名校验）。route 内设置时优先于顶层。",
                    "type": "boolean"
                  },
                  "extension": {
                    "description": "同顶层 extension（路由级自定义头与缓存规则）。route 内设置时优先于顶层。",
                    "properties": {
                      "cache": {
                        "properties": {
                          "rules": {
                            "items": {
                              "properties": {
                                "actions": {
                                  "description": "缓存动作数组：type=Cache 配 cache{followOrigin,noCache,cacheTime,maxAgeTime}（三者互斥，需开启其一）；type=CacheKey 配 cacheKey{fullUrlCache,queryStringSwitch,queryStringAction,queryStringValues}",
                                  "items": {
                                    "properties": {
                                      "cache": {
                                        "properties": {
                                          "cacheTime": {
                                            "maximum": 9007199254740991,
                                            "minimum": 0,
                                            "type": "integer"
                                          },
                                          "followOrigin": {
                                            "type": "boolean"
                                          },
                                          "maxAgeTime": {
                                            "maximum": 9007199254740991,
                                            "minimum": 0,
                                            "type": "integer"
                                          },
                                          "noCache": {
                                            "type": "boolean"
                                          }
                                        },
                                        "type": "object"
                                      },
                                      "cacheKey": {
                                        "properties": {
                                          "fullUrlCache": {
                                            "enum": [
                                              "on",
                                              "off"
                                            ],
                                            "type": "string"
                                          },
                                          "queryStringAction": {
                                            "enum": [
                                              "includeCustom",
                                              "excludeCustom"
                                            ],
                                            "type": "string"
                                          },
                                          "queryStringSwitch": {
                                            "enum": [
                                              "on",
                                              "off"
                                            ],
                                            "type": "string"
                                          },
                                          "queryStringValues": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "maxItems": 50,
                                            "type": "array"
                                          }
                                        },
                                        "type": "object"
                                      },
                                      "type": {
                                        "enum": [
                                          "Cache",
                                          "CacheKey"
                                        ],
                                        "type": "string"
                                      }
                                    },
                                    "type": "object"
                                  },
                                  "maxItems": 20,
                                  "type": "array"
                                },
                                "condition": {
                                  "description": "缓存规则匹配条件：target=url_path/file_extension/full_uri，matchType=prefix/suffix/contains/exact，values=匹配值数组",
                                  "properties": {
                                    "matchType": {
                                      "enum": [
                                        "prefix",
                                        "suffix",
                                        "contains",
                                        "exact"
                                      ],
                                      "type": "string"
                                    },
                                    "target": {
                                      "enum": [
                                        "url_path",
                                        "file_extension",
                                        "full_uri"
                                      ],
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "maxItems": 50,
                                      "type": "array"
                                    }
                                  },
                                  "type": "object"
                                },
                                "description": {
                                  "type": "string"
                                },
                                "enable": {
                                  "type": "boolean"
                                }
                              },
                              "required": [
                                "condition",
                                "actions"
                              ],
                              "type": "object"
                            },
                            "maxItems": 50,
                            "type": "array"
                          }
                        },
                        "type": "object"
                      },
                      "headersHandler": {
                        "properties": {
                          "requestHeadersToAdd": {
                            "items": {
                              "properties": {
                                "action": {
                                  "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                                  "enum": [
                                    "APPEND_IF_EXISTS_OR_ADD",
                                    "ADD_IF_ABSENT",
                                    "OVERWRITE_IF_EXISTS_OR_ADD",
                                    "OVERWRITE_IF_EXISTS"
                                  ],
                                  "type": "string"
                                },
                                "key": {
                                  "description": "请求/响应头名称，如 X-Frame-Options",
                                  "type": "string"
                                },
                                "value": {
                                  "description": "请求/响应头取值，如 SAMEORIGIN",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "key",
                                "value"
                              ],
                              "type": "object"
                            },
                            "maxItems": 100,
                            "type": "array"
                          },
                          "requestHeadersToRemove": {
                            "items": {
                              "type": "string"
                            },
                            "maxItems": 100,
                            "type": "array"
                          },
                          "responseHeadersToAdd": {
                            "items": {
                              "properties": {
                                "action": {
                                  "description": "写入策略（可选）：APPEND_IF_EXISTS_OR_ADD 追加；ADD_IF_ABSENT 不存在才加；OVERWRITE_IF_EXISTS_OR_ADD 覆盖或新增；OVERWRITE_IF_EXISTS 仅覆盖已存在的",
                                  "enum": [
                                    "APPEND_IF_EXISTS_OR_ADD",
                                    "ADD_IF_ABSENT",
                                    "OVERWRITE_IF_EXISTS_OR_ADD",
                                    "OVERWRITE_IF_EXISTS"
                                  ],
                                  "type": "string"
                                },
                                "key": {
                                  "description": "请求/响应头名称，如 X-Frame-Options",
                                  "type": "string"
                                },
                                "value": {
                                  "description": "请求/响应头取值，如 SAMEORIGIN",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "key",
                                "value"
                              ],
                              "type": "object"
                            },
                            "maxItems": 100,
                            "type": "array"
                          },
                          "responseHeadersToRemove": {
                            "items": {
                              "type": "string"
                            },
                            "maxItems": 100,
                            "type": "array"
                          }
                        },
                        "type": "object"
                      }
                    },
                    "type": "object"
                  },
                  "path": {
                    "type": "string"
                  },
                  "pathRewrite": {
                    "description": "同顶层 pathRewrite。route 内设置时优先于顶层。",
                    "properties": {
                      "prefix": {
                        "type": "string"
                      },
                      "staticStorePrefix": {
                        "type": "string"
                      }
                    },
                    "type": "object"
                  },
                  "qpsPolicy": {
                    "description": "同顶层 qpsPolicy（限频）。route 内设置时优先于顶层。",
                    "properties": {
                      "perClient": {
                        "properties": {
                          "limitBy": {
                            "enum": [
                              "ClientIP",
                              "UserID"
                            ],
                            "type": "string"
                          },
                          "limitValue": {
                            "maximum": 9007199254740991,
                            "minimum": 1,
                            "type": "integer"
                          }
                        },
                        "type": "object"
                      },
                      "total": {
                        "maximum": 9007199254740991,
                        "minimum": 0,
                        "type": "integer"
                      }
                    },
                    "type": "object"
                  },
                  "serviceName": {
                    "description": "上游实例名：云函数名 / 云托管服务名 / 静态托管实例名（常见 staticstore）/ LH 实例。优先于顶层 targetName。",
                    "type": "string"
                  },
                  "upstreamResourceType": {
                    "description": "同顶层 upstreamResourceType。route 内设置时优先于顶层。",
                    "enum": [
                      "SCF",
                      "WEB_SCF",
                      "CBR",
                      "STATIC_STORE",
                      "LH",
                      "STORAGE"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "targetName": {
                "description": "上游资源名称（UpstreamResourceName），与 route.serviceName 二选一（route 优先）。云函数=函数名；云托管=服务名；静态托管=实例名（常见 staticstore）。不会自动推断上游类型。",
                "type": "string"
              },
              "targets": {
                "description": "清除目标（仅 purgeCache，必填）：PURGE_URL 传 https://域名/路径 形式；PURGE_PREFIX 传 /static/ 这样的前缀；PURGE_HOST 传域名本身",
                "items": {
                  "type": "string"
                },
                "maxItems": 200,
                "type": "array"
              },
              "upstreamResourceType": {
                "description": "上游类型（与 route.upstreamResourceType 二选一，route 优先）。WEB_SCF=HTTP云函数，SCF=Event云函数，CBR=云托管，STATIC_STORE=静态托管，STORAGE=云存储，LH=轻量应用服务器。STORAGE 的 UpstreamResourceName 是云存储实例名，可先用 queryStorage 查实例。createRoute/updateRoute 必填其一；勿把 manageFunctions 的 type=HTTP|Event 传到本字段。",
                "enum": [
                  "SCF",
                  "WEB_SCF",
                  "CBR",
                  "STATIC_STORE",
                  "LH",
                  "STORAGE"
                ],
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:a1cdc95ffe24d5d3c1383528e6a78fa452a9b745ad3a54ba61081c1a93bb70ad"
        },
        {
          "id": "mcp:cloudbase-mcp/manageHosting",
          "name": "manageHosting",
          "title": "管理 CloudBase 静态托管",
          "description": "管理 CloudBase 静态托管的变更操作。action=upload 上传本地构建产物到共享域名（域名格式：<envId>-<appId>.tcloudbaseapp.com/<cloudPath>）；action=delete 删除托管文件或目录（必须 confirm=true）；action=setWebsiteDocument 设置首页/错误页/路由规则；action=enableService 开通静态托管；action=bindDomain / unbindDomain / updateDomain 管理自定义域名；action=downloadFile / downloadDirectory 下载托管内容到本地。⚠️ 底层每次托管操作都会请求 DescribeStaticStore 管控接口（20 次/秒 QPS 限制）：批量删除多个文件请逐次调用并保持间隔（建议每秒不超过 10 次），同一目录下多个文件可优先用 isDir=true 一次删除整个目录；若报错含 \"frequency limit\" 说明触发了限流，请等待 1-2 秒后重试，不要连续快速重试。⚠️ 本工具没有关闭默认域名（*.tcloudbaseapp.com）的 action；要禁用该默认公网域名，请用 manageGateway(action=\"disableRoute\", domain=该 STATIC_STORE IsDefault 域名, path=\"/\")（底层 ModifyHTTPServiceRoute，不是 ModifyGatewayRoute）。⚠️ 新项目部署优先使用 manageApps（部署到独立子域名），本工具适合已有老项目继续使用或作为 manageApps 的 fallback。manageApps 与 manageHosting 域名不同，切换会导致老链接失效。若任务只是查看配置、文件或域名状态，请改用 queryHosting。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageHosting"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "管理类型：upload=上传本地构建产物到静态托管，delete=删除静态托管文件或目录，setWebsiteDocument=设置首页/错误页/路由规则，enableService=开通静态托管服务，bindDomain=绑定自定义域名，unbindDomain=解绑自定义域名，updateDomain=更新域名缓存/防盗链/IP 规则，downloadFile=下载单个托管文件到本地，downloadDirectory=下载托管目录到本地。",
                "enum": [
                  "upload",
                  "delete",
                  "setWebsiteDocument",
                  "enableService",
                  "bindDomain",
                  "unbindDomain",
                  "updateDomain",
                  "downloadFile",
                  "downloadDirectory"
                ],
                "type": "string"
              },
              "certId": {
                "description": "证书 ID。仅 action=bindDomain 时必填。",
                "type": "string"
              },
              "cloudPath": {
                "description": "静态托管中的目标路径。action=upload 时表示上传后的托管路径；action=delete/downloadFile/downloadDirectory 时表示托管侧文件或目录路径。",
                "type": "string"
              },
              "confirm": {
                "default": false,
                "description": "高风险操作确认开关。action=delete 和 action=unbindDomain 时必须显式传 true，避免误删文件或误解绑域名。",
                "type": "boolean"
              },
              "domain": {
                "description": "自定义域名。action=bindDomain / unbindDomain / updateDomain 时使用，例如 www.example.com。",
                "type": "string"
              },
              "domainConfig": {
                "description": "域名配置。仅 action=updateDomain 时必填，支持缓存、Referer、防盗链、IP 规则与频控。",
                "properties": {
                  "Cache": {
                    "description": "CDN 缓存规则列表。",
                    "items": {
                      "properties": {
                        "CacheTtl": {
                          "description": "缓存 TTL，单位秒。",
                          "type": "number"
                        },
                        "RuleType": {
                          "description": "缓存规则类型：fileType=文件类型，path=路径。",
                          "enum": [
                            "fileType",
                            "path"
                          ],
                          "type": "string"
                        },
                        "RuleValue": {
                          "description": "规则匹配值。",
                          "type": "string"
                        }
                      },
                      "required": [
                        "RuleType",
                        "RuleValue",
                        "CacheTtl"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  },
                  "IpFilter": {
                    "description": "IP 访问控制配置。",
                    "properties": {
                      "FilterType": {
                        "description": "过滤类型：blacklist=黑名单，whitelist=白名单。",
                        "enum": [
                          "blacklist",
                          "whitelist"
                        ],
                        "type": "string"
                      },
                      "Filters": {
                        "description": "IP 规则列表。",
                        "items": {
                          "type": "string"
                        },
                        "maxItems": 100,
                        "type": "array"
                      },
                      "Switch": {
                        "description": "IP 访问控制开关：on=开启，off=关闭。",
                        "enum": [
                          "on",
                          "off"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "Switch"
                    ],
                    "type": "object"
                  },
                  "IpFreqLimit": {
                    "description": "IP 频控配置。",
                    "properties": {
                      "Qps": {
                        "description": "每个 IP 的 QPS 上限。",
                        "type": "number"
                      },
                      "Switch": {
                        "description": "IP 频控开关：on=开启，off=关闭。",
                        "enum": [
                          "on",
                          "off"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "Switch"
                    ],
                    "type": "object"
                  },
                  "Refer": {
                    "description": "Referer 防盗链配置。",
                    "properties": {
                      "RefererRules": {
                        "description": "Referer 规则列表。",
                        "items": {
                          "properties": {
                            "AllowEmpty": {
                              "description": "是否允许空 Referer。",
                              "type": "boolean"
                            },
                            "RefererType": {
                              "description": "Referer 规则类型：blacklist=黑名单，whitelist=白名单。",
                              "enum": [
                                "blacklist",
                                "whitelist"
                              ],
                              "type": "string"
                            },
                            "Referers": {
                              "description": "Referer 规则值列表。",
                              "items": {
                                "type": "string"
                              },
                              "maxItems": 100,
                              "type": "array"
                            }
                          },
                          "required": [
                            "RefererType",
                            "Referers",
                            "AllowEmpty"
                          ],
                          "type": "object"
                        },
                        "maxItems": 20,
                        "type": "array"
                      },
                      "Switch": {
                        "description": "Referer 防盗链开关：on=开启，off=关闭。",
                        "enum": [
                          "on",
                          "off"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "Switch"
                    ],
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "domainId": {
                "description": "域名 ID。仅 action=updateDomain 时必填，用于精确更新指定域名配置。",
                "type": "number"
              },
              "errorDocument": {
                "description": "错误页文档名称。仅 action=setWebsiteDocument 时可选，例如 404.html。",
                "type": "string"
              },
              "files": {
                "default": [],
                "description": "多文件上传配置。仅 action=upload 时可选；传入后会逐项上传，不再依赖单个 localPath/cloudPath。",
                "items": {
                  "properties": {
                    "cloudPath": {
                      "description": "该文件上传到静态托管后的托管路径。",
                      "type": "string"
                    },
                    "localPath": {
                      "description": "单个待上传文件的本地绝对路径。",
                      "type": "string"
                    }
                  },
                  "required": [
                    "localPath",
                    "cloudPath"
                  ],
                  "type": "object"
                },
                "maxItems": 500,
                "type": "array"
              },
              "ignore": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "items": {
                      "type": "string"
                    },
                    "maxItems": 200,
                    "type": "array"
                  }
                ],
                "description": "上传时忽略的文件模式。仅 action=upload 时可选，例如 node_modules 或 [\"**/*.map\", \"**/.DS_Store\"]。"
              },
              "indexDocument": {
                "description": "网站首页文档名称。仅 action=setWebsiteDocument 时必填，例如 index.html。",
                "type": "string"
              },
              "isDir": {
                "default": false,
                "description": "是否把 cloudPath 视为目录。仅 action=delete 时使用；true=删除目录，false=删除单个文件。",
                "type": "boolean"
              },
              "localPath": {
                "description": "本地路径。action=upload 时表示要上传的本地文件/目录路径；action=downloadFile 或 downloadDirectory 时表示下载到本地的目标路径。建议传绝对路径。",
                "type": "string"
              },
              "routingRules": {
                "description": "网站路由规则列表。仅 action=setWebsiteDocument 时可选。SPA 常见配置是将 404 重写到 index.html。",
                "items": {
                  "properties": {
                    "httpErrorCodeReturnedEquals": {
                      "description": "匹配 HTTP 错误码，例如 404。SPA 回退常用 404。",
                      "type": "string"
                    },
                    "keyPrefixEquals": {
                      "description": "匹配前缀规则，例如 app/ 或 assets/。与 httpErrorCodeReturnedEquals 二选一或按 CloudBase 规则组合使用。",
                      "type": "string"
                    },
                    "replaceKeyPrefixWith": {
                      "description": "把匹配前缀替换成新的前缀路径。",
                      "type": "string"
                    },
                    "replaceKeyWith": {
                      "description": "把匹配结果替换为固定文件路径，例如 index.html。",
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "maxItems": 50,
                "type": "array"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:575b042e152c1a9447ad0ae56b4732cade9bb61efe18f55370f772562464a5a2"
        },
        {
          "id": "mcp:cloudbase-mcp/manageLogs",
          "name": "manageLogs",
          "title": "管理 CloudBase 日志服务",
          "description": "CloudBase 日志域写入入口。用于开通 CLS 日志服务（对齐 Manager SDK `log.createLogService` / CreateEnvResource Resources=['log']）。\n\n**适用场景**：\n- 开通 CLS 日志服务：`action=\"createLogService\", confirm=true`\n\n开通为异步操作：接口成功不代表立即可用，请随后用 `queryLogs(action=\"checkLogService\")` 轮询确认。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageLogs"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：\n- `createLogService`: 开通 CLS 日志服务（需 `confirm=true`）",
                "enum": [
                  "createLogService"
                ],
                "type": "string"
              },
              "confirm": {
                "description": "开通日志服务前的显式确认。必须传 `confirm=true`；未传时返回 CONFIRM_REQUIRED。",
                "type": "boolean"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:3984e70622975563dd60ca219bf3f9312e709a6067879dc56babfb1d2028bc10"
        },
        {
          "id": "mcp:cloudbase-mcp/manageMysqlDatabase",
          "name": "manageMysqlDatabase",
          "title": "管理 CloudBase MySQL 实例或执行写入 SQL",
          "description": "管理既有 CloudBase MySQL 实例：支持销毁实例、执行写入 SQL/DDL、初始化数据库 Schema。注意：MySQL 开通能力已下线，本工具不再创建实例——需要新开通请前往云开发控制台。环境内没有实例时返回 MYSQL_NOT_CREATED 并给出控制台入口，不再提供开通引导。新环境请优先使用 CloudBase PostgreSQL（managePgDatabase / queryPgDatabase）。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageMysqlDatabase"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "destroyMySQL=销毁 MySQL 实例；runStatement=执行写入 SQL 或 DDL；initializeSchema=按顺序执行 Schema 初始化语句",
                "enum": [
                  "destroyMySQL",
                  "runStatement",
                  "initializeSchema"
                ],
                "type": "string"
              },
              "confirm": {
                "description": "action=destroyMySQL 所需的显式确认",
                "type": "boolean"
              },
              "dbInstance": {
                "description": "runStatement/initializeSchema 可选的 SQL 数据库实例上下文",
                "properties": {
                  "instanceId": {
                    "type": "string"
                  },
                  "schema": {
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "request": {
                "additionalProperties": {},
                "description": "action=destroyMySQL 使用的官方请求载荷",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "requireReady": {
                "description": "initializeSchema 是否应阻塞至确认 MySQL 就绪。默认为 true。",
                "type": "boolean"
              },
              "sql": {
                "description": "action=runStatement 使用的 SQL 语句",
                "type": "string"
              },
              "statements": {
                "description": "action=initializeSchema 使用的有序 Schema 初始化 SQL 语句",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "statusContext": {
                "description": "initializeSchema 前用于确认就绪状态的可选实例状态请求（针对控制台发起的开通/销毁任务）",
                "properties": {
                  "createResultRequest": {
                    "additionalProperties": {},
                    "propertyNames": {
                      "type": "string"
                    },
                    "type": "object"
                  },
                  "taskStatusRequest": {
                    "additionalProperties": {},
                    "propertyNames": {
                      "type": "string"
                    },
                    "type": "object"
                  }
                },
                "type": "object"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:dfdbc9171143cedffc5ae6b3ef89209995ad951c2a7ba9e73908a351ed6c8d2e"
        },
        {
          "id": "mcp:cloudbase-mcp/managePermissions",
          "name": "managePermissions",
          "title": "管理 CloudBase 权限与用户配置",
          "description": "管理 CloudBase 权限与用户配置，支持修改资源权限（数据库/云函数/存储桶等）、角色管理、成员与策略增删、应用用户 CRUD，以及设置网关 OPA Rego 策略（对齐 CLI `tcb policy set`）。\n\n示例：\n- 设置存储桶为私有：`action=\"updateResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\", permission=\"PRIVATE\"`\n- 创建角色：`action=\"createRole\", roleName=\"admin\", roleIdentity=\"admin\"`\n- 放开云函数匿名/未登录访问（PG 会走 OPA，对齐 CLI `tcb policy set`）：`action=\"updateResourcePermission\", resourceType=\"function\", resourceId=\"myFn\", permission=\"CUSTOM\", securityRule='{\"invoke\":true}'`\n- 直接设置用户 Rego：`action=\"setPolicy\", regoContent=\"package authz.user\\n\\ndefault allow := false\\n\", confirm=true`（⚠️ 立即禁用旧网关鉴权）\n\n注意：`createUser` / `updateUser` 是环境侧应用用户管理能力，适合测试账号、管理员或预置用户，不应替代浏览器里的 Web SDK 注册表单；前端用户名密码注册应使用 `auth.signUp({ username, password })`，登录应使用 `auth.signInWithPassword({ username, password })`。直接在浏览器里用 `auth.signUp` 创建用户名密码用户取决于 SDK/provider 支持，使用前必须验证；不支持时应走后端或管理端边界，不能在浏览器暴露密钥。`securityRule` 的详细语义取决于 `resourceType`：`doc._openid`、`auth.openid`、查询条件子集校验，以及 `create` / `update` / `delete` JSON 模板仅适用于 `resourceType=\"noSqlDatabase\"` 的文档数据库安全规则；配置 `function` 或 `storage` 时，请参考各自官方安全规则文档，而不是复用 NoSQL 模板。\n\n📌 跨后端边界提示：调用前先用 `queryEnv(action=\"info\", envId=...)` 看 `EnvInfo.RuntimeBackends`：\n- `resourceType=\"noSqlDatabase\"` 仅作用于 CloudBase NoSQL 文档数据库的集合；CloudBase PostgreSQL（PG）表的行级权限**不**受它控制——PG 表请改用 RLS：`managePgDatabase(action=\"execute\", confirm=true)` 跑 `ALTER TABLE ... ENABLE ROW LEVEL SECURITY` 与 `CREATE POLICY ...`。同一个 PG 环境里如果还有 NoSQL 集合在用，对那些**集合**继续使用 `noSqlDatabase` 规则是正确的——不是\"PG 环境就禁用本工具\"。\n- `resourceType=\"storage\"` 控制的是 NoSQL/COS 存储桶 ACL；PG 的 `pgstore` bucket 不在此 `resourceType` 覆盖范围内。\n- 本工具不涉及 MySQL；MySQL 数据库权限请走 MySQL 自身的 GRANT/REVOKE 语句（通过 `manageMysqlDatabase`）。\n\n⚠️ PostgreSQL 环境：平台 `ModifyResourcePermission` 对 PG 环境会直接拒绝。当 `resourceType=\"function\"` 时，本工具会自动回退到 Manager SDK `modifyEnvAuthzConfig`（与 CLI `tcb policy set` 一致，写入 `authz.user.rego`）。`securityRule` 可传完整 Rego（`package authz.user`）或 `'{\"invoke\":true}'`（自动生成放通 anonymous/unauthenticated 调 functions 的策略）。设置 Rego 后旧网关鉴权会失效，行为与 CLI 相同。显式 OPA 策略请优先用 `action=\"setPolicy\"`。\n\n⚠️ 角色类 action（`createRole` / `deleteRoles` / `updateRole`）在 **PostgreSQL 类型环境**下平台侧一律拒绝（`The current API does not support PostgreSQL type environments.`）——平台能力边界，不是配置问题，**不要在 PG 环境反复重试**；PG 环境请改用 RLS（`managePgDatabase(action=\"execute\")` 跑 `CREATE POLICY`）或控制台管理权限。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "managePermissions"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "updateResourcePermission",
                  "createRole",
                  "updateRole",
                  "deleteRoles",
                  "addRoleMembers",
                  "removeRoleMembers",
                  "addRolePolicies",
                  "removeRolePolicies",
                  "createUser",
                  "updateUser",
                  "deleteUsers",
                  "setPolicy"
                ],
                "type": "string"
              },
              "confirm": {
                "description": "仅 action=setPolicy。设置 Rego 后会立即禁用旧网关鉴权，必须显式传 confirm=true（对齐 CLI 确认提示）。",
                "type": "boolean"
              },
              "description": {
                "type": "string"
              },
              "memberUids": {
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "password": {
                "type": "string"
              },
              "permission": {
                "enum": [
                  "READONLY",
                  "PRIVATE",
                  "ADMINWRITE",
                  "ADMINONLY",
                  "CUSTOM"
                ],
                "type": "string"
              },
              "policies": {
                "items": {
                  "additionalProperties": {},
                  "propertyNames": {
                    "type": "string"
                  },
                  "type": "object"
                },
                "maxItems": 20,
                "type": "array"
              },
              "policyIds": {
                "description": "策略 ID 列表（当前不支持直接按 ID 绑定，请改传 policies 详情对象）",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "regoContent": {
                "description": "仅 action=setPolicy。用户 OPA Rego 全文，必须以 `package authz.user` 开头，对齐 CLI `tcb policy set <regoContent>`。",
                "type": "string"
              },
              "resourceId": {
                "type": "string"
              },
              "resourceType": {
                "description": "目标资源类型。`securityRule` 的具体语义依赖这个值；`noSqlDatabase` 使用集合安全规则，`function` 与 `storage` 也有各自独立的安全规则语义，不要套用 NoSQL 规则语法。",
                "enum": [
                  "noSqlDatabase",
                  "sqlDatabase",
                  "function",
                  "storage"
                ],
                "type": "string"
              },
              "roleId": {
                "type": "string"
              },
              "roleIdentity": {
                "description": "角色标识符（字母/数字/_-:@.），action=createRole 时必填，用于程序化引用角色",
                "type": "string"
              },
              "roleIds": {
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "roleName": {
                "type": "string"
              },
              "securityRule": {
                "description": "资源类型特定的规则内容，详细语义依赖 `resourceType`。当 `resourceType=\"noSqlDatabase\"` 且 `permission=\"CUSTOM\"` 时，应传文档数据库安全规则 JSON（文档型数据库规则：`https://docs.cloudbase.net/database/security-rules`）；键通常为 `read` / `create` / `update` / `delete`，值为表达式。重要：`create` 规则验证写入数据，此时文档尚不存在，不能使用 `doc.*`；`read` / `update` / `delete` 规则可使用 `doc.*` 引用已有文档字段。不要把 `doc._openid`、`auth.openid`、查询条件子集校验或 `create` / `update` / `delete` 模板误用于 `function`、`storage` 或 `sqlDatabase`。如需配置 `function` 或 `storage`，请改查官方安全规则文档：云函数 `https://docs.cloudbase.net/cloud-function/security-rules`，云存储 `https://docs.cloudbase.net/storage/security-rules`。示例：{\"read\":\"auth.uid != null\",\"create\":\"auth.uid != null && auth.loginType != \"ANONYMOUS\"\",\"update\":\"auth.uid != null && doc._openid == auth.openid\",\"delete\":\"auth.uid != null && doc._openid == auth.openid\"}",
                "type": "string"
              },
              "uid": {
                "type": "string"
              },
              "uids": {
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "userStatus": {
                "enum": [
                  "ACTIVE",
                  "BLOCKED"
                ],
                "type": "string"
              },
              "username": {
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:d0672487441d799ee652a3a38d8a9bce9b0b216e806eef99d5c615e22f78b179"
        },
        {
          "id": "mcp:cloudbase-mcp/managePgDatabase",
          "name": "managePgDatabase",
          "title": "管理 PostgreSQL 上下文或执行写入 SQL",
          "description": "管理 CloudBase PostgreSQL：执行已确认的写入 SQL、SQL 风险预检、迁移管理，以及 Realtime 配置管理。建表/ALTER/DROP 等 schema 变更必须使用 applyMigration（显式 migrationVersion；成功前自动写入或校验本地 cloudbase/migrations/<version>_<name>.sql，与 CLI tcb db pg migration 一致），不要默认用 execute。execute 主要用于 DML 与 GRANT/RLS 等运维 SQL。Realtime 三个 action：describeRealtime 读取配置（响应没有开通态字段，成功不代表已开通）；enableRealtime 开通并解除挂起，等价把 Suspend 置为 false（未开通环境首次调用会自动完成开通，已开通且未挂起时无副作用）；modifyRealtime 按显式传入项增量修改（需 confirm=true，改 suspend 会立即断开该环境全部在线 WebSocket 连接，全局生效）。客户端接入写法见 postgresql-development-cloudbase skill 的 references/realtime.md。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "managePgDatabase"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型。日常写入用 execute（DML/GRANT/RLS；schema DDL 默认拒绝，需 allowDdlViaExecute=true）或 dryRun（只分析风险、不执行）。建表 / 改 schema 必须用 applyMigration——完整流程（轮询、超时、落库校验）见工具描述。其余 6 个是迁移配套：planMigration=预览计划、listMigrations=列已应用、migrationDetail=单条详情、describeMigrationTask=查 Push 任务、fetchMigration=把远端 SQL 拉到本地、repairMigration=修历史记录。plan / apply / repair 都要 migrationName + migrationVersion；migrationDetail 只要 migrationVersion。三个 Realtime action：describeRealtime=读 Realtime 配置（不代表已开通）、enableRealtime=开通并解除挂起（等同 Suspend=false，未开通环境首次调用会自动完成开通，已开通未挂起时无副作用）、modifyRealtime=增量修改 Realtime 配置（需 confirm=true）。",
                "enum": [
                  "execute",
                  "dryRun",
                  "planMigration",
                  "applyMigration",
                  "listMigrations",
                  "migrationDetail",
                  "describeMigrationTask",
                  "fetchMigration",
                  "repairMigration",
                  "describeRealtime",
                  "enableRealtime",
                  "modifyRealtime"
                ],
                "type": "string"
              },
              "allowDdlViaExecute": {
                "description": "可选，默认 false。仅当需要故意绕过 migration history 时设为 true，才允许 schema DDL 走 execute；正常建表/改 schema 必须用 applyMigration。",
                "type": "boolean"
              },
              "confirm": {
                "description": "执行任何写入 SQL（execute 等）与 action=modifyRealtime 前都需要显式设置为 true；modifyRealtime 未传时不会下发任何修改，只返回当前值与将要变更的项，供你向用户确认。",
                "type": "boolean"
              },
              "connectionPool": {
                "description": "action=modifyRealtime 时生效：Realtime 供 RLS 鉴权查询用的数据库连接池大小，不是 PG 实例的连接池。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "defaultSchema": {
                "description": "可选的默认 schema，默认 public。",
                "type": "string"
              },
              "envId": {
                "description": "可选的 CloudBase 环境 ID，不传时使用当前 MCP 环境。",
                "type": "string"
              },
              "force": {
                "description": "fetchMigration 可选，默认 false。true=覆盖本地已存在的同名 SQL 文件（对齐 CLI tcb db pg migration fetch --force）；false=跳过已存在文件。用于从远端 history 重新对齐 Git checksum。",
                "type": "boolean"
              },
              "includeAll": {
                "description": "planMigration / applyMigration 可选，默认 false。true=允许 out-of-order（version 小于远端 LatestVersion）仍可 Preview/Push，对齐 CLI tcb db pg migration up --include-all；仅在确认要补历史/乱序迁移时使用，日常应选更大的 migrationVersion。",
                "type": "boolean"
              },
              "instanceId": {
                "description": "可选的 PostgreSQL 逻辑实例标识，默认 cloudbase-pg。",
                "type": "string"
              },
              "limit": {
                "description": "list 可选：返回数量上限，1-500，默认 100。",
                "maximum": 500,
                "minimum": 1,
                "type": "integer"
              },
              "lockTimeoutMs": {
                "description": "apply 可选：获取数据库锁的最长时间（毫秒），默认 5000。",
                "maximum": 9007199254740991,
                "minimum": -9007199254740991,
                "type": "integer"
              },
              "maxBytesPerSecond": {
                "description": "action=modifyRealtime 时生效：每秒最大消息字节数（所有广播负载流量），超限消息被拒。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "maxChannelsPerClient": {
                "description": "action=modifyRealtime 时生效：单客户端最大频道数，超限时该客户端无法 join 更多频道。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "maxConcurrentUsers": {
                "description": "action=modifyRealtime 时生效：最大并发用户数（同一用户多连接合并计数），超限时新连接被拒。服务端校验范围 0-15000。",
                "maximum": 15000,
                "minimum": 0,
                "type": "integer"
              },
              "maxEventsPerSecond": {
                "description": "action=modifyRealtime 时生效：每秒最大事件数（所有客户端 broadcast 事件总和），超限返回限流错误。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "maxJoinsPerSecond": {
                "description": "action=modifyRealtime 时生效：每秒最大 join 数，超限时新的 join 被限流。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "maxPayloadSizeInKB": {
                "description": "action=modifyRealtime 时生效：单条消息最大负载（KB），超限消息被拒。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "maxPresenceEventsPerSecond": {
                "description": "action=modifyRealtime 时生效：每秒最大 presence 事件数（所有客户端 track/untrack 总和）。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "migrationName": {
                "description": "plan/apply/repair 必填：migration 名称，小写字母开头，仅允许小写字母和下划线（不允许数字，服务端 PushPGUserMigrations 会拒绝含数字的名称）。",
                "pattern": "^[a-z][a-z_]*$",
                "type": "string"
              },
              "migrationVersion": {
                "description": "14 位时间戳 YYYYMMDDHHMMSS。plan/apply/detail/repair 必填；fetchMigration 可选（传入则只拉该条，省略则拉全量远端 history）；禁止由服务端静默生成，避免与本地 cloudbase/migrations/<version>_<name>.sql 分叉。applyMigration 非增量：每次传完整 SQL；终态失败且 listMigrations 未落地时版本号不占用，换新 migrationVersion 重发全量 SQL 即可（同名不同版本不冲突）。",
                "pattern": "^\\d{14}$",
                "type": "string"
              },
              "objectName": {
                "description": "可选的对象名，当前仅用于非 migration 场景。migration 相关操作请使用 migrationName / migrationVersion。",
                "type": "string"
              },
              "offset": {
                "description": "list 可选：分页偏移，默认 0。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "postgresChangesPool": {
                "description": "action=modifyRealtime 时生效：Realtime CDC（postgres_changes）专用连接池，与广播/鉴权池隔离。",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "presenceEnabled": {
                "description": "action=modifyRealtime 时生效：presence 总开关。false 时客户端对频道的 presence join 请求会被拒绝。",
                "type": "boolean"
              },
              "privateOnly": {
                "description": "action=modifyRealtime 时生效：true 时仅允许 private 频道，客户端无法 join 带 public: 前缀的频道。",
                "type": "boolean"
              },
              "repairReason": {
                "description": "repair 必填：修复原因。",
                "type": "string"
              },
              "repairStatus": {
                "description": "repair 必填：applied=标记为已应用（可补录 Query），reverted=删除 history 记录。",
                "enum": [
                  "applied",
                  "reverted"
                ],
                "type": "string"
              },
              "role": {
                "description": "可选的 PostgreSQL role，传给 Manager SDK executePGSql 的 Role（平台会 SET ROLE）。默认 cloudbase_postgres。推荐取值：cloudbase_postgres / anon / authenticated / service_role。不要传 postgres、postgres_pgdb_*、平台保留角色（平台管理账号，不对用户开放）或从环境名臆造的角色；不确定时省略本字段，或先用 cloudbase_postgres 执行 SELECT rolname FROM pg_roles。",
                "type": "string"
              },
              "rollbackSql": {
                "description": "plan/apply 可选：回滚 SQL 语句。",
                "type": "string"
              },
              "sql": {
                "description": "action=execute、dryRun、planMigration、applyMigration 或 repairMigration(applied) 使用的 SQL 语句",
                "type": "string"
              },
              "statementTimeoutMs": {
                "description": "apply 可选：单条 SQL 执行最长时间（毫秒），默认 300000。",
                "maximum": 9007199254740991,
                "minimum": -9007199254740991,
                "type": "integer"
              },
              "suspend": {
                "description": "action=modifyRealtime 时生效（enableRealtime 等价于传 Suspend=false）。全局生效，作用于该环境所有节点：true 立即断开全部在线 WebSocket 连接、拒绝新连接（HTTP 403）并禁用服务端广播 API；false 恢复服务。任何 suspend 值的变化都会触发一次断连，客户端需重连。",
                "type": "boolean"
              },
              "taskId": {
                "description": "describeMigrationTask 必填：PushPGUserMigrations / applyMigration 返回的 TaskId。用于一次性查询 DescribeTaskResult（Status/Phase/Reason），不轮询等待。",
                "type": "string"
              },
              "taskPollTimeoutMs": {
                "description": "apply 可选：轮询 DescribeTaskResult 的最长等待（毫秒）。默认 600000（与 CLI tcb db pg migration up 的 10 分钟对齐）。范围 5000-600000。超时后务必先 describeMigrationTask(taskId) 再 listMigrations，禁止立刻重推同 version。",
                "maximum": 600000,
                "minimum": 5000,
                "type": "integer"
              },
              "waitForTask": {
                "description": "apply 可选，默认 true。设为 false 时 Push 后立即返回 TaskId（errorCode=MIGRATION_TASK_PENDING），由调用方用 describeMigrationTask 轮询任务终态，再用 listMigrations 确认是否落库；适合 MCP host 工具调用超时较短的场景。默认 true 会同步等到任务终态。",
                "type": "boolean"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:feac3e2caeb2db7e8dcfdc3e6b2af6eccaae4c82f804f6aa69743c8293c8b2db"
        },
        {
          "id": "mcp:cloudbase-mcp/manageStorage",
          "name": "manageStorage",
          "title": "管理 CloudBase 存储文件",
          "description": "⚠️ PG 模式环境请使用 queryPgStorage 而非本工具（pgstore 与旧 COS 是两套独立系统）。\n\n管理 CloudBase 云存储文件，仅用于 COS/Storage 对象，不用于静态网站托管。支持上传文件/目录、下载文件/目录、删除文件/目录等操作。删除操作需要设置force=true进行确认，防止误删除重要文件。注意：上传后返回的 temporaryUrl 是临时签名链接，1小时后过期，不要当作永久公网地址写入配置或持久化存储。工具还会基于 DescribeEnvs 返回的 Storages[0].CdnDomain 推导 publicUrl，⚠️ 警告：publicUrl 仅在存储桶 ACL 为公有读（所有用户可读）时才能被匿名访问；默认私有读写存储桶返回的 publicUrl 会 403，此时请继续使用 temporaryUrl 或先通过控制台/SDK 将目标路径设置为公有读。\n\n💡 存储桶 ACL 权限管理请使用 permissions 工具：queryPermissions(action=\"getResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\") 查询，managePermissions(action=\"updateResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\", permission=\"READONLY\") 设置。\n\n📦 CloudBase PG / pgstore 桶必须先创建后使用（与 Supabase Storage 一致：upload 前 bucket 必须存在）。浏览器 SDK `app.storage.from().upload(path, file)` 不会自动建桶，且 `path` 的第一段就是 bucket 名（例如 `covers/foo.png` → bucket=`covers`）；`from('covers')` 这个参数当前不会被拼到 path 里。如果上传时浏览器看到 `STORAGE_BUCKET_NOT_FOUND` 或 `PUT https://undefined/`（DevTools 表现为 `net::ERR_NAME_NOT_RESOLVED`），先用本工具或控制台确认 / 创建对应的 pgstore bucket，再让前端重试上传，不要让前端把上传失败静默吞掉。`DescribeEnvs.Storages[]` 返回的旧 NoSQL bucket（形如 `<hash>-<envId>-<appId>`）不是可用的 pgstore bucket，切勿当作默认目标使用。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "manageStorage"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "管理操作类型：upload=上传文件或目录，download=下载文件或目录，delete=删除文件或目录",
                "enum": [
                  "upload",
                  "download",
                  "delete"
                ],
                "type": "string"
              },
              "cloudPath": {
                "description": "云端文件路径，例如 files/data.txt",
                "type": "string"
              },
              "force": {
                "default": false,
                "description": "强制操作开关，删除操作时建议设置为true以确认删除，默认false",
                "type": "boolean"
              },
              "isDirectory": {
                "default": false,
                "description": "是否为目录操作，true=目录操作，false=文件操作，默认false",
                "type": "boolean"
              },
              "localPath": {
                "description": "本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt；upload/download 操作时必填，delete 操作时不需要传该参数",
                "type": "string"
              }
            },
            "required": [
              "action",
              "cloudPath"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:6717a93756cf96ce3a26412456ca91e257bbd81fb5930f05236ec4ac56ac94da"
        },
        {
          "id": "mcp:cloudbase-mcp/modifyDataModel",
          "name": "modifyDataModel",
          "title": "修改数据模型（当前仅支持创建）",
          "description": "基于Mermaid classDiagram创建数据模型。为保持兼容性，工具名仍为 modifyDataModel；当前仅支持创建新模型，不支持更新现有模型结构。内置异步任务监控，自动轮询直至完成或超时。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "modifyDataModel"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "default": "create",
                "description": "操作类型：create=创建新模型",
                "enum": [
                  "create"
                ],
                "type": "string"
              },
              "dbInstanceType": {
                "default": "MYSQL",
                "description": "数据库实例类型，可选值：MYSQL=MySQL 数据库，FLEXDB=文档型数据库（NoSQL）",
                "enum": [
                  "MYSQL",
                  "FLEXDB"
                ],
                "type": "string"
              },
              "mermaidDiagram": {
                "description": "Mermaid classDiagram代码，描述数据模型结构。\n示例：\nclassDiagram\n    class Student {\n        name: string <<姓名>>\n        age: number = 18 <<年龄>>\n        gender: x-enum = \"男\" <<性别>>\n        classId: string <<班级ID>>\n        identityId: string <<身份ID>>\n        course: Course[] <<课程>>\n        required() [\"name\"]\n        unique() [\"name\"]\n        enum_gender() [\"男\", \"女\"]\n        display_field() \"name\"\n    }\n    class Class {\n        className: string <<班级名称>>\n        display_field() \"className\"\n    }\n    class Course {\n        name: string <<课程名称>>\n        students: Student[] <<学生>>\n        display_field() \"name\"\n    }\n    class Identity {\n        number: string <<证件号码>>\n        display_field() \"number\"\n    }\n\n    %% 关联关系\n    Student \"1\" --> \"1\" Identity : studentId\n    Student \"n\" --> \"1\" Class : student2class\n    Student \"n\" --> \"m\" Course : course\n    Student \"n\" <-- \"m\" Course : students\n    %% 类的命名\n    note for Student \"学生模型\"\n    note for Class \"班级模型\"\n    note for Course \"课程模型\"\n    note for Identity \"身份模型\"\n",
                "type": "string"
              },
              "publish": {
                "default": false,
                "description": "是否立即发布模型",
                "type": "boolean"
              }
            },
            "required": [
              "mermaidDiagram"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:b9bf9ad06555b8f4b4d13dc895042e987fdec8fa8c5f7227ef25837d952f49b3"
        },
        {
          "id": "mcp:cloudbase-mcp/prepareFeedback",
          "name": "prepareFeedback",
          "title": "打开反馈页面",
          "description": "返回公开仓库的新建 issue 页面。\n\n**什么时候用**：\n- `channel=\"case\"`：作品已经做出来，用户想展示到案例墙。\n- `channel=\"retrospective\"`：这次开发不顺利，用户想把卡点反馈给平台。\n\n**怎么用**：\n- 只调用一次。返回的是页面地址，不是已提交的 issue。\n- 在对话里写好正文，把链接交给用户。用户登录后自己提交。\n- 不要代为提交，不要把环境 ID 或密钥写进正文。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "prepareFeedback"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "channel": {
                "description": "`case` 打开案例模板；`retrospective` 打开复盘模板。",
                "enum": [
                  "case",
                  "retrospective"
                ],
                "type": "string"
              }
            },
            "required": [
              "channel"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:5d2d0b31ad79c059cd647e1ed1625657e6fd0db6921c84fbd8e407614847eb8f"
        },
        {
          "id": "mcp:cloudbase-mcp/queryAgents",
          "name": "queryAgents",
          "title": "查询 CloudBase Agent",
          "description": "CloudBase Agent 域统一只读入口。支持列表、详情与日志查询。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryAgents"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "listAgents",
                  "getAgent",
                  "getAgentLogs"
                ],
                "type": "string"
              },
              "agentId": {
                "type": "string"
              },
              "pageNumber": {
                "type": "number"
              },
              "pageSize": {
                "type": "number"
              },
              "params": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8b2b82d250fd0e9af75af4eddb201ef9ace4aa5b9f87265148370a8aad11bfd5"
        },
        {
          "id": "mcp:cloudbase-mcp/queryAppAuth",
          "name": "queryAppAuth",
          "title": "查询 CloudBase 应用认证配置",
          "description": "CloudBase 应用侧认证配置只读入口。用于查询登录方式、provider、publishable key、API key、client 配置和静态域名等认证准备状态。⚠️ 本工具为管理端配置查询工具，不执行用户登录。当任务要求编写客户端登录代码时（例如「用 JS SDK 登录」），应先通过本工具确认配置状态，再在项目代码中编写 @cloudbase/js-sdk 客户端登录代码（如 auth.signInWithPassword()），而非使用本工具完成登录。若业务要接受普通用户名样式标识符，先查询 action=getLoginConfig；若 usernamePassword=false，下一步应立即调用 manageAppAuth(action=patchLoginStrategy, patch={ usernamePassword: true })，不要直接写 email 登录 API。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryAppAuth"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "getLoginConfig",
                  "listProviders",
                  "getProvider",
                  "getClientConfig",
                  "getPublishableKey",
                  "getStaticDomain",
                  "listApiKeys"
                ],
                "type": "string"
              },
              "clientId": {
                "description": "OAuth client_id / DescribeClient 的 Id；省略时默认使用当前环境 ID（默认客户端）",
                "type": "string"
              },
              "keyType": {
                "description": "API key 类型过滤，可选 publish_key 或 api_key",
                "enum": [
                  "publish_key",
                  "api_key"
                ],
                "type": "string"
              },
              "pageNumber": {
                "description": "API key 列表页码，从 1 开始",
                "exclusiveMinimum": 0,
                "maximum": 9007199254740991,
                "type": "integer"
              },
              "pageSize": {
                "description": "API key 列表每页条数",
                "exclusiveMinimum": 0,
                "maximum": 9007199254740991,
                "type": "integer"
              },
              "providerId": {
                "description": "provider 标识，如 email、google",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8847865960b840e5550628f8942a61eeb10a32f277da918b9f5af74232273b97"
        },
        {
          "id": "mcp:cloudbase-mcp/queryApps",
          "name": "queryApps",
          "title": "查询 CloudBase 应用部署状态",
          "description": "查询 CloudBase 应用部署的应用和版本。可查应用列表/详情、版本列表/详情；部署后用 getAppVersion 按 buildId 轮询构建状态；getBuildLog 可查询构建日志用于诊断失败原因。\naction=getUploadUrl（只读）可获取预签名上传 URL：无本地文件系统时（cloud mode），先拿到 uploadUrl 自行 PUT 代码 zip，再用返回的 unixTimestamp 调 manageApps(action=deployApp, cosTimestamp) 触发部署。uploadUrl 是一次性上传凭据，不要外传或写进工单。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryApps"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "listApps",
                  "getApp",
                  "listAppVersions",
                  "getAppVersion",
                  "getBuildLog",
                  "getUploadUrl"
                ],
                "type": "string"
              },
              "buildId": {
                "description": "构建 ID（数字或数字字符串均可）。getAppVersion 时可与 versionName 二选一；部署返回 BuildId 后可直接用它轮询状态。getBuildLog 时必填。",
                "type": [
                  "string",
                  "number"
                ]
              },
              "pageNo": {
                "description": "分页页码，从 1 开始。",
                "type": "number"
              },
              "pageSize": {
                "description": "分页大小。",
                "type": "number"
              },
              "searchKey": {
                "description": "按应用服务名模糊搜索关键词，仅 action=listApps 时使用。",
                "type": "string"
              },
              "serviceName": {
                "description": "CloudBase 应用服务名。getApp / listAppVersions / getAppVersion / getBuildLog / getUploadUrl 时必填；重新部署后复用同一个 serviceName 查询版本历史。",
                "type": "string"
              },
              "start": {
                "description": "构建日志偏移量，用于分页拉取后续日志。仅 action=getBuildLog 时使用，不传时从开头返回。",
                "type": "number"
              },
              "versionName": {
                "description": "版本名称。getAppVersion 时可与 buildId 二选一；已知版本号时优先传该值。",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f1e287ec9e5058f7c426ea61a58d705866090d791b3dd2de2ec99b24e14f9f86"
        },
        {
          "id": "mcp:cloudbase-mcp/queryCloudRun",
          "name": "queryCloudRun",
          "title": "查询 CloudRun 服务信息",
          "description": "查询云托管服务信息，支持获取服务列表、查询服务详情、获取可用模板列表、获取构建日志（getDeployLog，仅云端源码构建/依赖 CODING）、获取运行日志（getProcessLog，镜像与源码部署均可/不依赖 CODING）、获取部署记录以及查询环境云托管开通状态（envStatus）。返回的服务信息包括服务名称、状态、访问类型、配置详情以及最近部署上下文。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryCloudRun"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "查询操作类型：list=获取云托管服务列表（支持分页和筛选），detail=查询指定服务的详细信息（包含服务配置和最新部署状态），templates=获取可用的项目模板列表（用于初始化新项目），getDeployLog=获取构建日志（仅云端源码构建有意义，走 CODING/DescribeCloudRunBuildLog；已有镜像部署无构建过程；未登录 CODING 的账号会报错），getProcessLog=获取运行日志（部署阶段步骤+容器启动/运行日志，走 tcbr/DescribeCloudRunProcessLog；镜像部署与源码构建均可用，不依赖 CODING；RunId 来自 detail/getDeployRecords 的 latestDeploy.RunId），getDeployRecords=获取指定服务的部署记录列表（按部署时间倒序，含 BuildId/RunId/FlowRatio/Status 等字段，用于查看历史发布与回滚上下文），envStatus=查询当前环境云托管是否已开通及开通状态（Status=creating开通中/normal已开通），用于initEnv之后轮询进度或deploy之前确认环境是否就绪，getManageTask=查询指定服务的发布任务状态（走 tcbr/DescribeServerManageTask），返回任务 Id/Status 与最新部署记录状态，用于判断部署是在推进还是已经卡住（例如版本长时间停在 creating）；遇到「已有部署发布任务运行中」时先用它确认任务真实状态，不要盲目重试",
                "enum": [
                  "list",
                  "detail",
                  "templates",
                  "getDeployLog",
                  "getProcessLog",
                  "getDeployRecords",
                  "envStatus",
                  "getManageTask"
                ],
                "type": "string"
              },
              "buildId": {
                "description": "构建ID，仅在action=getDeployLog时使用（构建日志，仅云端源码构建）。不传时默认返回最近一次部署的构建日志",
                "type": "number"
              },
              "detailServerName": {
                "description": "要查询详细信息、部署记录、构建日志或运行日志的服务名称。当action为detail、getDeployLog、getProcessLog或getDeployRecords时建议提供，必须是已存在的服务名称。可通过list操作获取可用的服务名称列表",
                "type": "string"
              },
              "envId": {
                "description": "环境 ID（action=envStatus 时使用；不传则使用当前配置的环境）。格式如 env-xxxxxx",
                "type": "string"
              },
              "pageNum": {
                "default": 1,
                "description": "页码，用于分页查询。从1开始，默认值：1。配合pageSize使用可实现分页浏览",
                "minimum": 1,
                "type": "number"
              },
              "pageSize": {
                "default": 10,
                "description": "分页大小，控制每页返回的服务数量。取值范围：1-100，默认值：10。建议根据网络性能和显示需求调整",
                "maximum": 100,
                "minimum": 1,
                "type": "number"
              },
              "revealEnvParams": {
                "default": false,
                "description": "是否返回服务环境变量（ServerConfig.EnvParams）明文值（仅 action=detail 时生效）。默认 false，值脱敏为 \"***\"（保留 key，足够排查配置了哪些变量、变更是否生效）；true 时返回明文，敏感变量（如带密码的 DATABASE_URL）可能暴露给模型上下文，谨慎使用",
                "type": "boolean"
              },
              "runId": {
                "description": "运行ID（RunId），仅在action=getProcessLog时使用。不传时默认取该服务最近一次部署记录的 RunId（与 detail/getDeployRecords 的 latestDeploy.RunId 同源）。镜像部署与源码构建均可查询运行日志",
                "type": "string"
              },
              "serverName": {
                "description": "服务名称筛选条件，支持模糊匹配。例如：输入\"test\"可匹配\"test-service\"、\"my-test-app\"等服务名称。留空则查询所有服务",
                "type": "string"
              },
              "serverType": {
                "description": "服务类型筛选条件：function=函数型云托管（仅支持Node.js，有特殊的开发要求和限制，适合简单的API服务），container=容器型服务（推荐使用，支持任意语言和框架如Java/Go/Python/PHP/.NET等，适合大多数应用场景）",
                "enum": [
                  "function",
                  "container"
                ],
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:49b919857bfafc969a5b55d130c0c874cec542d977808192a12c7858c0d611fe"
        },
        {
          "id": "mcp:cloudbase-mcp/queryEnv",
          "name": "queryEnv",
          "title": "CloudBase 环境查询",
          "description": "查询 CloudBase 环境相关信息，支持查询环境列表、指定环境详情、安全域名、资源用量与监控指标。（曾用名：envQuery、listEnvs、getEnvInfo、getEnvAuthDomains）当 action=list 时，会按 DescribeEnvs 语义做列表/筛选，标准返回字段为 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，并支持通过 fields 白名单裁剪这些字段；aliasExact=true 时会按别名精确筛选，避免把前缀相近的环境误当作候选；即使传入 envId，action=list 也只返回摘要，不会返回完整资源明细或 expiry。账号级登录可传 region（ap-shanghai/ap-guangzhou/ap-singapore）查询对应地域，对齐 CLI `tcb env list -r <region>`；环境级凭证（API Key / 托管授权 token）只能看到绑定的 envId，返回 credential_scope=single_env，此时 region 不参与查询会在 ignored_params 中如实说明（AppliedFilters.region 为 null），不要误判为环境不存在或地域过滤失效。如需查询某个已知 EnvId 对应环境的详细信息（包括资源字段和计费信息），必须使用 action=info 并传入目标环境的 envId 参数。action=info 会在可用时补充 BillingInfo（如 ExpireTime、PayMode、IsAutoRenew 等计费字段）。\n\n📊 action=usage 对齐 tcb env usage/info：透传 Manager SDK describeEnvAccountCircle + describeCreditsUsageDetail，返回计费周期与各模块资源点用量（FLEXDB/SCF/COS 等）。envId 必填；type 可选过滤模块；未传 startDate/endDate 时自动使用当前计费周期。\n\n📈 action=metrics 对齐 TCB DescribeCurveData（manager.monitor.describeCurveData，不是云监控 GetMonitorData）：查询环境/网关 QPS、云函数调用与错误、数据库 CPU/内存/磁盘、云托管 CPU/QPS 等时序。envId 与 metricName 必填；startTime/endTime 格式 YYYY-MM-DD HH:mm:ss，须成对传入，不传则默认最近 24 小时；period 仅 300/3600/86400。GatewayTraceEnvQPS 未传 resourceID 时自动填环境级 all|:|all|:|all|:|all；云托管 Tke* 指标必须传服务名 resourceID。禁止用 callCloudApi 猜测监控 Action。\n\n🔍 action=info 还会派生三个用于后端选型的字段（PG 环境另附实例形态）：\n- `EnvInfo.RuntimeMode`：'postgresql' 或 'nosql'，表示新业务建议默认使用的后端（PG 已开通时为 postgresql，否则为 nosql）。\n- `EnvInfo.RuntimeBackends`：`{postgresql, nosql, mysql}` 三个布尔值，描述当前环境实际并存的后端。\n- `EnvInfo.RuntimeModeHints`：每个后端对应的 API/工具/skill 提示。\n- `EnvInfo.PostgreSQL[].TenantType`：PG 实例形态 —— `SHARED`（仅支持 SDK / 网关访问）或 `DEDICATED`（有私网 host / TCP 直连）。\n\n🌐 action=info 还会在不改写 `StaticStorages[].StaticDomain`（云 API 名义域名）的前提下，投影网关路由 Enable 状态：`StaticStorages[].staticDomainRouteEnabled` 与 `EnvInfo.staticDomainRouteEnabled`（与 queryHosting websiteConfig 同源）。`false` 表示默认静态域名根路由已禁用（访问会返回 GATEWAY_ROUTE_DISABLED），勿把名义域名当成可达 URL。\n\nAI 在写业务/权限/存储代码前必须先看这三项：PG 模式下新业务推荐 `app.rdb()` + RLS（`managePgDatabase action=execute` 跑 `CREATE POLICY`）+ pgstore；已存在的 NoSQL 集合 / 旧 storage / `managePermissions(resourceType=\"noSqlDatabase\")` 在普通 PG 环境下仍然有效。**例外（pgdoc）**：当文档型数据库请求由 PostgreSQL 承载、客户端 SDK 调用保持不变时，集合的 CUSTOM 安全规则不生效，只能用四种基础权限或把校验放到云函数；此时不要把已有文档型代码改写成 `app.rdb()`，也不要假设数据会自动搬迁。`RuntimeBackends` 只列环境里有哪些数据库资源，不表示文档型请求由谁承载，启用状态以使用者说明为准。真正不适用的是 MySQL 与数据模型：当 `RuntimeBackends.mysql === false` 时，`manageMysqlDatabase` / `queryMysqlDatabase` / `relational-database-mcp-cloudbase` skill 都不该使用；`manageDataModel` / `modifyDataModel` 只在传统模式下可用，PG 环境没有对应功能。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryEnv"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "查询类型：list=环境列表/摘要筛选（按 DescribeEnvs 语义筛选，支持通过 envId / region 筛选，返回 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault，不支持 expiry），info=指定环境的详细信息（必须传入 envId，返回资源字段和计费信息），domains=安全域名列表，usage=环境资源用量（必须传入 envId，对齐 tcb env usage/info），metrics=环境监控时序（必须传入 envId 与 metricName，对齐 TCB DescribeCurveData）",
                "enum": [
                  "list",
                  "info",
                  "domains",
                  "usage",
                  "metrics"
                ],
                "type": "string"
              },
              "alias": {
                "description": "按环境别名筛选。action=list 时可选",
                "type": "string"
              },
              "aliasExact": {
                "description": "按环境别名精确筛选。action=list 时可选；与 alias 配合使用",
                "type": "boolean"
              },
              "endDate": {
                "description": "用量结束日期（YYYY-MM-DD）。仅 action=usage 时有效；与 startDate 成对传入。不传则使用当前计费周期。",
                "type": "string"
              },
              "endTime": {
                "description": "监控结束时间（YYYY-MM-DD HH:mm:ss）。仅 action=metrics 时有效；与 startTime 成对传入。不传则默认最近 24 小时。",
                "type": "string"
              },
              "envId": {
                "description": "环境 ID。action=list 时可选（仅按 DescribeEnvs 语义做筛选，仍返回摘要）；action=info / action=usage / action=metrics 时必填；action=domains 时可选（不传则查当前绑定环境，传了则查该环境的安全域名）。",
                "type": "string"
              },
              "fields": {
                "description": "返回字段白名单。仅支持 EnvId、Alias、Status、EnvType、Region、PackageId、PackageName、IsDefault。action=list 时可选",
                "items": {
                  "enum": [
                    "EnvId",
                    "Alias",
                    "Status",
                    "EnvType",
                    "Region",
                    "PackageId",
                    "PackageName",
                    "IsDefault"
                  ],
                  "type": "string"
                },
                "maxItems": 8,
                "type": "array"
              },
              "limit": {
                "description": "返回数量上限。action=list 时可选",
                "exclusiveMinimum": 0,
                "maximum": 9007199254740991,
                "type": "integer"
              },
              "metricName": {
                "description": "监控指标名。仅 action=metrics 时有效且必填。GatewayTraceEnvQPS/EnvQPSAll=环境与网关 QPS；FunctionInvocation/FunctionError/FunctionTimeout/FunctionThrottle=云函数调用、错误、超时、限流；DbRead/DbWrite/DbSizepkg=文档库读写与容量；MysqlCpuUsageRate/MysqlMemoryUse/MysqlStorageUsage=SQL 库 CPU/内存/磁盘；TkeCpuUsedService/TkeQPSService/TkeHttpErrorService=云托管 CPU/QPS/错误。",
                "enum": [
                  "GatewayTraceEnvQPS",
                  "EnvQPSAll",
                  "FunctionInvocation",
                  "FunctionError",
                  "FunctionTimeout",
                  "FunctionThrottle",
                  "FunctionDuration",
                  "FunctionConcurrentExecutions",
                  "DbRead",
                  "DbWrite",
                  "DbSizepkg",
                  "MysqlCpuUsageRate",
                  "MysqlMemoryUse",
                  "MysqlStorageUsage",
                  "MysqlQps",
                  "MysqlSlowQueries",
                  "MysqlDbConnections",
                  "TkeCpuUsedService",
                  "TkeMemUsedService",
                  "TkeQPSService",
                  "TkeHttpErrorService",
                  "TkeInvokeNumService"
                ],
                "type": "string"
              },
              "needUsageDetails": {
                "description": "是否返回四层用量明细。仅 action=usage 时有效；默认 false。默认返回只到模块一层：每个模块一条（Module、CreditsValue 为总消耗、DeductValue 为套餐内用量），另附 DailyTotals（近 7 天逐日合计，与卡片柱子同源）。传 true 才拿全四层：模块 → 指标 → 资源类型（ResourceType，如 NAT / Gateway）→ 天（ValueDetailList[].CalcTime）。默认关掉，是因为全模块查询在这个深度下 4.5 万–5.4 万字符（4 个环境实测，2026-11-05），只在需要逐日对账时才值这个代价；默认这一份只有几百字符。指标名是接口原始码（Capacity / Flux / CU / InputToken.<model>），官方没有中文名表：跟用户讲的时候按模块语境翻成人话（容量、流量、调用次数、模型输入 Token），不要直接把码念给用户；拿不准就说这是接口字段名，不要猜。卡片上只有模块合计，所以「卡片上简单、返回里有明细」是正常的——指标与资源类型这两层只在传 true 时出现。普通版与平台版环境都返回这个深度（本 API 不收 PlatformId，收它的是另一个 action DescribePlatformCreditsUsageDetail）。最细粒度是「指标 × 天」：没有单次请求或单条记录流水，也没有金额与单价。",
                "type": "boolean"
              },
              "offset": {
                "description": "分页偏移。action=list 时可选",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "period": {
                "anyOf": [
                  {
                    "const": 300,
                    "type": "number"
                  },
                  {
                    "const": 3600,
                    "type": "number"
                  },
                  {
                    "const": 86400,
                    "type": "number"
                  }
                ],
                "description": "统计周期（秒）。仅 action=metrics 时有效；仅支持 300、3600、86400。不传则由后端按时间范围自动选择。时间范围 ≤1 天不可用 86400；>3 天不可用 300。"
              },
              "region": {
                "description": "查询地域。仅 action=list 时有效。账号级凭据会把该值透传到 DescribeEnvs（X-TC-Region），例如 ap-singapore。等价 CLI：tcb env list -r <region> --json。环境级凭据（API Key / 托管授权 token）为单环境权限，该参数会被忽略：结果恒为绑定环境，响应的 AppliedFilters.region 为 null、query_region 取该环境自身的 Region、ignored_params 说明忽略原因——不要据此判定该地域没有环境。⚠️ ap-singapore 同时属于国内站与国际站，未显式指定站点时会被判定为国际站（site=intl）：若两站都登录过，传该地域会静默查国际站账号，请先用 auth(site=\"domestic\") 或设置 TCB_SITE=domestic 明确站点。",
                "enum": [
                  "ap-shanghai",
                  "ap-guangzhou",
                  "ap-singapore"
                ],
                "type": "string"
              },
              "resourceID": {
                "description": "资源 ID。仅 action=metrics 时有效。云函数传函数名，文档库传集合名，云托管必须传服务名；GatewayTraceEnvQPS 不传则使用环境级 all|:|all|:|all|:|all。",
                "type": "string"
              },
              "startDate": {
                "description": "用量开始日期（YYYY-MM-DD）。仅 action=usage 时有效；与 endDate 成对传入。不传则使用当前计费周期。",
                "type": "string"
              },
              "startTime": {
                "description": "监控开始时间（YYYY-MM-DD HH:mm:ss）。仅 action=metrics 时有效；与 endTime 成对传入。不传则默认最近 24 小时。结束时间须晚于开始时间至少五分钟。",
                "type": "string"
              },
              "subresourceID": {
                "description": "子资源 ID。仅 action=metrics 时有效；查询云托管某版本监控时传入版本名。",
                "type": "string"
              },
              "type": {
                "description": "用量模块过滤。仅 action=usage 时有效；不传则查询全部模块。⚠️ 传入后只统计所选模块：`credits.total` 不下发，面板不再判断是否充足；套餐仍照实返回。要对比全量配额就别传本参数。可选值：FLEXDB、TDSQL、PostgreSQL、SCF、CBF、EKS、COS、AI、Token、HOSTING、Auth、Gateway、Workflow、CLS、EO、STORAGE_EO、CI、VM、Other（与控制台用量页一致）。",
                "items": {
                  "enum": [
                    "FLEXDB",
                    "TDSQL",
                    "PostgreSQL",
                    "SCF",
                    "CBF",
                    "EKS",
                    "COS",
                    "AI",
                    "Token",
                    "HOSTING",
                    "Auth",
                    "Gateway",
                    "Workflow",
                    "CLS",
                    "EO",
                    "STORAGE_EO",
                    "CI",
                    "VM",
                    "Other"
                  ],
                  "type": "string"
                },
                "maxItems": 19,
                "type": "array"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:c4e38ac5ab674481047a4e3892e51dfd000636f6cca53a6c4c9570bb42b8ac2a"
        },
        {
          "id": "mcp:cloudbase-mcp/queryFunctions",
          "name": "queryFunctions",
          "title": "查询 CloudBase 云函数",
          "description": "CloudBase 云函数统一只读入口。通过更自解释的 action 查询 CloudBase 云函数列表、函数详情、执行日志、层、触发器、代码下载地址、已发布版本与流量别名。\n\n**分页说明**：`listFunctions`、`listLayers`、`listVersionByFunction` 支持 `limit` 和 `offset` 参数。\n- `limit`: 分页数量，默认值由后端决定\n- `offset`: 分页偏移，从 0 开始\n- 示例：`queryFunctions(action=\"listFunctions\", offset=10, limit=10)`\n\n**查询 CloudBase 云函数日志**：`action=\"listFunctionLogs\"`，需要提供 `functionName`。日志从 CLS 检索（底层 GetFunctionLogs 接口已下线）。\n- 示例：`queryFunctions(action=\"listFunctionLogs\", functionName=\"my-function\")`\n- 不传 startTime/endTime 时默认查最近 1 天；跨度不能超过 1 天，单次最多返回 100 条\n- 返回 `hasMore=true` 表示还有更早的日志：把返回的 `context` 原样传回取下一页（`offset` 只在前 100 条内生效）\n- `logs[]` 已解析成 requestId / log / statusCode / retCode / durationMs / memoryMb / timestamp\n- 想看某一次调用的完整过程（START、业务日志、REPORT）：`queryFunctions(action=\"getFunctionLogDetail\", requestId=\"xxx\")`\n\n**定时任务 / cron / 定时跑**：使用 `listFunctionTriggers` 查询函数的 timer 触发器配置。\n\n**版本与流量路由**：`listVersionByFunction` 列出已发布版本（对齐 tcb fn list-function-versions）；`getFunctionAlias` 查看别名/灰度配置（对齐 tcb fn get-route，aliasName 默认 `$DEFAULT`）。\n\n**层（Layer）说明**：\n- 层为 SCF 账号级共享命名空间：不同环境创建同名层会共享同一层的版本序列；删除某版本会影响所有绑定该版本的环境的函数\n- 创建层必须用带环境标识的唯一层名，固定格式：`{layerName}_{当前envId}`（如 `common_cloud1-d9ghadgak3edf6b36`）。不要在不同环境使用相同裸层名，创建前先 `listLayers` 查重\n- `listLayers` / `listLayerVersions` / `getLayerVersionDetail` 返回账号级视图，可能含其他环境创建的层\n\n**区分 `queryLogs` 工具**：\n- 本工具用于查询特定 CloudBase 云函数的执行日志\n- `queryLogs` 工具用于搜索 CLS 日志服务（跨服务日志聚合）",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryFunctions"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "只读操作类型：\n- `listFunctions`: 列出所有 CloudBase 云函数\n- `getFunctionDetail`: 获取 CloudBase 云函数详情（需要 functionName）\n- `listFunctionLogs`: 查询云函数执行日志（需要 functionName；走 CLS 检索，默认最近 1 天，单次最多 100 条，翻页传 context）\n- `getFunctionLogDetail`: 获取某次调用的完整日志序列（需要 requestId，取自 listFunctionLogs 的 logs[].requestId）\n- `listFunctionLayers`: 列出函数绑定的层\n- `listLayers`: 列出所有层（账号级视图，含其他环境创建的层）\n- `listLayerVersions`: 列出层的版本（注意：是 Versions 不是 Version；账号级视图）\n- `getLayerVersionDetail`: 获取层版本详情（账号级视图）\n- `listFunctionTriggers`: 列出函数触发器（用于查看定时任务 / cron / timer 配置）\n- `getFunctionDownloadUrl`: 获取函数代码下载地址\n- `getFunctionDeployStatus`: 按 taskId 查询异步部署状态、阶段进度和最终结果。返回 data.build（构建子状态）、data.deploy（部署子状态）、data.progress（阶段事件）；status=running 时 data.result 与 data.error 一律为 null，不得报告部署完成。调用方必须持续轮询直到 status=succeeded/failed；status=expired 表示任务超过最长保留时间（2 小时）被终结，云端可能仍在部署，需用 getFunctionDetail 确认。任务只保存在 MCP 进程内存中，过期或 MCP Server 重启后返回 errorCode=DEPLOY_TASK_NOT_FOUND；任务按环境隔离，只能查到当前环境自己发起的部署。cloud mode 下本 action 不可用：异步任务只由 buildStrategy=cloud/local 的真实部署创建，而这两种策略在 cloud mode 下都不支持真实执行，image 策略则走同步部署不产生 taskId。\n- `listVersionByFunction`: 列出函数已发布版本（对齐 tcb fn list-function-versions / SDK listVersionByFunction；需要 functionName）\n- `getFunctionAlias`: 查询函数别名与流量路由（对齐 tcb fn get-route / SDK getFunctionAlias；需要 functionName；aliasName 默认 $DEFAULT）\n- `getFunctionUploadUrl`: 获取函数代码包的 COS 预签名上传地址（ZIP 两段式部署阶段 A）：PUT 代码 zip 到 uploadUrl（uploadHeaders 非空时须随请求携带对应请求头），再调用 manageFunctions 的 createFunction/updateFunctionCode 并传 code 三元组（阶段 B）。functionName 可选，仅用于生成上传对象 key。返回的 uploadUrl 含凭据签名，不得写入日志或持久化；阶段 B 会校验三元组的桶与地域必须是本环境自有存储桶，因此该地址只能用于取到它的那个环境；地址默认 300 秒内有效",
                "enum": [
                  "listFunctions",
                  "getFunctionDetail",
                  "listFunctionLogs",
                  "getFunctionLogDetail",
                  "listFunctionLayers",
                  "listLayers",
                  "listLayerVersions",
                  "getLayerVersionDetail",
                  "listFunctionTriggers",
                  "getFunctionDownloadUrl",
                  "getFunctionDeployStatus",
                  "listVersionByFunction",
                  "getFunctionAlias",
                  "getFunctionUploadUrl"
                ],
                "type": "string"
              },
              "aliasName": {
                "description": "`getFunctionAlias` 的别名名称。省略时默认 `$DEFAULT`（与 tcb fn get-route 一致）",
                "type": "string"
              },
              "codeSecret": {
                "description": "代码保护密钥，用于解密函数代码",
                "type": "string"
              },
              "context": {
                "description": "日志翻页游标。把上一次 `listFunctionLogs` 返回的 `context` 原样传回即可取下一页；不要自己构造，null 表示没有更多",
                "type": "string"
              },
              "endTime": {
                "description": "日志查询结束时间，格式必须为 YYYY-MM-DD HH:mm:ss（如 2024-01-01 23:59:59，按北京时间理解）。与 startTime 间隔不能超过一天。不传时默认为当前时间",
                "type": "string"
              },
              "functionName": {
                "description": "CloudBase 云函数名称。`getFunctionDetail`、`listFunctionLogs`、`listFunctionLayers`、`listFunctionTriggers`、`getFunctionDownloadUrl`、`listVersionByFunction`、`getFunctionAlias` 时必填；`getFunctionUploadUrl` 可选（仅用于生成上传对象 key）",
                "type": "string"
              },
              "layerName": {
                "description": "层名称。`listLayerVersions`、`getLayerVersionDetail` 操作必填。层为账号级共享命名空间；推荐固定格式 `{layerName}_{当前envId}`（如 common_cloud1-d9ghadgak3edf6b36）",
                "type": "string"
              },
              "layerVersion": {
                "description": "层版本号。`getLayerVersionDetail` 操作必填",
                "type": "number"
              },
              "limit": {
                "description": "分页数量（limit）。列表类 action 可选，默认值由后端决定；日志类 action 单次最多 100 条，默认 20",
                "type": "number"
              },
              "offset": {
                "description": "分页偏移（offset）。列表类 action 可选，默认 0。日志类 action 只在前 100 条内生效，更早的日志请用返回的 context 翻页",
                "type": "number"
              },
              "order": {
                "description": "`listVersionByFunction` 排序方向，仅支持 ASC / DESC",
                "enum": [
                  "ASC",
                  "DESC"
                ],
                "type": "string"
              },
              "orderBy": {
                "description": "`listVersionByFunction` 排序字段，仅支持 AddTime / ModTime",
                "enum": [
                  "AddTime",
                  "ModTime"
                ],
                "type": "string"
              },
              "qualifier": {
                "description": "函数版本别名，如 $LATEST、$DEFAULT。日志查询时可选，作为 CLS 检索条件",
                "type": "string"
              },
              "requestId": {
                "description": "日志请求 ID。`getFunctionLogDetail` 操作必填；取自 `listFunctionLogs` 返回的 logs[].requestId，也可传具体业务日志里出现的 RequestId",
                "type": "string"
              },
              "revealEnvValues": {
                "description": "getFunctionDetail / listFunctionTriggers / listFunctionLayers 时是否返回环境变量明文值。默认 false：Value 脱敏为 ***，仅保留 Key 与 ValueLength，足以确认配置了哪些变量及变更是否生效；true 时返回明文，敏感变量会进入模型上下文，谨慎使用。如需查看明文，建议优先使用控制台或 CLI",
                "type": "boolean"
              },
              "runtime": {
                "description": "层查询的运行时筛选，如 Nodejs18.15",
                "type": "string"
              },
              "searchKey": {
                "description": "层名称搜索关键字",
                "type": "string"
              },
              "startTime": {
                "description": "日志查询开始时间，格式必须为 YYYY-MM-DD HH:mm:ss（如 2024-01-01 00:00:00，按北京时间理解）。与 endTime 间隔不能超过一天。不传时默认查询最近一天",
                "type": "string"
              },
              "taskId": {
                "description": "`getFunctionDeployStatus` 操作时的异步部署任务 ID（由 manageFunctions 的 wait=false 返回）。任务仅保存在当前 MCP 进程内存中：终态任务保留约 30 分钟，运行中任务最长保留 2 小时。",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:55880ab47b045bc2f97202bc976d898938a0a63cdc8623a9f40ed3a1326412c0"
        },
        {
          "id": "mcp:cloudbase-mcp/queryGateway",
          "name": "queryGateway",
          "title": "查询 CloudBase 网关",
          "description": "CloudBase HTTP 网关统一只读入口（Domain/Route）。查询域名下路径路由及其上游：WEB_SCF/SCF=云函数，CBR=云托管，STATIC_STORE=静态托管，STORAGE=云存储，LH=轻量应用服务器。主键为 Domain + Path；listRoutes / getRoute / listCustomDomains / getPrivilege / cachePurgeTask。getPrivilege 查询 HTTP 网关总开关（enableService）与访问鉴权（enableAuth）状态。cachePurgeTask 查询域名缓存清除任务（先 manageGateway purgeCache 拿 TaskId）。实现自定义域名访问前，先 listCustomDomains：若已有自定义域名，优先 createRoute 挂路由（无需证书 ID）；仅在没有可用自定义域名时才 bindCustomDomain。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryGateway"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "只读操作类型：listRoutes、getRoute、listCustomDomains、getPrivilege、cachePurgeTask。getPrivilege 无需其他参数，直接返回 HTTP 网关总开关与访问鉴权状态。cachePurgeTask 需要 domain（可选 cacheType/taskId/purgeType/startTime/endTime/offset/limit）。自定义域名访问场景先 listCustomDomains 确认是否已有域名可复用。",
                "enum": [
                  "listRoutes",
                  "getRoute",
                  "listCustomDomains",
                  "getPrivilege",
                  "cachePurgeTask"
                ],
                "type": "string"
              },
              "cacheType": {
                "description": "缓存层（仅 cachePurgeTask）：CDN 或 EO。省略时按域名接入方式自动匹配（EO→EO、CDN→CDN）；DIRECT / CUSTOM / NONE 的域没有 CloudBase 托管的缓存，会直接拒绝并说明原因。",
                "enum": [
                  "CDN",
                  "EO"
                ],
                "type": "string"
              },
              "domain": {
                "description": "域名。getRoute / listRoutes 过滤时可选；cachePurgeTask 时必填",
                "type": "string"
              },
              "endTime": {
                "description": "任务结束时间（仅 cachePurgeTask，可选）。格式 YYYY-MM-DD HH:mm:ss",
                "type": "string"
              },
              "limit": {
                "description": "返回数量上限（仅 cachePurgeTask，可选）",
                "maximum": 9007199254740991,
                "minimum": 1,
                "type": "integer"
              },
              "offset": {
                "description": "分页偏移（仅 cachePurgeTask，可选）",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "path": {
                "description": "路由路径。getRoute / listRoutes 过滤时可选",
                "type": "string"
              },
              "purgeType": {
                "description": "清除方式过滤（仅 cachePurgeTask）：PURGE_URL=按 URL、PURGE_PREFIX=按前缀、PURGE_HOST=整站",
                "enum": [
                  "PURGE_URL",
                  "PURGE_PREFIX",
                  "PURGE_HOST"
                ],
                "type": "string"
              },
              "routeId": {
                "description": "路由 ID。getRoute 时可选",
                "type": "string"
              },
              "startTime": {
                "description": "任务开始时间（仅 cachePurgeTask，可选）。格式 YYYY-MM-DD HH:mm:ss",
                "type": "string"
              },
              "targetName": {
                "description": "上游资源名过滤（UpstreamResourceName）：云函数名、云托管服务名，或静态托管实例名（常见 staticstore）。",
                "type": "string"
              },
              "taskId": {
                "description": "缓存清除任务 ID（仅 cachePurgeTask，可选过滤）",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:28b9ddcf82ff695684650b330464158be85f05a42ec05082672575d017939336"
        },
        {
          "id": "mcp:cloudbase-mcp/queryHosting",
          "name": "queryHosting",
          "title": "查询 CloudBase 静态托管",
          "description": "查询 CloudBase 静态托管的只读信息。适合 AI 先做发现再决定下一步：action=websiteConfig 查询首页/错误页/路由规则与站点域名信息；action=status 查询托管服务状态；action=findFiles 按前缀查找文件；action=listFiles 列出全部托管文件；action=domainStatus 查询自定义域名的当前状态与配置。该工具不会产生任何副作用。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryHosting"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "查询类型：websiteConfig=查询静态托管网站文档配置与站点域名信息，status=查询静态托管服务状态，findFiles=按前缀查找托管文件，listFiles=列出静态托管中的全部文件，domainStatus=查询自定义域名配置与生效状态。该工具严格只读，不会修改任何资源。",
                "enum": [
                  "websiteConfig",
                  "status",
                  "findFiles",
                  "listFiles",
                  "domainStatus"
                ],
                "type": "string"
              },
              "domains": {
                "description": "要查询的自定义域名列表。仅 action=domainStatus 时使用，例如 [\"www.example.com\"]。",
                "items": {
                  "type": "string"
                },
                "maxItems": 100,
                "type": "array"
              },
              "marker": {
                "description": "分页起始标记。仅 action=findFiles 时使用，用于续查上一页之后的结果。",
                "type": "string"
              },
              "maxKeys": {
                "description": "单次返回的最大文件条数。仅 action=findFiles 时使用。",
                "exclusiveMinimum": 0,
                "maximum": 9007199254740991,
                "type": "integer"
              },
              "prefix": {
                "description": "文件前缀过滤条件，例如 app/ 或 assets/logo。action=findFiles 时建议带上以缩小范围；省略不会报错，会改为返回全量前 N 个文件，方便你从真实路径里挑前缀。",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f6fb2c28177f159e47814d21a788e24a574a6454169c5cd4b8343b13a64b8ca3"
        },
        {
          "id": "mcp:cloudbase-mcp/queryLogs",
          "name": "queryLogs",
          "title": "查询 CloudBase 日志服务",
          "description": "CloudBase 日志域统一只读入口。支持检查日志服务状态并搜索 CLS 日志。\n\n**重要区分**：\n- 查询云函数日志：使用 `queryFunctions(action=\"listFunctionLogs\", functionName=\"xxx\")`\n- 查询 CLS 日志（跨服务日志聚合）：使用本工具 `queryLogs(action=\"searchLogs\")`\n- 开通 CLS 日志服务：使用 `manageLogs(action=\"createLogService\", confirm=true)`\n\n**适用场景**：\n- 检查 CLS 日志服务是否开通：`action=\"checkLogService\"`\n- 跨服务日志搜索（如搜索所有 ERROR 日志）：`action=\"searchLogs\"`\n- 按 CLS 语法检索特定服务的日志：`action=\"searchLogs\", service=\"tcb|tcbr\"`",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryLogs"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：\n- `checkLogService`: 检查 CLS 日志服务是否开通\n- `searchLogs`: 搜索 CLS 日志（需要提供 queryString）",
                "enum": [
                  "checkLogService",
                  "searchLogs"
                ],
                "type": "string"
              },
              "context": {
                "description": "翻页上下文，用于继续上一次查询",
                "type": "string"
              },
              "endTime": {
                "description": "查询结束时间，格式：`YYYY-MM-DD HH:mm:ss`，如 `2024-01-01 23:59:59`",
                "type": "string"
              },
              "limit": {
                "description": "返回日志条数限制，默认 20",
                "type": "number"
              },
              "queryString": {
                "description": "CLS 查询语句，**action=\"searchLogs\" 时必填**，需严格遵循 CLS（Cloud Log Service）语法规范，详见 https://cloud.tencent.com/document/api/876/128127\n\n**云函数相关查询**：\n- 云函数日志：`(src:app OR src:system) AND log:\"START RequestId\"`\n- 聚合云函数请求状态：`| select request_id, max(status_code) as status where ((request_id='44738f94-16dd-11f1-****' AND retry_num=0) AND retry_num=0) AND status_code!=202 group by request_id, retry_num`\n\n**云数据库 / 文档型**：\n- 云数据库（文档型）：`module:database`\n- 云数据库（文档型）事件：`module:database AND eventType:(MongoSlowQuery)`（MongoSlowQuery 为文档型数据库慢查询事件）\n\n**云数据库 / SQL 型**：\n- 云数据库（SQL 型）：`module:rdb`\n- 云数据库（SQL 型）事件：`module:rdb AND eventType:(MysqlFreeze OR MysqlRecover OR MysqlSlowQuery)`（MysqlFreeze 冻结、MysqlRecover 恢复、MysqlSlowQuery 慢查询）\n\n**其它服务**：\n- 审批流：`module:workflow`\n- 模型：`module:model`\n- 用户权限：`module:auth`\n- 大模型：`module:llm AND logType:llm-tracelog`\n- 网关服务调用：`logType:accesslog`\n- 应用发布/删除事件：`module:app AND eventType:(AppProdPub OR AppProdDel)`（AppProdPub 发布事件、AppProdDel 删除事件）\n\n以上仅为示例，实际使用时请根据具体日志内容调整。\n\n**注意**：查询特定云函数的执行日志时，优先使用 `queryFunctions(action=\"listFunctionLogs\", functionName=\"xxx\")`。",
                "type": "string"
              },
              "service": {
                "description": "日志来源服务：\n- `tcb`: 云函数、数据库、存储等基础服务日志\n- `tcbr`: CloudRun 容器服务日志",
                "enum": [
                  "tcb",
                  "tcbr"
                ],
                "type": "string"
              },
              "sort": {
                "description": "按时间排序：`asc` 升序，`desc` 降序",
                "enum": [
                  "asc",
                  "desc"
                ],
                "type": "string"
              },
              "startTime": {
                "description": "查询开始时间，格式：`YYYY-MM-DD HH:mm:ss`，如 `2024-01-01 00:00:00`",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:34eea48f51e9d1c5551ccba61cbce58da9e3ae93fd2835a94e6a318c705107fb"
        },
        {
          "id": "mcp:cloudbase-mcp/queryMysqlDatabase",
          "name": "queryMysqlDatabase",
          "title": "查询 CloudBase MySQL 数据库状态或执行只读 SQL",
          "description": "查询 CloudBase MySQL 数据库信息。支持执行只读 SQL、查询实例创建任务结果（控制台发起）、查询 MySQL 任务状态、获取当前实例生命周期上下文，以及查询实例慢查询/错误日志（对齐 Manager SDK describeInstanceSlowQueries / describeInstanceErrorLogs）。标准 getInstanceInfo/describeInstance 不返回连接凭据；仅 getConnectionInfo 透传原始连接/集群载荷（含可能的凭据），且仅用于显式 TCP 迁移。业务 CRUD 优先使用 SDK 或 runQuery/runStatement。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryMysqlDatabase"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "runQuery=执行只读 SQL；describeCreateResult=查询实例创建任务结果（控制台发起）；describeTaskStatus=查询 MySQL 任务状态；getInstanceInfo=获取不含连接凭据的生命周期上下文；describeInstance=getInstanceInfo 的别名；getConnectionInfo=透传可能包含凭据的原始连接/集群载荷（仅限 TCP 迁移例外场景）；describeInstanceSlowQueries=查询实例慢查询日志；describeInstanceErrorLogs=查询实例错误日志",
                "enum": [
                  "runQuery",
                  "describeCreateResult",
                  "describeTaskStatus",
                  "getInstanceInfo",
                  "describeInstance",
                  "getConnectionInfo",
                  "describeInstanceSlowQueries",
                  "describeInstanceErrorLogs"
                ],
                "type": "string"
              },
              "database": {
                "description": "慢查过滤：数据库名",
                "type": "string"
              },
              "dbInstance": {
                "description": "runQuery / 慢查/错误日志可选的 SQL 数据库实例上下文",
                "properties": {
                  "instanceId": {
                    "type": "string"
                  },
                  "schema": {
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "endTime": {
                "description": "慢查/错误日志查询结束时间（YYYY-MM-DD HH:mm:ss）",
                "type": "string"
              },
              "host": {
                "description": "慢查过滤：客户端 host",
                "type": "string"
              },
              "keyWords": {
                "description": "错误日志关键字模糊搜索列表",
                "items": {
                  "type": "string"
                },
                "maxItems": 50,
                "type": "array"
              },
              "limit": {
                "description": "慢查/错误日志返回条数限制",
                "type": "number"
              },
              "logLevels": {
                "description": "错误日志等级过滤，可选值：error / warning / note",
                "items": {
                  "enum": [
                    "error",
                    "warning",
                    "note"
                  ],
                  "type": "string"
                },
                "maxItems": 3,
                "type": "array"
              },
              "offset": {
                "description": "慢查/错误日志分页偏移",
                "type": "number"
              },
              "orderBy": {
                "description": "排序字段。慢查支持 QueryTime/LockTime/RowsExamined/RowsSent；错误日志支持 Timestamp",
                "enum": [
                  "QueryTime",
                  "LockTime",
                  "RowsExamined",
                  "RowsSent",
                  "Timestamp"
                ],
                "type": "string"
              },
              "orderByType": {
                "description": "排序方向：asc/desc（大小写均可）",
                "enum": [
                  "asc",
                  "desc",
                  "ASC",
                  "DESC"
                ],
                "type": "string"
              },
              "request": {
                "additionalProperties": {},
                "description": "describeCreateResult/describeTaskStatus/describeInstanceSlowQueries/describeInstanceErrorLogs 使用的官方请求载荷（可含 InstanceId 等）",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "sql": {
                "description": "action=runQuery 使用的只读 SQL",
                "type": "string"
              },
              "sqlText": {
                "description": "慢查过滤：SQL 文本片段",
                "type": "string"
              },
              "startTime": {
                "description": "慢查/错误日志查询开始时间（YYYY-MM-DD HH:mm:ss）",
                "type": "string"
              },
              "username": {
                "description": "慢查过滤：用户名",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:85e065e3d58139ff2c2a8af695d52f28f8527fed8dd9e3f876e05f74ae55fa8e"
        },
        {
          "id": "mcp:cloudbase-mcp/queryPermissions",
          "name": "queryPermissions",
          "title": "查询 CloudBase 权限与用户配置",
          "description": "查询 CloudBase 权限与用户配置，支持查询资源权限（数据库/云函数/存储桶等）、角色列表/详情、应用用户列表/详情，以及网关 OPA 授权策略（对齐 CLI `tcb policy list/get`）。\n\n示例：\n- 查询存储桶权限：`action=\"getResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\"`\n- 列出旧网关策略：`action=\"listPolicy\"`（PG / OPA 引擎环境返回空列表，与 CLI 一致）\n- 读取用户 Rego：`action=\"getPolicy\"`；平台扩展策略：`action=\"getPolicy\", extension=true`\n\n📌 跨后端边界提示：调用前先用 `queryEnv(action=\"info\", envId=...)` 看 `EnvInfo.RuntimeBackends`。`resourceType=\"noSqlDatabase\"` 查询的是 CloudBase NoSQL 集合规则，与 CloudBase PostgreSQL（PG）表的行级安全（RLS）是两套独立机制——同一个 PG 环境里 NoSQL 集合若仍在使用，对那些集合查询本工具结果**仍然有效**。要查 PG 表 RLS，请改用 `queryPgDatabase(action=\"sql\", sql=\"SELECT * FROM pg_policies WHERE tablename=...\")`。本工具不涉及 MySQL 权限。\n\n⚠️ PostgreSQL 环境：平台 `DescribeResourcePermission` 对 PG 环境会直接拒绝。当 `resourceType=\"function\"` 时，本工具会自动回退到 Manager SDK `describeEnvAuthzConfig`（与 CLI `tcb policy get` 一致，读取 `authz.user.rego`）。显式 OPA 策略请用 `listPolicy` / `getPolicy`。\n\n⚠️ 角色类 action（`listRoles` / `getRole`）在 **PostgreSQL 类型环境**下平台侧一律拒绝（`The current API does not support PostgreSQL type environments.`）——这是平台能力边界，不是配置问题，**不要在 PG 环境反复重试**；PG 环境请改用 RLS（`managePgDatabase(action=\"execute\")` 跑 `CREATE POLICY`）或控制台管理权限。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryPermissions"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "enum": [
                  "getResourcePermission",
                  "listResourcePermissions",
                  "listRoles",
                  "getRole",
                  "listUsers",
                  "getUser",
                  "listPolicy",
                  "getPolicy"
                ],
                "type": "string"
              },
              "extension": {
                "description": "仅 action=getPolicy。true=读取平台为该环境单独配置的策略（authz.platform.extension.rego），默认 false=用户策略（authz.user.rego），对齐 CLI `tcb policy get --extension`。",
                "type": "boolean"
              },
              "pageNo": {
                "type": "number"
              },
              "pageSize": {
                "type": "number"
              },
              "policyResourceType": {
                "description": "仅 action=listPolicy。按资源类型过滤，当前仅支持 `policy`，对齐 CLI `tcb policy list --resource-type policy`。",
                "enum": [
                  "policy"
                ],
                "type": "string"
              },
              "resourceId": {
                "type": "string"
              },
              "resourceIds": {
                "items": {
                  "type": "string"
                },
                "maxItems": 200,
                "type": "array"
              },
              "resourceType": {
                "enum": [
                  "noSqlDatabase",
                  "sqlDatabase",
                  "function",
                  "storage"
                ],
                "type": "string"
              },
              "roleId": {
                "type": "string"
              },
              "roleIdentity": {
                "type": "string"
              },
              "roleName": {
                "type": "string"
              },
              "uid": {
                "type": "string"
              },
              "username": {
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:186a9a56fdb95b689ae9ada3cfab43d27c57b69a45a5deb79512da9c18d92e53"
        },
        {
          "id": "mcp:cloudbase-mcp/queryPgDatabase",
          "name": "queryPgDatabase",
          "title": "查询 PostgreSQL 上下文、对象、元数据或执行只读 SQL",
          "description": "⚠️ 只读工具：只接受 SELECT 等只读 SQL。CREATE / ALTER / DROP / INSERT / UPDATE / DELETE 会被直接拒绝（STATE 42703/42P01 也多半是表名或列名猜错，先 action=objects 看真实结构，不要凭惯例猜 schema_migrations 之类的表）。写入与 DDL 请改用 managePgDatabase：DML/GRANT/RLS 用 action=execute，建表/改 schema 用 action=applyMigration。\n\n查询 CloudBase PostgreSQL 数据库：获取当前 PG 上下文、列出带 schema 的数据库对象、读取轻量元数据、检查单个对象结构，以及执行只读 SQL。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryPgDatabase"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：context=获取当前 PostgreSQL 上下文；objects=列出带 schema 的数据库对象；metadata=获取轻量表元数据；schema=检查单个带 schema 的对象结构；sql=执行只读 SQL",
                "enum": [
                  "context",
                  "objects",
                  "metadata",
                  "schema",
                  "sql"
                ],
                "type": "string"
              },
              "limit": {
                "description": "可选的摘要数量上限，用于对象、元数据或 SQL 返回行数，默认 20，最大 200。",
                "maximum": 200,
                "minimum": 1,
                "type": "integer"
              },
              "objectName": {
                "description": "action=schema 时使用的带 schema 的 PostgreSQL 对象名，例如 public.users",
                "type": "string"
              },
              "schema": {
                "description": "可选的 schema 过滤条件，用于 action=objects 或 action=metadata",
                "type": "string"
              },
              "sql": {
                "description": "action=sql 时使用的只读 SQL",
                "type": "string"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:7889e011b9cc11a8f88971ebc3a759bbbdf39cacf6e02e29a2958a10dff86542"
        },
        {
          "id": "mcp:cloudbase-mcp/queryPgStorage",
          "name": "queryPgStorage",
          "title": "查询 PostgreSQL 环境云存储能力和上传方案",
          "description": "查询 CloudBase PostgreSQL 环境下的云存储能力。返回 bucket/config 能力摘要、对象信息查询方案，以及基于 HTTP API 或 SDK 的上传实现方案；不会读取本地文件，也不会默认输出大量签名 URL。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryPgStorage"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "操作类型：buckets/config=查询存储能力摘要；createBucket=生成 bucket 创建方案（SQL/HTTP API/CLI）；uploadPlan=生成 HTTP API/SDK 上传方案；objectInfo=生成对象元信息查询方案；signUpload/signDownload=显式的一次性签名 URL 请求占位",
                "enum": [
                  "buckets",
                  "config",
                  "uploadPlan",
                  "objectInfo",
                  "signUpload",
                  "signDownload",
                  "createBucket"
                ],
                "type": "string"
              },
              "bucket": {
                "description": "云存储 bucket 名称",
                "type": "string"
              },
              "expiresIn": {
                "description": "签名 URL 有效期，单位秒，范围 60 到 86400。",
                "maximum": 86400,
                "minimum": 60,
                "type": "integer"
              },
              "objectKey": {
                "description": "单个对象 key",
                "type": "string"
              },
              "objectKeys": {
                "description": "多个对象 key，用于对象元信息查询规划",
                "items": {
                  "type": "string"
                },
                "maxItems": 500,
                "type": "array"
              },
              "objects": {
                "description": "待上传对象的元信息。文件字节内容不会通过 MCP 传递。",
                "items": {
                  "properties": {
                    "contentType": {
                      "type": "string"
                    },
                    "objectKey": {
                      "type": "string"
                    },
                    "sizeBytes": {
                      "maximum": 9007199254740991,
                      "minimum": 0,
                      "type": "integer"
                    }
                  },
                  "required": [
                    "objectKey"
                  ],
                  "type": "object"
                },
                "maxItems": 500,
                "type": "array"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:306624b0f7c717776dbfb8f7e65fb1679a246e96fab6195f430d2cc59aac5f30"
        },
        {
          "id": "mcp:cloudbase-mcp/queryStorage",
          "name": "queryStorage",
          "title": "查询 CloudBase 存储信息",
          "description": "⚠️ PG 模式环境请使用 queryPgStorage 而非本工具（pgstore 与旧 COS 是两套独立系统）。\n\n查询 CloudBase 云存储信息，支持列出目录文件、获取文件信息、获取临时下载链接等只读操作。返回的文件信息包括文件名、大小、修改时间、下载链接等。注意：action=url 返回的 temporaryUrl 是临时签名链接，有效期由 maxAge 参数决定（默认1小时），不要当作永久公网地址使用。工具还会基于 DescribeEnvs 返回的 Storages[0].CdnDomain 推导 publicUrl，⚠️ 警告：publicUrl 仅在存储桶 ACL 为公有读（所有用户可读）时才能被匿名访问；默认私有读写存储桶返回的 publicUrl 会 403，此时请继续使用 temporaryUrl 或先通过控制台/SDK 将目标路径设置为公有读。\n\n💡 存储桶 ACL 权限管理请使用 permissions 工具：queryPermissions(action=\"getResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\") 查询，managePermissions(action=\"updateResourcePermission\", resourceType=\"storage\", resourceId=\"bucket-name\", permission=\"READONLY\") 设置。\n\n📦 CloudBase PG / pgstore 环境：`DescribeEnvs.Storages[]` 列出的 bucket 是旧 NoSQL 后端的，不等于 pgstore bucket。本工具用于查看常规存储；为 PG 浏览器上传准备 bucket 时，请确认目标 bucket 是 pgstore 后端可用的，否则浏览器 `app.storage.from().upload(...)` 会得到 `STORAGE_BUCKET_NOT_FOUND` 并出现 `PUT https://undefined/`。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "queryStorage"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "查询操作类型：list=列出目录下的所有文件，info=获取指定文件的详细信息，url=获取文件的临时下载链接，read=读取文本文件内容",
                "enum": [
                  "list",
                  "info",
                  "url",
                  "read"
                ],
                "type": "string"
              },
              "cloudPath": {
                "description": "云端文件路径，例如 files/data.txt 或 files/（目录）",
                "type": "string"
              },
              "maxAge": {
                "default": 3600,
                "description": "临时链接有效期，单位为秒，取值范围：1-86400，默认值：3600（1小时）",
                "maximum": 86400,
                "minimum": 1,
                "type": "number"
              }
            },
            "required": [
              "action",
              "cloudPath"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:a2dd9edbffb20201751799bc8723af592a2f62cd065922f70a04e59fd2eaa925"
        },
        {
          "id": "mcp:cloudbase-mcp/readNoSqlDatabaseContent",
          "name": "readNoSqlDatabaseContent",
          "title": "查询并获取 CloudBase NoSQL 数据库数据记录",
          "description": "查询 CloudBase NoSQL 数据库中的数据记录。支持按条件筛选、分页、排序，适用于管理端数据查询与运维。limit 默认 100、最大 1000；超出请用 offset 分页。projection 仅支持 { field: 1|0 } 对象（示例 {\"_id\":1,\"name\":1,\"createdAt\":1}），不要传字段数组。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "readNoSqlDatabaseContent"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "collectionName": {
                "description": "集合名称",
                "type": "string"
              },
              "instanceId": {
                "description": "可选：显式指定数据库实例ID；未传时会自动解析并缓存",
                "type": "string"
              },
              "limit": {
                "description": "返回数量限制，整数，范围 1-1000，默认 100。超过 1000 会被 Cloud API MgoLimit lte 校验拒绝；请用 offset 分页。",
                "type": "number"
              },
              "offset": {
                "description": "跳过的记录数",
                "type": "number"
              },
              "projection": {
                "anyOf": [
                  {
                    "additionalProperties": {},
                    "properties": {},
                    "type": "object"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "返回字段投影，仅支持对象或对应 JSON 字符串，值只能是 1/0/true/false。合法示例：{\"_id\":1,\"name\":1,\"createdAt\":1}（包含）或 {\"password\":0}（排除）。不要传 [\"name\",\"age\"] 这类字段数组，也不要混用包含与排除（_id 除外）。"
              },
              "query": {
                "anyOf": [
                  {
                    "additionalProperties": {},
                    "properties": {},
                    "type": "object"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "查询条件(对象或字符串,推荐对象)"
              },
              "sort": {
                "anyOf": [
                  {
                    "items": {
                      "additionalProperties": {},
                      "properties": {
                        "direction": {
                          "description": "排序方向,1:升序,-1:降序",
                          "type": "number"
                        },
                        "key": {
                          "description": "sort 字段名",
                          "type": "string"
                        }
                      },
                      "required": [
                        "key",
                        "direction"
                      ],
                      "type": "object"
                    },
                    "maxItems": 10,
                    "type": "array"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "排序条件，仅支持数组 [{\"key\":\"createdAt\",\"direction\":-1}] 或对应 JSON 字符串。"
              }
            },
            "required": [
              "collectionName"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f151b3668be93d3eeae70f5b013b1d3dcca735413cf4a786e2f80568a819db58"
        },
        {
          "id": "mcp:cloudbase-mcp/readNoSqlDatabaseStructure",
          "name": "readNoSqlDatabaseStructure",
          "title": "读取 CloudBase NoSQL 数据库结构",
          "description": "读取 CloudBase NoSQL 数据库集合与索引结构，支持列出集合、查看集合详情、列出索引以及检查索引是否存在。本工具为服务端管理工具，用于管理端查询数据库结构，不用于编写客户端代码。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "readNoSqlDatabaseStructure"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "listCollections: 列出集合列表\ndescribeCollection: 描述集合详情（会返回索引摘要）\ncheckCollection: 检查集合是否存在\nlistIndexes: 列出指定集合的索引列表\ncheckIndex: 检查指定索引是否存在",
                "enum": [
                  "listCollections",
                  "describeCollection",
                  "checkCollection",
                  "listIndexes",
                  "checkIndex"
                ],
                "type": "string"
              },
              "collectionName": {
                "description": "集合名称(describeCollection、listIndexes、checkIndex 操作时必填)",
                "type": "string"
              },
              "indexName": {
                "description": "索引名称(checkIndex 操作时必填)",
                "type": "string"
              },
              "limit": {
                "description": "返回数量限制(listCollections 操作时可选)",
                "type": "number"
              },
              "offset": {
                "description": "偏移量(listCollections 操作时可选)",
                "type": "number"
              }
            },
            "required": [
              "action"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:d123f9e6ea059606bf6d970ff8e08ced774e1b5a9a6439ce9c1c86a4b05390cb"
        },
        {
          "id": "mcp:cloudbase-mcp/searchKnowledgeBase",
          "name": "searchKnowledgeBase",
          "title": "云开发知识库检索",
          "description": "云开发知识库检索工具，支持 CloudBase 官方文档 (docs)、固定技能文档 (skill) 和 OpenAPI 文档 (openapi) 查询。\n\n      按场景选择 mode：\n      - 工具调用报错且错误信息含具体错误码（如 OperationDenied.FreePackageDenied）时：mode=docs + action=searchDocs（query=错误码），先查错误码官方含义与处理指引再行动，不要凭猜测重试\n      - 不确定答案在哪、需要对官方文档做全文检索时：mode=docs + action=searchDocs（传 query 关键词）\n      - 已知文档标题、层级路径或 URL 时：mode=docs + action=findByName（传 input）或 action=readDoc（传 docPath）\n      - 需要某个场景的落地指南 / 最佳实践时：mode=skill + skillName\n      - 需要 HTTP API 的接口定义时：mode=openapi + apiName\n\n      ⚠️ 重要：当 CloudBase skills 处于禁用状态或当前 IDE 不支持 skill 文件读取时，必须使用 searchKnowledgeBase(mode=skill, skillName=...) 来获取 CloudBase 技能文档内容，而不是尝试直接读取 skill 文件。直接读取可能返回 400 错误。示例：\n      - 需要最小 Web+数据库 Demo 路径时：searchKnowledgeBase(mode=skill, skillName=minimal-web-baas-demo)\n      - 需要 auth-tool-cloudbase 指南时：searchKnowledgeBase(mode=skill, skillName=auth-tool-cloudbase)\n      - 需要 auth-web-cloudbase 指南时：searchKnowledgeBase(mode=skill, skillName=auth-web-cloudbase)\n      - 需要 cloudbase-agent 指南时：searchKnowledgeBase(mode=skill, skillName=cloudbase-agent)\n      - 需要 MCP 接入方式（本地 / 远程）、用 mcporter 在命令行调用工具、或站点 / 插件开关时：searchKnowledgeBase(mode=skill, skillName=cloudbase-mcp)\n\n      返回内容包含该 skill 的 SKILL.md 全文，以及它在远端聚合仓（CNB raw）中的全部 .md 文件地址清单（SKILL.md 与 references/ 等，可直接 HTTP 抓取）。正文中代码栅栏之外的相对链接也会改写为绝对地址；若该 skill 在远端仓中不存在，则只返回内联内容并明确标注，不返回失效链接。\n\n      不确定该选哪个时：mode=skill 下不传 skillName、mode=openapi 下不传 apiName 直接调用，会返回当前可用清单及各自的适用场景 / 接口简介，再带上名称重新调用即可。可选名称也见本工具的 skillName / apiName 枚举（skill 共 0 个，API 共 0 个）。\n\n      注意：OpenAPI 文档 (openapi) 查询只需要传 mode=\"openapi\" 和 apiName，不要传 action；action 仅用于 mode=\"docs\"。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "searchKnowledgeBase"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "仅 mode=docs 时指定；mode=openapi 不要传 action。CloudBase 文档操作类型：listModules=列出所有文档模块，listModuleDocs=获取指定模块的目录结构，findByName=按名称/路径/URL 智能查找，readDoc=读取指定文档 Markdown，searchDocs=全文搜索官方文档。",
                "enum": [
                  "listModules",
                  "listModuleDocs",
                  "findByName",
                  "readDoc",
                  "searchDocs"
                ],
                "type": "string"
              },
              "apiName": {
                "type": "string"
              },
              "docPath": {
                "description": "mode=docs 且 action=readDoc 时指定。站内相对路径（如 /quick-start），或 action=findByName / action=searchDocs 返回的文档地址 —— 传地址时只取其中的路径，主机部分一律忽略。",
                "type": "string"
              },
              "input": {
                "description": "mode=docs 且 action=findByName 时指定。支持模块名、文档标题、层级路径或 URL。",
                "type": "string"
              },
              "mode": {
                "enum": [
                  "skill",
                  "openapi",
                  "docs"
                ],
                "type": "string"
              },
              "moduleName": {
                "description": "mode=docs 且 action=listModuleDocs 时指定。模块名称。",
                "type": "string"
              },
              "query": {
                "description": "mode=docs 且 action=searchDocs 时指定。全文检索关键词。",
                "type": "string"
              },
              "skillName": {
                "type": "string"
              }
            },
            "required": [
              "mode"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:5193f6d0464a65538340649fd2245395fb0d13c8d46f9b563d9f6837644541d4"
        },
        {
          "id": "mcp:cloudbase-mcp/writeNoSqlDatabaseContent",
          "name": "writeNoSqlDatabaseContent",
          "title": "修改 CloudBase NoSQL 数据库数据记录",
          "description": "修改 CloudBase NoSQL 数据库中的数据记录。支持插入、更新（含 $set/$inc/$push 等操作符）、删除、upsert 等操作，适用于管理端数据写入与运维。⚠️ 服务端写入不含 _openid：若集合依赖客户端 SDK（@cloudbase/js-sdk 或微信小程序 wx.cloud.database()）的行级安全规则（如 doc._openid == auth.openid），服务端写入时需手动补充 _openid 字段，否则客户端将无法读取到该数据。⚠️ 部分更新嵌套字段须使用点号路径，如 `$set: {\"shipping.city\": \"guangzhou\"}`，直接传嵌套对象会覆盖整个字段。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "writeNoSqlDatabaseContent"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "insert: 插入数据（新增文档）\nupdate: 更新数据\ndelete: 删除数据",
                "enum": [
                  "insert",
                  "update",
                  "delete"
                ],
                "type": "string"
              },
              "collectionName": {
                "description": "集合名称",
                "type": "string"
              },
              "documents": {
                "description": "要插入的文档对象数组,每个文档都是对象(insert 操作必填)",
                "items": {
                  "additionalProperties": {},
                  "properties": {},
                  "type": "object"
                },
                "maxItems": 100,
                "type": "array"
              },
              "instanceId": {
                "description": "可选：显式指定数据库实例ID；未传时会自动解析并缓存",
                "type": "string"
              },
              "isMulti": {
                "description": "是否更新多条记录(update/delete 操作可选)",
                "type": "boolean"
              },
              "query": {
                "anyOf": [
                  {
                    "additionalProperties": {},
                    "properties": {},
                    "type": "object"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "查询条件(对象或字符串,推荐对象)(update/delete 操作必填)"
              },
              "update": {
                "anyOf": [
                  {
                    "additionalProperties": {},
                    "properties": {},
                    "type": "object"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "更新内容(对象或字符串,推荐对象)(update 操作必填)。按 MongoDB 更新语义传入 MgoUpdate：部分更新请使用 `$set`、`$inc`、`$unset`、`$push` 等操作符，例如使用 `$set` 更新 `status`；不要直接传\"字段到值的普通对象\"，否则可能替换整条文档。\n\n⚠️ 嵌套字段必须用点号路径（如 `shipping.city`），禁止整对象替换：\n- ❌ 错误：{ \"$set\": { \"shipping\": { \"city\": \"guangzhou\" } } } — shipping 被整块替换，原有 address/province 等字段全部丢失\n- ✅ 正确：{ \"$set\": { \"shipping.city\": \"guangzhou\" } } — 仅更新 city，shipping 下其他字段保留"
              },
              "upsert": {
                "description": "是否在不存在时插入(update 操作可选)",
                "type": "boolean"
              }
            },
            "required": [
              "action",
              "collectionName"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:bc228843fe0fd3c3bdc2d61633d139bbd999c1352e208aaa5b6170d976975521"
        },
        {
          "id": "mcp:cloudbase-mcp/writeNoSqlDatabaseStructure",
          "name": "writeNoSqlDatabaseStructure",
          "title": "创建并管理 CloudBase NoSQL 数据库集合",
          "description": "创建、删除和管理 CloudBase NoSQL 数据库集合（collection）。支持创建新集合、删除现有集合，以及通过 updateCollection 的 updateOptions.CreateIndexes / updateOptions.DropIndexes 添加索引和删除索引。当需要新建集合时，使用 action=createCollection。本工具为服务端管理工具，用于管理端操作集合和索引结构，不用于编写客户端代码。",
          "source": {
            "type": "mcp",
            "server": "cloudbase-mcp",
            "operation": "writeNoSqlDatabaseStructure"
          },
          "input_schema": {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "action": {
                "description": "createCollection: 创建集合\nupdateCollection: 更新集合配置；添加索引请传 updateOptions.CreateIndexes，删除索引请传 updateOptions.DropIndexes\ndeleteCollection: 删除集合",
                "enum": [
                  "createCollection",
                  "updateCollection",
                  "deleteCollection"
                ],
                "type": "string"
              },
              "collectionName": {
                "description": "集合名称",
                "minLength": 1,
                "type": "string"
              },
              "updateOptions": {
                "description": "更新选项(updateCollection 时使用)。CreateIndexes 用于添加索引，DropIndexes 用于删除索引。",
                "properties": {
                  "CreateIndexes": {
                    "description": "要添加的索引列表",
                    "items": {
                      "properties": {
                        "IndexName": {
                          "description": "要创建的索引名称",
                          "type": "string"
                        },
                        "MgoKeySchema": {
                          "description": "待创建索引的字段与约束配置",
                          "properties": {
                            "MgoIndexKeys": {
                              "description": "索引字段列表，支持单字段或复合索引",
                              "items": {
                                "properties": {
                                  "Direction": {
                                    "description": "索引方向，通常 1 表示升序，-1 表示降序",
                                    "type": "string"
                                  },
                                  "Name": {
                                    "description": "索引字段名",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "Name",
                                  "Direction"
                                ],
                                "type": "object"
                              },
                              "maxItems": 32,
                              "type": "array"
                            },
                            "MgoIsUnique": {
                              "description": "是否唯一索引",
                              "type": "boolean"
                            }
                          },
                          "required": [
                            "MgoIsUnique",
                            "MgoIndexKeys"
                          ],
                          "type": "object"
                        }
                      },
                      "required": [
                        "IndexName",
                        "MgoKeySchema"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  },
                  "DropIndexes": {
                    "description": "要删除的索引列表",
                    "items": {
                      "properties": {
                        "IndexName": {
                          "description": "要删除的索引名称",
                          "type": "string"
                        }
                      },
                      "required": [
                        "IndexName"
                      ],
                      "type": "object"
                    },
                    "maxItems": 20,
                    "type": "array"
                  }
                },
                "type": "object"
              }
            },
            "required": [
              "action",
              "collectionName"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:e209cc26000d8c7127f1a9ea5b7cd9b3110ee731f2e936347b50ec859d9fbde8"
        }
      ],
      "discovery_order": [
        "mcp:cloudbase-mcp/auth",
        "mcp:cloudbase-mcp/queryEnv",
        "mcp:cloudbase-mcp/envDomainManagement",
        "mcp:cloudbase-mcp/manageEnv",
        "mcp:cloudbase-mcp/readNoSqlDatabaseStructure",
        "mcp:cloudbase-mcp/writeNoSqlDatabaseStructure",
        "mcp:cloudbase-mcp/readNoSqlDatabaseContent",
        "mcp:cloudbase-mcp/writeNoSqlDatabaseContent",
        "mcp:cloudbase-mcp/manageDataModel",
        "mcp:cloudbase-mcp/modifyDataModel",
        "mcp:cloudbase-mcp/queryPgDatabase",
        "mcp:cloudbase-mcp/managePgDatabase",
        "mcp:cloudbase-mcp/queryPgStorage",
        "mcp:cloudbase-mcp/queryMysqlDatabase",
        "mcp:cloudbase-mcp/manageMysqlDatabase",
        "mcp:cloudbase-mcp/queryFunctions",
        "mcp:cloudbase-mcp/manageFunctions",
        "mcp:cloudbase-mcp/queryHosting",
        "mcp:cloudbase-mcp/manageHosting",
        "mcp:cloudbase-mcp/queryStorage",
        "mcp:cloudbase-mcp/manageStorage",
        "mcp:cloudbase-mcp/downloadTemplate",
        "mcp:cloudbase-mcp/searchKnowledgeBase",
        "mcp:cloudbase-mcp/queryCloudRun",
        "mcp:cloudbase-mcp/manageCloudRun",
        "mcp:cloudbase-mcp/deployBuild",
        "mcp:cloudbase-mcp/deployPlan",
        "mcp:cloudbase-mcp/deployApply",
        "mcp:cloudbase-mcp/queryGateway",
        "mcp:cloudbase-mcp/manageGateway",
        "mcp:cloudbase-mcp/queryAppAuth",
        "mcp:cloudbase-mcp/manageAppAuth",
        "mcp:cloudbase-mcp/queryApps",
        "mcp:cloudbase-mcp/manageApps",
        "mcp:cloudbase-mcp/queryPermissions",
        "mcp:cloudbase-mcp/managePermissions",
        "mcp:cloudbase-mcp/queryLogs",
        "mcp:cloudbase-mcp/manageLogs",
        "mcp:cloudbase-mcp/queryAgents",
        "mcp:cloudbase-mcp/manageAgents",
        "mcp:cloudbase-mcp/callCloudApi",
        "mcp:cloudbase-mcp/prepareFeedback"
      ],
      "fingerprint": "sha256:d1b49c1a3cfca090974d48103ae1ee729b09bd652430602809165f70d2a50145"
    },
    "summary": {
      "total": 42,
      "read_only": 20,
      "potential_writes": 22,
      "destructive": 17,
      "unknown_effects": 0,
      "retry_safe": 20
    },
    "schema_stats": {
      "mcp:cloudbase-mcp/auth": {
        "input": {
          "properties": 13,
          "required": 0,
          "total_properties": 13,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 13
        }
      },
      "mcp:cloudbase-mcp/callCloudApi": {
        "input": {
          "properties": 5,
          "required": 2,
          "total_properties": 5,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:cloudbase-mcp/deployApply": {
        "input": {
          "properties": 10,
          "required": 0,
          "total_properties": 10,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 12
        }
      },
      "mcp:cloudbase-mcp/deployBuild": {
        "input": {
          "properties": 2,
          "required": 0,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:cloudbase-mcp/deployPlan": {
        "input": {
          "properties": 6,
          "required": 0,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:cloudbase-mcp/downloadTemplate": {
        "input": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:cloudbase-mcp/envDomainManagement": {
        "input": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:cloudbase-mcp/manageAgents": {
        "input": {
          "properties": 14,
          "required": 1,
          "total_properties": 14,
          "nested_objects": 2,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 16
        }
      },
      "mcp:cloudbase-mcp/manageAppAuth": {
        "input": {
          "properties": 11,
          "required": 1,
          "total_properties": 11,
          "nested_objects": 3,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 2,
          "refs": 0,
          "complexity": 16
        }
      },
      "mcp:cloudbase-mcp/manageApps": {
        "input": {
          "properties": 13,
          "required": 2,
          "total_properties": 13,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 14
        }
      },
      "mcp:cloudbase-mcp/manageCloudRun": {
        "input": {
          "properties": 19,
          "required": 1,
          "total_properties": 78,
          "nested_objects": 10,
          "arrays": 7,
          "max_depth": 3,
          "combinators": 2,
          "refs": 0,
          "complexity": 97
        }
      },
      "mcp:cloudbase-mcp/manageDataModel": {
        "input": {
          "properties": 3,
          "required": 1,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:cloudbase-mcp/manageEnv": {
        "input": {
          "properties": 10,
          "required": 1,
          "total_properties": 13,
          "nested_objects": 1,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 16
        }
      },
      "mcp:cloudbase-mcp/manageFunctions": {
        "input": {
          "properties": 31,
          "required": 1,
          "total_properties": 101,
          "nested_objects": 21,
          "arrays": 10,
          "max_depth": 5,
          "combinators": 2,
          "refs": 0,
          "complexity": 134
        }
      },
      "mcp:cloudbase-mcp/manageGateway": {
        "input": {
          "properties": 21,
          "required": 1,
          "total_properties": 136,
          "nested_objects": 37,
          "arrays": 25,
          "max_depth": 7,
          "combinators": 0,
          "refs": 0,
          "complexity": 198
        }
      },
      "mcp:cloudbase-mcp/manageHosting": {
        "input": {
          "properties": 14,
          "required": 1,
          "total_properties": 37,
          "nested_objects": 8,
          "arrays": 7,
          "max_depth": 4,
          "combinators": 2,
          "refs": 0,
          "complexity": 54
        }
      },
      "mcp:cloudbase-mcp/manageLogs": {
        "input": {
          "properties": 2,
          "required": 1,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:cloudbase-mcp/manageMysqlDatabase": {
        "input": {
          "properties": 8,
          "required": 1,
          "total_properties": 12,
          "nested_objects": 5,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 18
        }
      },
      "mcp:cloudbase-mcp/managePermissions": {
        "input": {
          "properties": 20,
          "required": 1,
          "total_properties": 20,
          "nested_objects": 1,
          "arrays": 5,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 26
        }
      },
      "mcp:cloudbase-mcp/managePgDatabase": {
        "input": {
          "properties": 35,
          "required": 1,
          "total_properties": 35,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 35
        }
      },
      "mcp:cloudbase-mcp/manageStorage": {
        "input": {
          "properties": 5,
          "required": 2,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:cloudbase-mcp/modifyDataModel": {
        "input": {
          "properties": 4,
          "required": 1,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:cloudbase-mcp/prepareFeedback": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:cloudbase-mcp/queryAgents": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:cloudbase-mcp/queryAppAuth": {
        "input": {
          "properties": 6,
          "required": 1,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:cloudbase-mcp/queryApps": {
        "input": {
          "properties": 8,
          "required": 1,
          "total_properties": 8,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:cloudbase-mcp/queryCloudRun": {
        "input": {
          "properties": 10,
          "required": 1,
          "total_properties": 10,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 10
        }
      },
      "mcp:cloudbase-mcp/queryEnv": {
        "input": {
          "properties": 18,
          "required": 1,
          "total_properties": 18,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 3,
          "refs": 0,
          "complexity": 23
        }
      },
      "mcp:cloudbase-mcp/queryFunctions": {
        "input": {
          "properties": 19,
          "required": 1,
          "total_properties": 19,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 19
        }
      },
      "mcp:cloudbase-mcp/queryGateway": {
        "input": {
          "properties": 12,
          "required": 1,
          "total_properties": 12,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 12
        }
      },
      "mcp:cloudbase-mcp/queryHosting": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:cloudbase-mcp/queryLogs": {
        "input": {
          "properties": 8,
          "required": 1,
          "total_properties": 8,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:cloudbase-mcp/queryMysqlDatabase": {
        "input": {
          "properties": 16,
          "required": 1,
          "total_properties": 18,
          "nested_objects": 2,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 22
        }
      },
      "mcp:cloudbase-mcp/queryPermissions": {
        "input": {
          "properties": 13,
          "required": 1,
          "total_properties": 13,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 14
        }
      },
      "mcp:cloudbase-mcp/queryPgDatabase": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:cloudbase-mcp/queryPgStorage": {
        "input": {
          "properties": 6,
          "required": 1,
          "total_properties": 9,
          "nested_objects": 1,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 12
        }
      },
      "mcp:cloudbase-mcp/queryStorage": {
        "input": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:cloudbase-mcp/readNoSqlDatabaseContent": {
        "input": {
          "properties": 7,
          "required": 1,
          "total_properties": 9,
          "nested_objects": 3,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 6,
          "refs": 0,
          "complexity": 19
        }
      },
      "mcp:cloudbase-mcp/readNoSqlDatabaseStructure": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:cloudbase-mcp/searchKnowledgeBase": {
        "input": {
          "properties": 8,
          "required": 1,
          "total_properties": 8,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:cloudbase-mcp/writeNoSqlDatabaseContent": {
        "input": {
          "properties": 8,
          "required": 2,
          "total_properties": 8,
          "nested_objects": 3,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 4,
          "refs": 0,
          "complexity": 16
        }
      },
      "mcp:cloudbase-mcp/writeNoSqlDatabaseStructure": {
        "input": {
          "properties": 3,
          "required": 2,
          "total_properties": 12,
          "nested_objects": 5,
          "arrays": 3,
          "max_depth": 5,
          "combinators": 0,
          "refs": 0,
          "complexity": 20
        }
      }
    }
  },
  "source": {
    "registry": "npm",
    "package": "@cloudbase/cloudbase-mcp",
    "version": "2.37.5",
    "published_at": "2026-11-06T07:38:25.117Z",
    "integrity": "sha512-Ij2HbPcix9bFsnJn1P2Q/mBIIpc0727RW3bSwI1mUYP3shwT8GRhhD6ZbE1rxufGH/zR6Xcn5kaieRLprwTT9g==",
    "repository": "https://github.com/TencentCloudBase/CloudBase-AI-Toolkit"
  },
  "analyzer": {
    "name": "modelara",
    "version": "v0.1.8",
    "policy_version": null
  },
  "capability_hash_version": 2,
  "capability_hashes": {
    "tencentcloudbase-cloudbase-mcp:tool:auth": {
      "description": "sha256:2448cbb6e5348176664ed261585162a98ccf9ba18a2c6feb064ef3170a1c1a2f",
      "input_schema": "sha256:773c55efe775d43808208d1fd381297be78e0d80e4118af9cf29a4e20120a359",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:759d52be963e0e2caa1fdba6fc07e3affc94bae43e96731cab3246979add14c2"
    },
    "tencentcloudbase-cloudbase-mcp:tool:callCloudApi": {
      "description": "sha256:0452dd6f157bf1120ac02cb6d2e472b818c3ea077a7af7ed3a87931db85a464d",
      "input_schema": "sha256:4d0088f2b141d0376ced3180949e8993fbfa65138ef26e756153f2d5ea0b41a7",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:32452cf7e9a4776944e1a80e6f0195bebe3cf4dd4da2726cf207cd89a78c2f6d"
    },
    "tencentcloudbase-cloudbase-mcp:tool:deployApply": {
      "description": "sha256:4a2a6c07e1dfa349702d23ddf4b88df2bbf0cb754f906d5a226283830b1b992b",
      "input_schema": "sha256:386545b3f4415411870c8b6eef463ab974b60a2f728065cbbfb62ad843b1f753",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:53b5d1b614a1a2a2e155d89e1c399f0e11f1ee67113976e1d175bab83b448771"
    },
    "tencentcloudbase-cloudbase-mcp:tool:deployBuild": {
      "description": "sha256:5170eb3cb93c3e150b9cf92df0a84686d23602b0df116e621a3861693de49100",
      "input_schema": "sha256:e0ea05b6ba0dfad6b4de7f80e500cf906667df4e5251d983a70690aaba6d16dd",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:58fd7adc46e13047dc3beae991b692e8ddcde5a9b76248afe836d851a265fb03"
    },
    "tencentcloudbase-cloudbase-mcp:tool:deployPlan": {
      "description": "sha256:7b4cbe988437177d1e9284933590e0fbe4b7a9fc1d20d6dfe766208c4350267a",
      "input_schema": "sha256:e1cae3724a3cf6948e8706ea8a4b1dce4ea8c06349c4410e7da594e88f9149a4",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:2d79cee7f2d3ac5960942b912bc71006fc847b872267087f2eb8379fc3b5a441"
    },
    "tencentcloudbase-cloudbase-mcp:tool:downloadTemplate": {
      "description": "sha256:ff433550694fcb6baae13e5b7d6ea5e4ff7bbdbe61e7adfe27b7df50584bde34",
      "input_schema": "sha256:7bcd136c50e8796086e924407ad61562045a4d9f7780337c95ef3df04b4630c1",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:ef4a9b21cef32f88280a1dce93bab968aca971bea19888d9aa9b310bd2cdeb37"
    },
    "tencentcloudbase-cloudbase-mcp:tool:envDomainManagement": {
      "description": "sha256:e14d6f9f892c0c278cfe11761d95bffc0fae4b418ae2f3b1a16802cd7b84b311",
      "input_schema": "sha256:aa230792c85af3729d37e4514f5631d837f181d24d8d7330369294846ddba2db",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:402089fbb06749c25744fd8a296e8758a9196cec5815d130f7f719212370e3e1"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageAgents": {
      "description": "sha256:f3e09fa06e26ca0732a89a5b5524a9b116efb76ddce67152dd914ef07cd9c40c",
      "input_schema": "sha256:87cfb6b245aa89fd150783ea611e31d4d211854dbb84379b5d3417bdd5aa10a3",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:d6ebbc414a2d2a59431a5fa06cb57fc4832afe57f48a71f59a1493905e81a040"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageAppAuth": {
      "description": "sha256:65929e766ecab5df1674f9c4656d517162e483463f1393b335b511b80f56178a",
      "input_schema": "sha256:0bcaad7d79be451fc689ebb7e70e8cb59556b387c729255b90813526eb6b0c93",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:46b261b4484abefcdbaaf84127b7aa61754a93ed62e29965d5a4c1a00e94d03a"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageApps": {
      "description": "sha256:82a6dc043bd30f43d3927c074b8090a6e946ce3957364a514886b637b59898a8",
      "input_schema": "sha256:2deda6b225ce094137e06ea240e490f7fa3bc9a48088177876dd26cc1fc9ebb5",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:f8f5926b99322ae332a2bcb1549c847ee2cb2e3f51a26d6c73fe5588b4fee9b5"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageCloudRun": {
      "description": "sha256:d16e74e0c394b87f318ec19be047b9aa7079bf098415b7bd2d797286faa9a927",
      "input_schema": "sha256:2ab354d0ab4c95a60b2a27c442d0de577200606008349d098bd389ac44b85460",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:19f4d6daefaf424176404a65cd68ec1177dcbee3b07632b28012f64919ba5b9f"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageDataModel": {
      "description": "sha256:51111f7bcd028e1d0925c16fb4969b55deed305a86a9ef2d3eabb922ad68536c",
      "input_schema": "sha256:bac4bce1c7015690fa685d00702a76b689c76218c00915e573febd8534bbbad2",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:dae5914f2fb134c64936ba0faa8c4c77d507ebfcff82d073eaaf2a6fdbfc5feb"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageEnv": {
      "description": "sha256:eb0824a61943ada668cc86a3f77e716b6a7d4e18f0de5ddfc9240582aeea66ed",
      "input_schema": "sha256:244939168ee6b09ac7df350391fcbee13f2e585e9b83aaa2c3aaa7c9c42bffab",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:5979c922e6fd7e017636e7871703a5cf93bb7a3035b68aaff1b4d5141c9095e0"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageFunctions": {
      "description": "sha256:2022775cce77756cc156dd8daa9b4c413e6284d0c3616fe60a2b275b811486d8",
      "input_schema": "sha256:21fa50fd783b9e6e71176ed9be6ce9259543f0d156718449770b3aebf8c83a70",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:fb2b247bc4690e3319f51f055998cb65379f73c2386a56c6984c502d982ca948"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageGateway": {
      "description": "sha256:80866fd8207c962513f5fb2b6eb31aa1db6cc9924ad340801f3d902384950b00",
      "input_schema": "sha256:3f73a9e26a7a8e9d2012394eca4df13802c5db5ac0af1fcb78b7667eb74235b1",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:40f8fbeb58405025c694188d7e3bce2789cffccbeb8416148d0091a6f0ae3556"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageHosting": {
      "description": "sha256:1639b15cce04074973dbb07f1d09d5bd2880d891ab07da79b2cc7dbf835be460",
      "input_schema": "sha256:c51ff5e66ed91b92775490b5859588d8c0cb90a5ad473fde358319dff1efea7c",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:720cde1df434c633ef2682df1865fcac655cbc7c3435c2272e581663787c000f"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageLogs": {
      "description": "sha256:f1dfb8a7797a147d4079423d61664cf9ee840280f2e29d0a256799d2610c6819",
      "input_schema": "sha256:52c2c272b3b8d09b0aa13911686a7219fc42772b3bea8f6c1631135d7fcf5ff6",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:ff461012465340d784c95d60b59845ab526ca7cad133938c8db585bb4372c8c6"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageMysqlDatabase": {
      "description": "sha256:9851889c7b3e2fa9e8d60edc48be379581d9170d8c594e75fa86c3c0c6268e14",
      "input_schema": "sha256:eedd3694ebb2c2260cd0d66955680efae283cac7962c063212272088cb4aa17f",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:db67c8414de69b626cf4b601178f00435d8def4b8afb9eed2843b22d9deae69b"
    },
    "tencentcloudbase-cloudbase-mcp:tool:managePermissions": {
      "description": "sha256:4b39116aa2d51513702ac119cddb54b3e69f64cb208391f16def68a9df6436a4",
      "input_schema": "sha256:36c4a9493e8c836c1d53e67038b55b120777057719a357e497f3d12018dc2a50",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:20022ea4fd58fae1683296c68d10f8f0438e09cf51ed2423388aa72311459eec"
    },
    "tencentcloudbase-cloudbase-mcp:tool:managePgDatabase": {
      "description": "sha256:0c2a655fa371750115d92c36ef6b84178d1aa8111d500041be88558ed71a5cf3",
      "input_schema": "sha256:ddb2d3fa492a7de250cfa350e1852f795fb8449f07b8904025a0bdd55a15b7a7",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:1a42bfe12c22302b658cb862f88cc8ebbc1a7c60a8e695c340d3627def1cf867"
    },
    "tencentcloudbase-cloudbase-mcp:tool:manageStorage": {
      "description": "sha256:808e11ab939f5ca88c9a05c732a66ebb85e45d8f9440c3ee72d0c2e0acd17615",
      "input_schema": "sha256:823e18d8a45a787a4ebf4b8d1e496291af185498c505e22f55799ba58242742a",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:b21741e7084093dab1cfc7ca67ae1e9f4b5f23d25cc4a362c356eb5ec4be69a4"
    },
    "tencentcloudbase-cloudbase-mcp:tool:modifyDataModel": {
      "description": "sha256:dce2b32639a4299cc404e3cfecc3ca6e0261c704cd6474791ab869f5e8200e2d",
      "input_schema": "sha256:550cc39eecd1d2be1c01fa73185ac1526d0b1e355509c9972fa3c924876760ab",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:9dc39c5a3b5319b2ef3fd38ee50ae794aa98dd6912e044d3cb7bdb2b8fbc855b"
    },
    "tencentcloudbase-cloudbase-mcp:tool:prepareFeedback": {
      "description": "sha256:f638322c7b1387f6c9ccd0002d5d8716a6f1455d660f889edb26d0da5cf19cdb",
      "input_schema": "sha256:a9b20cda2d72b6f757638d65f7514346bd212b2cfae14711947eaab37ad13ca4",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:8b4ea058bc7e4f2761f540ac46a9ba49444f81d7bc56f6e0db1bb7d8f7105220"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryAgents": {
      "description": "sha256:2c8cf1a09f5957b758505350b9e417ec771ea1d6eaa26a57622c1c391ce1c6f2",
      "input_schema": "sha256:98f6fbfab289dfb9a5a28858e299af680aa8dd39489772c9289514eba995681d",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:9848b7a9afe07049a4b3383123b59f73ab3053ebc3e2862383658a1edfb9638e"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryAppAuth": {
      "description": "sha256:290a926ad0b888f6300403c7e45203142579a4b95412e3b7335891e1e2965d86",
      "input_schema": "sha256:2f2064cf543fffc8a0162cb166d4b0492004db714fbe52e47270a07145330f1e",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:794b129f911d15325b62bbb431548a00015c19bdd90b51aaf88da1c76501a1ba"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryApps": {
      "description": "sha256:f98a334938629478ecbe51f97f32f23067a77a9c54298770ae0c511fbab3fade",
      "input_schema": "sha256:9e5b9e41aca65c53350d63c871c465c06b529818ccb1b05f02d580602070fbaa",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:c54219fa01fe506f7f4d59adfe92fe9e1d6aa5b183c52023304afe4f10afa426"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryCloudRun": {
      "description": "sha256:7741e03ed6440d5a814fe0239391f9db3856cdf26eaa57c41b9f66973c53baec",
      "input_schema": "sha256:1e7963c72e41f680f06ce02ca9db208c4e1eb16b831b228fe4771d851635ca3a",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:6bd1b37354f40122078fd10e730a88d3b4dec8b3b83eae6a1c4ee3a6fb69ac8f"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryEnv": {
      "description": "sha256:3c2509695679fc20482c18336b41da260715e29aac2c9dbf1843a179dc5b9ece",
      "input_schema": "sha256:3488cbed5dfb29fd2b91fc7d0977c570500d7550ac50c28659f14a94aceba2a4",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:476adc95cbdca5bac4069304fa499f631e42ba8a52fa044244fd0c24604af9e0"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryFunctions": {
      "description": "sha256:8b3293867831f7f569982480fa6bd963b8cc0e701f4d1fbb09f774d3bea3e9c3",
      "input_schema": "sha256:fe786fe839ba629e0b2cc36f771fb665b65e27faabcffb42647ce2b429c922fd",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:12dbe6721505e3e5a7e597b5c6212a350f9915553303a38a00d0de2cdc1920b5"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryGateway": {
      "description": "sha256:7f22dbc95c24957eee94d29e204e9144241aaa7944a9cbb62ffabbdb4874f928",
      "input_schema": "sha256:72dd48b01975d63990a385647b94fdd627cab56fba1559bc4bc4fdee73d9a5aa",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:9355f688d7ce0a06a0110ad4306fe2c87d169f6eaa63a0930f2df4db8943fb9f"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryHosting": {
      "description": "sha256:88bbc89d2aba7c2d5c1cf55d165be6bbe7674b7ae6eb387374db5648778fbd46",
      "input_schema": "sha256:ff2e105a36081009e07f1daf5dd92ff616665973b81fd9ca3439791d2e1954ae",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:d95413e733f98116bc6ab7e191e96d1fd863945b337d67352393b39d9ced694e"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryLogs": {
      "description": "sha256:da95af8aced14b3c6de3b9ff3f95f55beb5f04913d5b4e09112ff07c1941527c",
      "input_schema": "sha256:9279129994af2e0f1cb8bf7c6ac3fbf7faacce4b89c12f0ec703172f18165430",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:6dc0def31420a687857594562f3b6dfeef674dcd48e4b9304d11e89c127f3db6"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryMysqlDatabase": {
      "description": "sha256:5faa8a6aa7be1cc9998b55ad81d8df4433ac2964a5d9f7d8dbba629246cefa08",
      "input_schema": "sha256:11cf07b466df508c6331ea5d4a8fb89ee3058320455a43ce3bafc403e2015ff9",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:5fa8bb02e4825b78755fe53f7c3775838782746cc1b5458036a4385b5ffdecad"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryPermissions": {
      "description": "sha256:4af994b07f5b75f341f5cd3398922ab716905f70514be53f88024ed4deb66603",
      "input_schema": "sha256:0c40efbe8a8093894783c19270548d4deedca66ed0f1ad9e61e04e82be0842ba",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:dc72ffcc50369431c9c4aa57c92d1086c4f98808af55595c489b987cba7faee9"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryPgDatabase": {
      "description": "sha256:387ab3aeda29a2fb733102dcde444d7304ce3636293c93c9c409eaa4eaf1b26a",
      "input_schema": "sha256:3230ad1db6ddfa46bb6ea4ab9c0d33c58a42514dc535e475e39bf0f54ec3ee20",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:d27efd2d26af14e257dbdfde15af9662177c80489471fddb860daf97730e47ad"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryPgStorage": {
      "description": "sha256:1ec37fd0b23271af21530f53a53b817d4307e3414b10292cdd80d7e3c97b2e37",
      "input_schema": "sha256:5bfeb69add64081baa3c97c66b73a7226f99d50ae63a6231030a7c7dd5928cab",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:e8574a7309571a2e1da23eec6f87564d68088da0c286077cb9d5cd7e84201456"
    },
    "tencentcloudbase-cloudbase-mcp:tool:queryStorage": {
      "description": "sha256:6b7682836e9fabe71bca6d75234fc34af53847078ec342cf8a33b2b6d12d6db4",
      "input_schema": "sha256:31a638b1d9d4a68fa2314663fa3e9e9a6a1cf508278b609b9cc6c36cb479fd43",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:54267cfe6a2d433b1c6d0732f3e1d5108ba9ebe4f2623deb7a1710f606b1e9e6"
    },
    "tencentcloudbase-cloudbase-mcp:tool:readNoSqlDatabaseContent": {
      "description": "sha256:8aec02be4c2d3cced820ee03d3b840616f06ee9c462e0ac24c0f62b477bc7da3",
      "input_schema": "sha256:ada96a45832fcb8e12ccf7393186462fea13bc5ff5dcbb60c42322de5c8bd951",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:94e6eb0bca23a9a84d73f4760c21032958f46a4410ca7e441e0c4c593487a965"
    },
    "tencentcloudbase-cloudbase-mcp:tool:readNoSqlDatabaseStructure": {
      "description": "sha256:13f0ed105aad18a38ea12ff85861dbd0b6dd0539bb6dfe4cc1c3272220d5fc0c",
      "input_schema": "sha256:19e70dcb9c59b5146cd12782841a01f984be82f3a5d1c3b430e75f2471408e84",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:5820851d984aa2ba768678feda8573c83234664812cb614278b65b767fc93b06"
    },
    "tencentcloudbase-cloudbase-mcp:tool:searchKnowledgeBase": {
      "description": "sha256:b37cd193327d19c23e37a0f670371458525f5808e8ade06bc7fbbe8c9dc04967",
      "input_schema": "sha256:c46e74b016e005d9770cd20809b6ca1bdfdce4ba47ec302cecb7656d6c4fc42b",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:4b351d54a77db71d6d4fd510dd6d868d4100e5869cda95c263fdbb1d182a44a7"
    },
    "tencentcloudbase-cloudbase-mcp:tool:writeNoSqlDatabaseContent": {
      "description": "sha256:1a439a0de5f0c8d83f3797327ed561e78ba9755c7183f315991d96b9c867d278",
      "input_schema": "sha256:a8f790ddb4bbe4f9234ab30bfdb1a2aa3de817283af3337e7f5dc5edbaa43a6d",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:a1a07f0a5d4f009411c20bcace4dd4702e8c3a8d55f7fa80b68bf615547f83c8"
    },
    "tencentcloudbase-cloudbase-mcp:tool:writeNoSqlDatabaseStructure": {
      "description": "sha256:2b9912e6dc2e6988372bc619fcf4c8431042869f71653e95679e5ae33c722f27",
      "input_schema": "sha256:c287df26748413c5e77284e3bdd78c0d1c6c40682daa1982cc86e0724854428e",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:da353c763fc190b2ae371070545eb04be6874591ef11f336f9840a82da3a0f13"
    }
  }
}
