@cloudbase/cloudbase-mcp 2.25.0 → 2.25.2

package/dist/index.js

@@ -2233,7 +2233,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.25.0" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.25.2" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -2314,7 +2314,7 @@ function createWrappedHandler(name, handler, server) {
                 requestId: (typeof error === 'object' && error && 'requestId' in error) ? error.requestId : '',
                 ide: server.ide || process.env.INTEGRATION_IDE || ''
             });
-            const mcpVersion =  true ? "2.25.0" : 0;
+            const mcpVersion =  true ? "2.25.2" : 0;
             const requestIdSuffix = requestId ? `\n🆔 RequestId: ${requestId}` : '';
             const enhancedErrorMessage = `${errorMessage}${requestIdSuffix}\n\n📦 CloudBase MCP v${mcpVersion}\n🔗 遇到问题？请复制以下链接到浏览器打开\n即可自动携带错误详情快速创建 GitHub Issue：\n${issueLink}`;
             // 创建新的错误对象，保持原有的错误类型但更新消息
@@ -2483,7 +2483,6 @@ const capi_js_1 = __webpack_require__(738);
 const cloudrun_js_1 = __webpack_require__(5023);
 const dataModel_js_1 = __webpack_require__(4052);
 const gateway_js_1 = __webpack_require__(4319);
-const invite_code_js_1 = __webpack_require__(4760);
 const agents_js_1 = __webpack_require__(9527);
 const app_auth_js_1 = __webpack_require__(5313);
 const apps_js_1 = __webpack_require__(6817);
@@ -2514,7 +2513,6 @@ const DEFAULT_PLUGINS = [
     "logs",
     "agents",
     "download",
-    "invite-code",
     "capi",
 ];
 function registerDatabase(server) {
@@ -2556,7 +2554,6 @@ const AVAILABLE_PLUGINS = {
     logs: { name: "logs", register: logs_js_1.registerLogTools },
     agents: { name: "agents", register: agents_js_1.registerAgentTools },
     apps: { name: "apps", register: apps_js_1.registerAppTools },
-    "invite-code": { name: "invite-code", register: invite_code_js_1.registerInviteCodeTools },
     cloudrun: { name: "cloudrun", register: cloudrun_js_1.registerCloudRunTools },
     capi: { name: "capi", register: capi_js_1.registerCapiTools },
 };
@@ -2911,6 +2908,153 @@ function registerLogTools(server) {
 
 module.exports = __WEBPACK_EXTERNAL_MODULE__modelcontextprotocol_sdk_types_js_70eb1363__;
 
+/***/ }),
+
+/***/ 2435:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.rankGatewayAccessUrls = rankGatewayAccessUrls;
+exports.flattenHttpServiceRoutes = flattenHttpServiceRoutes;
+exports.filterRoutesByUpstream = filterRoutesByUpstream;
+exports.toAccessUrlEnvelope = toAccessUrlEnvelope;
+exports.resolveGatewayAccessUrls = resolveGatewayAccessUrls;
+exports.preferGatewayOrFallback = preferGatewayOrFallback;
+function normalizeAccessPath(path) {
+    if (!path) {
+        return "/";
+    }
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function buildHttpsUrl(domain, path) {
+    return `https://${domain}${normalizeAccessPath(path)}`;
+}
+/**
+ * Rank gateway route URLs: custom domains (IsDefault !== true) before default domain.
+ * Stable within each group; dedupe by full URL.
+ */
+function rankGatewayAccessUrls(routes) {
+    const mapped = routes
+        .filter((route) => Boolean(route.Domain))
+        .map((route) => {
+        const path = normalizeAccessPath(route.Path);
+        const isDefault = route.IsDefault === true;
+        return {
+            url: buildHttpsUrl(route.Domain, path),
+            domain: route.Domain,
+            path,
+            isDefault,
+            source: (isDefault
+                ? "gateway.default"
+                : "gateway.custom"),
+        };
+    });
+    mapped.sort((a, b) => {
+        if (a.isDefault === b.isDefault) {
+            return 0;
+        }
+        return a.isDefault ? 1 : -1;
+    });
+    const seen = new Set();
+    const deduped = [];
+    for (const item of mapped) {
+        if (seen.has(item.url)) {
+            continue;
+        }
+        seen.add(item.url);
+        deduped.push(item);
+    }
+    return deduped;
+}
+function flattenHttpServiceRoutes(result) {
+    return (result.Domains ?? []).flatMap((domainItem) => (domainItem.Routes ?? []).map((route) => ({
+        Domain: domainItem.Domain ?? "",
+        IsDefault: domainItem.IsDefault,
+        Path: typeof route.Path === "string" ? route.Path : undefined,
+        UpstreamResourceType: typeof route.UpstreamResourceType === "string"
+            ? route.UpstreamResourceType
+            : undefined,
+        UpstreamResourceName: typeof route.UpstreamResourceName === "string"
+            ? route.UpstreamResourceName
+            : undefined,
+    })));
+}
+function filterRoutesByUpstream(routes, input) {
+    const name = input.upstreamResourceName;
+    const types = input.upstreamResourceTypes?.map((t) => String(t));
+    return routes.filter((route) => {
+        if (route.UpstreamResourceName !== name) {
+            return false;
+        }
+        if (!types || types.length === 0) {
+            return true;
+        }
+        return Boolean(route.UpstreamResourceType &&
+            types.includes(String(route.UpstreamResourceType)));
+    });
+}
+function toAccessUrlEnvelope(ranked) {
+    if (ranked.length === 0) {
+        return { accessUrls: [], routes: [] };
+    }
+    return {
+        accessUrl: ranked[0].url,
+        accessUrls: ranked.map((item) => item.url),
+        accessUrlSource: ranked[0].source,
+        routes: ranked,
+    };
+}
+/**
+ * Best-effort lookup of gateway access URLs for an upstream resource.
+ * Never throws — returns empty lists on failure.
+ */
+async function resolveGatewayAccessUrls(input) {
+    try {
+        const manager = await input.getManager();
+        const result = await manager.env.describeHttpServiceRoute({
+            EnvId: input.envId,
+            Limit: 1000,
+        });
+        const flattened = flattenHttpServiceRoutes(result);
+        const matched = filterRoutesByUpstream(flattened, {
+            upstreamResourceName: input.upstreamResourceName,
+            upstreamResourceTypes: input.upstreamResourceTypes,
+        });
+        return toAccessUrlEnvelope(rankGatewayAccessUrls(matched));
+    }
+    catch {
+        return { accessUrls: [], routes: [] };
+    }
+}
+/**
+ * Merge ranked gateway URLs with a resource-native fallback URL.
+ * Gateway custom/default always win over the fallback when present.
+ */
+function preferGatewayOrFallback(input) {
+    if (input.gateway.accessUrl) {
+        const urls = [...input.gateway.accessUrls];
+        if (input.fallbackUrl &&
+            !urls.includes(input.fallbackUrl)) {
+            urls.push(input.fallbackUrl);
+        }
+        return {
+            accessUrl: input.gateway.accessUrl,
+            accessUrls: urls,
+            accessUrlSource: input.gateway.accessUrlSource,
+        };
+    }
+    if (input.fallbackUrl) {
+        return {
+            accessUrl: input.fallbackUrl,
+            accessUrls: [input.fallbackUrl],
+            accessUrlSource: input.fallbackSource,
+        };
+    }
+    return { accessUrls: [] };
+}
+
+
 /***/ }),
 
 /***/ 2448:
@@ -7151,6 +7295,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.registerGatewayTools = registerGatewayTools;
 const zod_1 = __webpack_require__(2971);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
+const gateway_access_urls_js_1 = __webpack_require__(2435);
 const json_content_js_1 = __webpack_require__(4365);
 const QUERY_GATEWAY_ACTIONS = [
     "listRoutes",
@@ -7226,9 +7371,33 @@ function registerGatewayTools(server) {
         IsDefault: domainItem.IsDefault,
         ...route,
     })));
-    const buildRouteUrls = (routes) => Array.from(new Set(routes
-        .filter((route) => route.Domain && route.Path)
-        .map((route) => `https://${route.Domain}${normalizeAccessPath(String(route.Path))}`)));
+    const buildRouteUrls = (routes) => {
+        const candidates = routes.map((route) => ({
+            Domain: route.Domain,
+            Path: route.Path,
+            IsDefault: route.IsDefault,
+            UpstreamResourceType: route.UpstreamResourceType,
+            UpstreamResourceName: route.UpstreamResourceName,
+        }));
+        return (0, gateway_access_urls_js_1.rankGatewayAccessUrls)(candidates).map((item) => item.url);
+    };
+    const buildAccessUrlFields = (routes) => {
+        const candidates = routes.map((route) => ({
+            Domain: route.Domain,
+            Path: route.Path,
+            IsDefault: route.IsDefault,
+            UpstreamResourceType: route.UpstreamResourceType,
+            UpstreamResourceName: route.UpstreamResourceName,
+        }));
+        const envelope = (0, gateway_access_urls_js_1.toAccessUrlEnvelope)((0, gateway_access_urls_js_1.rankGatewayAccessUrls)(candidates));
+        return {
+            ...(envelope.accessUrl ? { accessUrl: envelope.accessUrl } : {}),
+            accessUrls: envelope.accessUrls,
+            ...(envelope.accessUrlSource
+                ? { accessUrlSource: envelope.accessUrlSource }
+                : {}),
+        };
+    };
     const resolveDefaultHttpDomain = async () => {
         const routeInfo = await listHttpServiceRoutes();
         const domains = routeInfo.Domains ?? [];
@@ -7247,36 +7416,24 @@ function registerGatewayTools(server) {
         }
         return resolveDefaultHttpDomain();
     };
-    const mapUpstreamResourceType = (input) => {
-        if (input.upstreamResourceType) {
-            return input.upstreamResourceType;
-        }
-        if (input.type === "HTTP") {
-            return "WEB_SCF";
-        }
-        if (input.type === "Event") {
-            return "SCF";
-        }
-        if (input.requiresFunctionType || input.targetType === "function") {
-            throw new Error("为云函数创建/更新路由时必须显式提供 type（HTTP→WEB_SCF，Event→SCF）或 route.upstreamResourceType。省略会导致 HTTP 与 Event 函数互相误标，访问时可能返回 FUNCTION_PARAM_INVALID 或网关内部错误。");
-        }
-        throw new Error("必须提供 route.upstreamResourceType（SCF / WEB_SCF / CBR / STATIC_STORE / LH），或在函数场景提供 type=\"HTTP\"|\"Event\"。");
+    const resolveUpstreamResourceType = (input) => {
+        const resolved = input.routeUpstreamResourceType ?? input.upstreamResourceType;
+        if (resolved) {
+            return resolved;
+        }
+        throw new Error("必须提供 upstreamResourceType（或 route.upstreamResourceType）：" +
+            "WEB_SCF=HTTP云函数，SCF=Event云函数，CBR=云托管，STATIC_STORE=静态托管，LH=轻量应用服务器。" +
+            "禁止仅凭 targetName/serviceName 推断上游类型。");
     };
     const normalizeRoutePayload = async (input) => {
         const upstreamResourceName = input.route?.serviceName ?? input.targetName;
         if (!upstreamResourceName) {
-            throw new Error("必须提供 targetName 或 route.serviceName 作为上游资源名称（例如云函数名）");
-        }
-        const isFunctionRoute = input.targetType === "function" ||
-            input.type !== undefined ||
-            input.route?.upstreamResourceType === "SCF" ||
-            input.route?.upstreamResourceType === "WEB_SCF" ||
-            (!input.route?.upstreamResourceType && Boolean(input.targetName));
-        const upstreamResourceType = mapUpstreamResourceType({
-            type: input.type,
-            targetType: input.targetType,
-            upstreamResourceType: input.route?.upstreamResourceType,
-            requiresFunctionType: isFunctionRoute,
+            throw new Error("必须提供 targetName 或 route.serviceName 作为上游资源名称：" +
+                "云函数名、云托管服务名，或静态托管实例名（常见为 staticstore）。");
+        }
+        const upstreamResourceType = resolveUpstreamResourceType({
+            upstreamResourceType: input.upstreamResourceType,
+            routeUpstreamResourceType: input.route?.upstreamResourceType,
         });
         const path = normalizeAccessPath(input.route?.path ?? input.path ?? `/${upstreamResourceName}`);
         const domain = await resolveRouteDomain(input.domain);
@@ -7285,18 +7442,25 @@ function registerGatewayTools(server) {
             : input.auth !== undefined
                 ? input.auth
                 : undefined;
+        const enablePathTransmission = input.route?.enablePathTransmission !== undefined
+            ? input.route.enablePathTransmission
+            : input.enablePathTransmission !== undefined
+                ? input.enablePathTransmission
+                : undefined;
+        const route = {
+            Path: path,
+            UpstreamResourceType: upstreamResourceType,
+            UpstreamResourceName: upstreamResourceName,
+            EnableAuth: enableAuth,
+        };
+        if (enablePathTransmission !== undefined) {
+            route.EnablePathTransmission = enablePathTransmission;
+        }
         return {
             EnvId: await resolveEnvId(),
             Domain: {
                 Domain: domain,
-                Routes: [
-                    {
-                        Path: path,
-                        UpstreamResourceType: upstreamResourceType,
-                        UpstreamResourceName: upstreamResourceName,
-                        EnableAuth: enableAuth,
-                    },
-                ],
+                Routes: [route],
             },
             resolved: {
                 domain,
@@ -7304,6 +7468,7 @@ function registerGatewayTools(server) {
                 upstreamResourceType,
                 upstreamResourceName,
                 enableAuth,
+                enablePathTransmission,
             },
         };
     };
@@ -7343,6 +7508,7 @@ function registerGatewayTools(server) {
                     action: input.action,
                     routes,
                     urls: buildRouteUrls(routes),
+                    ...buildAccessUrlFields(routes),
                     total: result.TotalCount ?? routes.length,
                     raw: result,
                 }, `已获取 ${result.TotalCount ?? routes.length} 条 HTTP 路由`);
@@ -7384,6 +7550,7 @@ function registerGatewayTools(server) {
                     routes: matches,
                     total: matches.length,
                     urls,
+                    ...buildAccessUrlFields(matches),
                     raw: result,
                 }, matches.length === 0
                     ? "未找到对应路由"
@@ -7417,9 +7584,10 @@ function registerGatewayTools(server) {
                     const message = err instanceof Error ? err.message : String(err);
                     if (message.includes("An error has occurred")) {
                         let hint = "为目标资源配置访问路由失败（后端内部错误）。请确保：1) 目标云函数已成功创建并处于 Active 状态；2) 环境默认 HTTP 域名已完成初始化（IsDefault）；3) 该访问路径未被占用。";
-                        if (input.type === "HTTP") {
+                        if (payload.resolved.upstreamResourceType === "WEB_SCF" ||
+                            payload.resolved.upstreamResourceType === "SCF") {
                             hint +=
-                                "此外注意：如果目标函数最初是作为 Event 函数创建的，这里 type 仍必须传 Event（UpstreamResourceType=SCF）；误传 HTTP/WEB_SCF 会导致此错误。";
+                                "此外注意：HTTP 云函数必须用 upstreamResourceType=WEB_SCF，Event 云函数必须用 SCF；互标会导致此错误。";
                         }
                         throw new Error(`${hint} 原始错误：${message}`);
                     }
@@ -7429,15 +7597,26 @@ function registerGatewayTools(server) {
                 return buildEnvelope({
                     action: input.action,
                     model: "httpServiceRoute",
-                    targetType: input.targetType ?? null,
                     targetName: payload.resolved.upstreamResourceName,
                     domain: payload.resolved.domain,
                     path: payload.resolved.path,
                     upstreamResourceType: payload.resolved.upstreamResourceType,
                     upstreamResourceName: payload.resolved.upstreamResourceName,
                     auth: payload.resolved.enableAuth ?? null,
+                    enablePathTransmission: payload.resolved.enablePathTransmission ?? null,
+                    accessUrl: `https://${payload.resolved.domain}${payload.resolved.path}`,
+                    accessUrls: [`https://${payload.resolved.domain}${payload.resolved.path}`],
+                    accessUrlSource: input.domain && input.domain === payload.resolved.domain
+                        ? "gateway.custom"
+                        : "gateway.default",
                     raw: result,
-                }, `已为目标 ${payload.resolved.upstreamResourceName} 在域名 ${payload.resolved.domain} 创建路由 ${payload.resolved.path}（${payload.resolved.upstreamResourceType}）。注意：路由配置传播通常需要等待 30 秒到 3 分钟，请勿立即访问。该操作只创建网关入口，不会自动放开函数安全规则；若需要匿名或浏览器直接访问，请继续检查函数资源权限。`, routeMutationNextActions(payload.resolved.upstreamResourceName));
+                }, `已为目标 ${payload.resolved.upstreamResourceName} 在域名 ${payload.resolved.domain} 创建路由 ${payload.resolved.path}（${payload.resolved.upstreamResourceType}）` +
+                    (payload.resolved.enablePathTransmission === true
+                        ? "；已开启路径透传（后端收到完整请求路径）"
+                        : payload.resolved.enablePathTransmission === false
+                            ? "；路径透传关闭（网关会剥掉触发路径前缀后再转发给后端）"
+                            : "；路径透传未显式设置（平台默认 false，会剥掉触发路径前缀）") +
+                    `。注意：路由配置传播通常需要等待 30 秒到 3 分钟，请勿立即访问。该操作只创建网关入口，不会自动放开上游权限；若上游是云函数且需要匿名或浏览器直接访问，请继续检查函数资源权限。`, routeMutationNextActions(payload.resolved.upstreamResourceName));
             }
             case "updateRoute": {
                 const cloudbase = await getManager();
@@ -7455,8 +7634,20 @@ function registerGatewayTools(server) {
                     upstreamResourceType: payload.resolved.upstreamResourceType,
                     upstreamResourceName: payload.resolved.upstreamResourceName,
                     auth: payload.resolved.enableAuth ?? null,
+                    enablePathTransmission: payload.resolved.enablePathTransmission ?? null,
+                    accessUrl: `https://${payload.resolved.domain}${payload.resolved.path}`,
+                    accessUrls: [`https://${payload.resolved.domain}${payload.resolved.path}`],
+                    accessUrlSource: input.domain && input.domain === payload.resolved.domain
+                        ? "gateway.custom"
+                        : "gateway.default",
                     raw: result,
-                }, `HTTP 路由更新成功（${payload.resolved.domain}${payload.resolved.path}）`, routeMutationNextActions(payload.resolved.upstreamResourceName));
+                }, `HTTP 路由更新成功（${payload.resolved.domain}${payload.resolved.path}` +
+                    (payload.resolved.enablePathTransmission === true
+                        ? "，路径透传=开启"
+                        : payload.resolved.enablePathTransmission === false
+                            ? "，路径透传=关闭"
+                            : "") +
+                    `）`, routeMutationNextActions(payload.resolved.upstreamResourceName));
             }
             case "deleteRoute": {
                 const routePath = input.route?.path ?? input.path;
@@ -7522,19 +7713,17 @@ function registerGatewayTools(server) {
     };
     server.registerTool?.("queryGateway", {
         title: "查询 CloudBase 网关",
-        description: "CloudBase 网关统一只读入口（Domain/Route 模型）。通过 listRoutes / getRoute / listCustomDomains 查询域名与路由；主键为 Domain + Path，上游类型为 SCF / WEB_SCF / CBR / STATIC_STORE / LH。",
+        description: "CloudBase HTTP 网关统一只读入口（Domain/Route）。查询域名下路径路由及其上游：" +
+            "WEB_SCF/SCF=云函数，CBR=云托管，STATIC_STORE=静态托管，LH=轻量应用服务器。" +
+            "主键为 Domain + Path；listRoutes / getRoute / listCustomDomains。",
         inputSchema: {
             action: zod_1.z
                 .enum(QUERY_GATEWAY_ACTIONS)
                 .describe("只读操作类型：listRoutes、getRoute、listCustomDomains"),
-            targetType: zod_1.z
-                .enum(["function"])
-                .optional()
-                .describe("目标资源类型。当前支持 function"),
             targetName: zod_1.z
                 .string()
                 .optional()
-                .describe("上游资源名称。getRoute 时可按云函数名过滤"),
+                .describe("上游资源名过滤（UpstreamResourceName）：云函数名、云托管服务名，或静态托管实例名（常见 staticstore）。"),
             routeId: zod_1.z.string().optional().describe("路由 ID。getRoute 时可选"),
             path: zod_1.z
                 .string()
@@ -7553,40 +7742,68 @@ function registerGatewayTools(server) {
     }, async (input) => withEnvelope(() => handleQueryGateway(input)));
     server.registerTool?.("manageGateway", {
         title: "管理 CloudBase 网关",
-        description: "CloudBase 网关统一写入口（Domain/Route 模型）。为已存在的 HTTP 云函数补默认域名访问时，使用 createRoute，并提供 targetType=\"function\"、targetName、type=\"HTTP\"（映射 WEB_SCF）与期望 path；Event 函数传 type=\"Event\"（映射 SCF）。未传 domain 时自动解析 IsDefault 默认域名。注意 createRoute 只创建网关入口，不会自动修改函数资源权限。更新鉴权用 updateRoute；删除用 deleteRoute（Domain+Path）。⚠️ 绑定带 SSL 证书的自定义域名用 bindCustomDomain；CORS/安全域名请使用 envDomainManagement。",
+        description: "CloudBase HTTP 网关统一写入口（Domain/Route）。createRoute/updateRoute/deleteRoute 把域名下的 path 转到上游；未传 domain 时用 IsDefault 默认域名。" +
+            "上游类型只用一个参数 upstreamResourceType（也可写在 route.upstreamResourceType，route 优先）：" +
+            "WEB_SCF=HTTP云函数，SCF=Event云函数，CBR=云托管，STATIC_STORE=静态托管，LH=轻量应用服务器；" +
+            "配合 targetName 或 route.serviceName（云函数名/云托管服务名/静态托管实例名，常见 staticstore）。" +
+            "createRoute 只建网关入口，不改上游权限。" +
+            "enablePathTransmission：默认 false 剥触发路径前缀；true 透传完整路径（CBR 多路由、WEB_SCF 自管子路径常需 true；STATIC_STORE 自定义触发路径映射站点根通常 false）。" +
+            "⚠️ SSL 自定义域名用 bindCustomDomain；CORS/安全域名用 envDomainManagement。",
         inputSchema: {
             action: zod_1.z
                 .enum(MANAGE_GATEWAY_ACTIONS)
-                .describe("写操作类型。为已有函数补默认域名访问入口时使用 createRoute；函数场景必须显式提供 type（HTTP→WEB_SCF，Event→SCF）或 route.upstreamResourceType。"),
-            targetType: zod_1.z
-                .enum(["function"])
-                .optional()
-                .describe("目标资源类型。当前支持 function"),
+                .describe("写操作：createRoute/updateRoute/deleteRoute 管理路由；bindCustomDomain/deleteCustomDomain 管理自定义域名。" +
+                "createRoute/updateRoute 必须提供 upstreamResourceType。"),
             targetName: zod_1.z
                 .string()
                 .optional()
-                .describe("目标资源名称。createRoute 到云函数时填写函数名"),
+                .describe("上游资源名称（UpstreamResourceName），与 route.serviceName 二选一（route 优先）。" +
+                "云函数=函数名；云托管=服务名；静态托管=实例名（常见 staticstore）。不会自动推断上游类型。"),
             path: zod_1.z
                 .string()
                 .optional()
-                .describe("访问路径，默认 /{targetName}。例如为 HTTP 函数暴露 /api/hello 时传 /api/hello。该参数只创建网关入口，不会自动放开函数资源权限。"),
-            type: zod_1.z
-                .enum(["Event", "HTTP"])
+                .describe("触发路径（网关匹配前缀），默认 /{上游名}。例：云函数 /api/hello、云托管 /api、静态托管 / 或 /app。" +
+                "只建网关入口；与 enablePathTransmission 共同决定上游实际收到的路径。"),
+            upstreamResourceType: zod_1.z
+                .enum(UPSTREAM_RESOURCE_TYPES)
                 .optional()
-                .describe("目标函数运行时类型，不是接入协议。HTTP 云函数传 HTTP（UpstreamResourceType=WEB_SCF）；Event 函数传 Event（SCF）。误标会导致 FUNCTION_PARAM_INVALID 或网关错误。函数路由场景必须显式提供 type 或 route.upstreamResourceType。"),
+                .describe("上游类型（与 route.upstreamResourceType 二选一，route 优先）。" +
+                "WEB_SCF=HTTP云函数，SCF=Event云函数，CBR=云托管，STATIC_STORE=静态托管，LH=轻量应用服务器。" +
+                "createRoute/updateRoute 必填其一；勿把 manageFunctions 的 type=HTTP|Event 传到本字段。"),
             auth: zod_1.z
                 .boolean()
                 .optional()
-                .describe("是否开启网关路径鉴权（EnableAuth）。若要走默认域名做匿名或浏览器访问，通常设为 false；该开关仅控制网关入口本身，不会修改函数资源权限。"),
+                .describe("网关路径鉴权（EnableAuth）。匿名/浏览器公网访问通常 false。" +
+                "只控制网关入口；云函数安全规则、云托管鉴权、静态托管权限需各自工具另行配置。"),
+            enablePathTransmission: zod_1.z
+                .boolean()
+                .optional()
+                .describe("路径透传（EnablePathTransmission），平台默认 false。例 path=/api 且请求 /api/users：" +
+                "false→上游收到 /users；true→上游收到 /api/users。" +
+                "CBR 云托管（Express 等自管子路由）与 WEB_SCF 多路径函数常需 true；" +
+                "STATIC_STORE 把触发路径映射到站点根目录（如 /app → 托管 /）时通常 false；" +
+                "单入口/根路径处理保持 false。也可用 route.enablePathTransmission（route 优先）。"),
             route: zod_1.z
                 .object({
                 path: zod_1.z.string().optional(),
-                serviceName: zod_1.z.string().optional(),
-                upstreamResourceType: zod_1.z.enum(UPSTREAM_RESOURCE_TYPES).optional(),
+                serviceName: zod_1.z
+                    .string()
+                    .optional()
+                    .describe("上游实例名：云函数名 / 云托管服务名 / 静态托管实例名（常见 staticstore）/ LH 实例。优先于顶层 targetName。"),
+                upstreamResourceType: zod_1.z
+                    .enum(UPSTREAM_RESOURCE_TYPES)
+                    .optional()
+                    .describe("同顶层 upstreamResourceType。route 内设置时优先于顶层。"),
                 auth: zod_1.z.boolean().optional(),
+                enablePathTransmission: zod_1.z
+                    .boolean()
+                    .optional()
+                    .describe("同顶层 enablePathTransmission。route 内设置时优先于顶层。"),
             })
                 .optional()
-                .describe("HTTP 路由配置。upstreamResourceType 可选 SCF / WEB_SCF / CBR / STATIC_STORE / LH"),
+                .describe("路由对象（可选写法）。例：云函数 {upstreamResourceType:\"WEB_SCF\",serviceName:\"fn\",path:\"/api\"}；" +
+                "云托管 {upstreamResourceType:\"CBR\",serviceName:\"svc\",path:\"/api\"}；" +
+                "静态托管 {upstreamResourceType:\"STATIC_STORE\",serviceName:\"staticstore\",path:\"/\"}。"),
             domain: zod_1.z
                 .string()
                 .optional()
@@ -7648,70 +7865,6 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_fs__;
 
 module.exports = __WEBPACK_EXTERNAL_MODULE__modelcontextprotocol_sdk_server_mcp_js_45c326f0__;
 
-/***/ }),
-
-/***/ 4760:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.registerInviteCodeTools = registerInviteCodeTools;
-const zod_1 = __webpack_require__(2971);
-const cloudbase_manager_js_1 = __webpack_require__(3431);
-function registerInviteCodeTools(server) {
-    const cloudBaseOptions = server.cloudBaseOptions;
-    const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
-    server.registerTool?.("activateInviteCode", {
-        title: "激活邀请码",
-        description: "云开发 AI编程激励计划，通过邀请码激活用户激励。",
-        inputSchema: {
-            InviteCode: zod_1.z.string().describe("待激活的邀请码")
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-            category: "invite-code"
-        }
-    }, async ({ InviteCode }) => {
-        if (!InviteCode) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            ErrorCode: 'MissingParameter',
-                            ErrorMsg: '邀请码为必填项',
-                            RequestId: ''
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        const manager = await getManager();
-        const EnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-        const result = await manager.commonService().call({
-            Action: 'ActivateInviteCode',
-            Param: { InviteCode, EnvId }
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        ErrorCode: result?.ErrorCode || '',
-                        ErrorMsg: result?.ErrorMsg || '',
-                        RequestId: result?.RequestId || ''
-                    }, null, 2)
-                }
-            ]
-        };
-    });
-}
-
-
 /***/ }),
 
 /***/ 4848:
@@ -8249,7 +8402,9 @@ const path_1 = __importDefault(__webpack_require__(2521));
 const zod_1 = __webpack_require__(2971);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
 const logger_js_1 = __webpack_require__(3039);
+const gateway_access_urls_js_1 = __webpack_require__(2435);
 const notification_js_1 = __webpack_require__(2720);
+const cloudrun_config_js_1 = __webpack_require__(8266);
 // CloudRun service types
 exports.CLOUDRUN_SERVICE_TYPES = ['function', 'container'];
 // CloudRun access types
@@ -8268,10 +8423,11 @@ const queryCloudRunInputSchema = {
 };
 // Input schema for manageCloudRun tool
 const ManageCloudRunInputSchema = {
-    action: zod_1.z.enum(['init', 'download', 'run', 'deploy', 'delete', 'createAgent']).describe('云托管服务管理操作类型：init=从模板初始化新的云托管项目代码（在targetPath目录下创建以serverName命名的子目录，支持多种语言和框架模板），download=从云端下载现有服务的代码到本地进行开发，run=在本地运行函数型云托管服务（用于开发和调试，仅支持函数型服务），deploy=将本地代码部署到云端云托管服务（支持函数型和容器型），delete=删除指定的云托管服务（不可恢复，需要确认），createAgent=创建函数型Agent（基于函数型云托管开发AI智能体）'),
+    action: zod_1.z.enum(['init', 'download', 'run', 'deploy', 'delete', 'createAgent', 'updateConfig']).describe('云托管服务管理操作类型：init=从模板初始化新的云托管项目代码（在targetPath目录下创建以serverName命名的子目录，支持多种语言和框架模板），download=从云端下载现有服务的代码到本地进行开发，run=在本地运行函数型云托管服务（用于开发和调试，仅支持函数型服务），deploy=将本地代码部署到云端云托管服务（支持函数型和容器型；已存在服务会 Read-Merge-Write 保留远程 VpcConf/EnvParams/OpenAccessTypes），updateConfig=仅更新服务配置不重新上传代码（对齐控制台服务设置，走 SubmitServerConfigChangeDiff；不需要 targetPath），delete=删除指定的云托管服务（不可恢复，需要确认），createAgent=创建函数型Agent（基于函数型云托管开发AI智能体）'),
     serverName: zod_1.z.string().describe('云托管服务名称，用于标识和管理服务。命名规则：支持大小写字母、数字、连字符和下划线，必须以字母开头，长度3-45个字符。在init操作中会作为在targetPath下创建的子目录名，在其他操作中作为目标服务名'),
     // Deploy operation parameters
-    targetPath: zod_1.z.string().optional().describe('本地代码路径，必须是绝对路径。在deploy操作中指定要部署的代码目录，在download操作中指定下载目标目录，在init操作中指定云托管服务的上级目录（会在该目录下创建以serverName命名的子目录）。建议约定：项目根目录下的cloudrun/目录，例如：/Users/username/projects/my-project/cloudrun'),
+    targetPath: zod_1.z.string().optional().describe('本地代码路径，必须是绝对路径。在deploy操作中指定要部署的代码目录，在download操作中指定下载目标目录，在init操作中指定云托管服务的上级目录（会在该目录下创建以serverName命名的子目录）。updateConfig 不需要此参数。建议约定：项目根目录下的cloudrun/目录，例如：/Users/username/projects/my-project/cloudrun'),
+    envParamsReplaceAll: zod_1.z.boolean().optional().default(false).describe('EnvParams 合并策略（deploy / updateConfig）：false（默认）= 与远程按 key 合并（输入覆盖同名 key，远程其余 key 保留）；true= 用输入 EnvParams 整包替换远程。仅当显式传入 EnvParams 时生效'),
     serverConfig: zod_1.z.object({
         OpenAccessTypes: zod_1.z.array(zod_1.z.enum(exports.CLOUDRUN_ACCESS_TYPES)).optional().describe('公网访问类型配置，控制服务的访问权限：OA=办公网访问，PUBLIC=公网访问（默认，可通过HTTPS域名访问），MINIAPP=小程序访问，VPC=VPC访问（仅同VPC内可访问）。可配置多个类型'),
         Cpu: zod_1.z.number().positive().optional().describe('CPU规格配置，单位为核。可选值：0.25、0.5、1、2、4、8等。注意：内存规格必须是CPU规格的2倍（如CPU=0.25时内存=0.5，CPU=1时内存=2）。影响服务性能和计费'),
@@ -8310,7 +8466,7 @@ const ManageCloudRunInputSchema = {
         VpcConf: zod_1.z.object({
             VpcId: zod_1.z.string().describe('VPC网络ID，格式如 vpc-xxxxxxxx。必须与目标数据库/Redis 处于同一地域，并优先选择同一 VPC。禁止猜测或使用占位符；须来自数据库控制台、已有资源详情、callCloudApi 或用户确认。建议首次创建即配置；已存在服务也可在 deploy 时传入，部署后必须用 queryCloudRun detail 复核是否生效'),
             SubnetId: zod_1.z.string().describe('子网ID，格式如 subnet-xxxxxxxx。云托管实例将占用该子网 IP，需确保有足够可用 IP'),
-        }).optional().describe('VPC网络配置（实例出网/私有网络）。用于让云托管实例接入指定 VPC，从而内网访问 MySQL/PostgreSQL/Redis/CVM 等资源。与 OpenAccessTypes（外部如何访问本服务）是不同概念。TCP 连库场景必须配置。禁止猜测 VpcId/SubnetId，须来自数据库控制台、已有资源详情、callCloudApi 或用户确认。MCP 在创建时会将 VpcConf 映射为 SDK vpcInfo(CreateType=2)；更新后必须用 queryCloudRun detail 复核 ServerConfig.VpcConf，未生效再走控制台网络设置或删建兜底'),
+        }).optional().describe('VPC网络配置（实例出网/私有网络）。用于让云托管实例接入指定 VPC，从而内网访问 MySQL/PostgreSQL/Redis/CVM 等资源。与 OpenAccessTypes（外部如何访问本服务）是不同概念。TCP 连库场景必须配置。禁止猜测 VpcId/SubnetId，须来自数据库控制台、已有资源详情、callCloudApi 或用户确认。创建时映射为 SDK vpcInfo(CreateType=2)；已存在服务可用 updateConfig 或 deploy（RMW 会保留未传入的远程 VpcConf）。部署/更新后必须用 queryCloudRun detail 复核 ServerConfig.VpcConf'),
         VolumesConf: zod_1.z.array(zod_1.z.object({
             VolumeName: zod_1.z.string().describe('存储卷名称'),
             VolumeType: zod_1.z.string().describe('存储卷类型，如CFS表示云文件存储'),
@@ -8320,7 +8476,7 @@ const ManageCloudRunInputSchema = {
             PublicAccess: zod_1.z.boolean().optional().describe('是否开启公网访问，true=开启公网访问，false=关闭公网访问'),
             PublicAccessPath: zod_1.z.string().optional().describe('公网访问路径配置')
         }).optional().describe('公网访问配置，用于控制服务的公网访问策略。可配置是否开启公网访问及访问路径'),
-    }).optional().describe('服务配置项，用于部署时设置服务的运行参数。包括资源规格、访问权限、环境变量、日志、网络等配置。不提供时使用默认配置'),
+    }).optional().describe('服务配置项，用于 deploy / updateConfig。包括资源规格、访问权限、环境变量、日志、网络等。deploy 未提供时对已存在服务仍会从远程合并保留 VpcConf/EnvParams/OpenAccessTypes；updateConfig 至少需要一个配置字段'),
     // Init operation parameters
     template: zod_1.z.string().optional().default('helloworld').describe('项目模板标识符，用于指定初始化项目时使用的模板。可通过queryCloudRun的templates操作获取可用模板列表。常用模板：helloworld=Hello World示例，nodejs=Node.js项目模板，python=Python项目模板等'),
     // Run operation parameters (function services only)
@@ -8504,6 +8660,30 @@ function normalizeProcessLogText(logs) {
     })
         .join("\n");
 }
+function normalizeCloudRunDomainUrl(input) {
+    if (typeof input !== "string" || !input.trim())
+        return undefined;
+    const raw = input.trim();
+    return raw.startsWith("http://") || raw.startsWith("https://")
+        ? raw
+        : `https://${raw}`;
+}
+function resolveCloudRunFallbackAccess(details) {
+    const custom = normalizeCloudRunDomainUrl(details?.BaseInfo?.CustomDomainName);
+    if (custom)
+        return { url: custom, source: "cloudrun.customDomain" };
+    const defaultDomain = normalizeCloudRunDomainUrl(details?.BaseInfo?.DefaultDomainName);
+    if (defaultDomain)
+        return { url: defaultDomain, source: "cloudrun.defaultDomain" };
+    const publicDomain = normalizeCloudRunDomainUrl(details?.BaseInfo?.PublicDomain) ??
+        normalizeCloudRunDomainUrl(details?.AccessInfo?.PublicDomain);
+    if (publicDomain)
+        return { url: publicDomain, source: "cloudrun.publicDomain" };
+    const internal = normalizeCloudRunDomainUrl(details?.BaseInfo?.InternalDomain);
+    if (internal)
+        return { url: internal, source: "cloudrun.internalDomain" };
+    return {};
+}
 /**
  * Format CloudRun service info for display
  */
@@ -8737,7 +8917,7 @@ function registerCloudRunTools(server) {
     // Tool 2: Manage CloudRun services (write operations)
     server.registerTool("manageCloudRun", {
         title: "管理 CloudRun 服务",
-        description: "管理云托管服务，按开发顺序支持：初始化项目（可从模板开始，模板列表可通过 queryCloudRun 查询）、下载服务代码、本地运行（仅函数型服务）、部署代码、删除服务。部署可配置CPU、内存、实例数、访问类型等参数。删除操作需要确认，建议设置force=true。",
+        description: "管理云托管服务，按开发顺序支持：初始化项目（可从模板开始，模板列表可通过 queryCloudRun 查询）、下载服务代码、本地运行（仅函数型服务）、部署代码、仅更新配置（updateConfig，无需重新上传代码）、删除服务。deploy 对已存在服务会先读取远程配置再合并（保留 VpcConf/EnvParams/OpenAccessTypes）。updateConfig 对齐控制台服务设置页。删除操作需要确认，建议设置force=true。",
         inputSchema: ManageCloudRunInputSchema,
         annotations: {
             readOnlyHint: false,
@@ -8928,6 +9108,8 @@ for await (let x of res.textStream) {
                 }
                 // Determine service type - use input.serverType if provided, otherwise auto-detect
                 let serverType;
+                let remoteServerConfig = null;
+                let existingService = false;
                 if (input.serverType) {
                     serverType = input.serverType;
                 }
@@ -8936,6 +9118,8 @@ for await (let x of res.textStream) {
                         // First try to get existing service details
                         const details = await cloudrunService.detail({ serverName: input.serverName });
                         serverType = details.BaseInfo?.ServerType || 'container';
+                        remoteServerConfig = (details.ServerConfig || null);
+                        existingService = true;
                     }
                     catch (e) {
                         // If service doesn't exist, determine by project structure
@@ -8969,20 +9153,40 @@ for await (let x of res.textStream) {
                         }
                     }
                 }
+                // When serverType was provided explicitly, still try to load remote config for RMW.
+                if (!existingService) {
+                    try {
+                        const details = await cloudrunService.detail({ serverName: input.serverName });
+                        remoteServerConfig = (details.ServerConfig || null);
+                        existingService = true;
+                    }
+                    catch {
+                        // New service create path
+                    }
+                }
+                let mergedFromRemote = [];
+                let effectiveServerConfig = input.serverConfig;
+                if (existingService) {
+                    const mergedResult = (0, cloudrun_config_js_1.mergeCloudRunServerConfig)({
+                        remote: remoteServerConfig,
+                        input: input.serverConfig || {},
+                        envParamsReplaceAll: Boolean(input.envParamsReplaceAll),
+                    });
+                    effectiveServerConfig = mergedResult.merged;
+                    mergedFromRemote = mergedResult.mergedFromRemote;
+                }
                 const deployParams = {
                     serverName: input.serverName,
                     targetPath: targetPath,
                     force: input.force,
                     serverType: serverType,
                 };
-                // Add server configuration if provided
-                if (input.serverConfig) {
-                    deployParams.serverConfig = input.serverConfig;
+                if (effectiveServerConfig && Object.keys(effectiveServerConfig).length > 0) {
+                    deployParams.serverConfig = effectiveServerConfig;
                 }
                 // Manager SDK create path prefers top-level vpcInfo (CreateCloudRunServer.VpcInfo).
                 // Map serverConfig.VpcConf → vpcInfo so first-time create actually binds VPC.
-                // Update path still sends Items.VpcConf; platform may ignore VPC changes on existing services.
-                const vpcConf = input.serverConfig?.VpcConf;
+                const vpcConf = effectiveServerConfig?.VpcConf;
                 if (vpcConf?.VpcId?.trim() && vpcConf?.SubnetId?.trim()) {
                     deployParams.vpcInfo = {
                         VpcId: vpcConf.VpcId.trim(),
@@ -9013,47 +9217,46 @@ for await (let x of res.textStream) {
                 catch (error) {
                     (0, logger_js_1.debug)('cloudbaserc.json creation skipped:', error instanceof Error ? error : new Error(String(error)));
                 }
+                let preferredAccessUrl;
+                let preferredAccessUrls = [];
+                let preferredAccessSource;
+                let verifiedConfigSnapshot;
+                try {
+                    const serviceDetails = await cloudrunService.detail({
+                        serverName: input.serverName,
+                    });
+                    verifiedConfigSnapshot = (0, cloudrun_config_js_1.summarizeConfigSnapshot)(serviceDetails?.ServerConfig);
+                    const fallback = resolveCloudRunFallbackAccess(serviceDetails);
+                    const gateway = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                        envId: currentEnvId,
+                        upstreamResourceName: input.serverName,
+                        upstreamResourceTypes: ["CBR"],
+                        getManager: async () => {
+                            const manager = await getManager();
+                            if (!manager) {
+                                throw new Error("cloudbase manager unavailable");
+                            }
+                            return manager;
+                        },
+                    });
+                    const preferred = (0, gateway_access_urls_js_1.preferGatewayOrFallback)({
+                        gateway,
+                        fallbackUrl: fallback.url,
+                        fallbackSource: fallback.source,
+                    });
+                    preferredAccessUrl = preferred.accessUrl;
+                    preferredAccessUrls = preferred.accessUrls;
+                    preferredAccessSource = preferred.accessUrlSource;
+                }
+                catch {
+                    // best-effort URL enrichment only
+                }
                 // Send deployment notification to CodeBuddy IDE
                 try {
-                    // Query service details to get access URL
-                    let serviceUrl = "";
-                    try {
-                        const serviceDetails = await cloudrunService.detail({ serverName: input.serverName });
-                        // Extract access URL from service details
-                        // Priority: DefaultDomainName > CustomDomainName > PublicDomain > InternalDomain
-                        const details = serviceDetails; // Use any to access dynamic properties
-                        if (details?.BaseInfo?.DefaultDomainName) {
-                            // DefaultDomainName is already a complete URL (e.g., https://...)
-                            serviceUrl = details.BaseInfo.DefaultDomainName;
-                        }
-                        else if (details?.BaseInfo?.CustomDomainName) {
-                            // CustomDomainName might be a domain without protocol
-                            const customDomain = details.BaseInfo.CustomDomainName;
-                            serviceUrl = customDomain.startsWith('http') ? customDomain : `https://${customDomain}`;
-                        }
-                        else if (details?.BaseInfo?.PublicDomain) {
-                            serviceUrl = `https://${details.BaseInfo.PublicDomain}`;
-                        }
-                        else if (details?.BaseInfo?.InternalDomain) {
-                            serviceUrl = `https://${details.BaseInfo.InternalDomain}`;
-                        }
-                        else if (details?.AccessInfo?.PublicDomain) {
-                            serviceUrl = `https://${details.AccessInfo.PublicDomain}`;
-                        }
-                        else {
-                            serviceUrl = ""; // URL not available
-                        }
-                    }
-                    catch (detailErr) {
-                        // If query fails, continue with empty URL
-                        serviceUrl = "";
-                    }
-                    // Extract project name from targetPath
                     const projectName = path_1.default.basename(targetPath);
-                    // Send notification
                     await (0, notification_js_1.sendDeployNotification)(server, {
                         deployType: 'cloudrun',
-                        url: serviceUrl,
+                        url: preferredAccessUrl ?? "",
                         projectId: currentEnvId,
                         projectName: projectName,
                         consoleUrl: consoleUrl
@@ -9064,8 +9267,8 @@ for await (let x of res.textStream) {
                     // Error is already logged in sendDeployNotification
                 }
                 const dbNetworkRisk = detectCloudRunDbNetworkRisk({
-                    envParams: input.serverConfig?.EnvParams,
-                    vpcConf: input.serverConfig?.VpcConf,
+                    envParams: effectiveServerConfig?.EnvParams,
+                    vpcConf: effectiveServerConfig?.VpcConf,
                 });
                 const warnings = dbNetworkRisk ? [dbNetworkRisk] : [];
                 const warningSuffix = dbNetworkRisk
@@ -9084,6 +9287,25 @@ for await (let x of res.textStream) {
                                     serverType: serverType,
                                     cloudbasercGenerated: true,
                                     consoleUrl,
+                                    ...(existingService
+                                        ? {
+                                            configMerge: {
+                                                existingService: true,
+                                                mergedFromRemote,
+                                                appliedConfig: (0, cloudrun_config_js_1.summarizeConfigSnapshot)(effectiveServerConfig),
+                                                ...(verifiedConfigSnapshot
+                                                    ? { verifiedAfterDeploy: verifiedConfigSnapshot }
+                                                    : {}),
+                                            },
+                                        }
+                                        : {}),
+                                    ...(preferredAccessUrl ? { accessUrl: preferredAccessUrl } : {}),
+                                    ...(preferredAccessUrls.length > 0
+                                        ? { accessUrls: preferredAccessUrls }
+                                        : {}),
+                                    ...(preferredAccessSource
+                                        ? { accessUrlSource: preferredAccessSource }
+                                        : {}),
                                     ...(warnings.length > 0 ? { warnings } : {}),
                                 },
                                 message: `Triggered deployment for ${serverType} service '${input.serverName}' from ${targetPath}. You can follow the progress in ${consoleUrl}.${warningSuffix}`
@@ -9092,6 +9314,125 @@ for await (let x of res.textStream) {
                     ]
                 };
             }
+            case 'updateConfig': {
+                if (!input.serverConfig || Object.keys(input.serverConfig).length === 0) {
+                    throw new Error("serverConfig with at least one field is required for updateConfig");
+                }
+                let remoteServerConfig = {};
+                try {
+                    const details = await cloudrunService.detail({
+                        serverName: input.serverName,
+                    });
+                    remoteServerConfig = (details.ServerConfig ||
+                        {});
+                }
+                catch (error) {
+                    throw new Error(buildManageCloudRunErrorMessage("updateConfig", input.serverName, error));
+                }
+                // EnvParams on Diff replaces the whole blob — merge keys unless replaceAll.
+                const dirty = { ...input.serverConfig };
+                if (Object.prototype.hasOwnProperty.call(input.serverConfig, "EnvParams")) {
+                    const { merged } = (0, cloudrun_config_js_1.mergeCloudRunServerConfig)({
+                        remote: { EnvParams: remoteServerConfig.EnvParams },
+                        input: { EnvParams: input.serverConfig.EnvParams },
+                        envParamsReplaceAll: Boolean(input.envParamsReplaceAll),
+                    });
+                    if (merged.EnvParams !== undefined) {
+                        dirty.EnvParams = merged.EnvParams;
+                    }
+                }
+                let Items;
+                try {
+                    Items = (0, cloudrun_config_js_1.parseServerConfigToDiffItems)(dirty);
+                }
+                catch (error) {
+                    throw new Error(buildManageCloudRunErrorMessage("updateConfig", input.serverName, error));
+                }
+                if (Items.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    data: {
+                                        serviceName: input.serverName,
+                                        status: "noop",
+                                        itemsCount: 0,
+                                        appliedConfig: (0, cloudrun_config_js_1.summarizeConfigSnapshot)(dirty),
+                                        verifiedConfig: (0, cloudrun_config_js_1.summarizeConfigSnapshot)(remoteServerConfig),
+                                    },
+                                    message: `No effective config changes for '${input.serverName}'.`,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                if (!manager.commonService) {
+                    throw new Error("Current CloudBase Manager does not support commonService; cannot call SubmitServerConfigChangeDiff.");
+                }
+                let diffResult;
+                try {
+                    diffResult = await manager
+                        .commonService("tcbr", "2022-02-17")
+                        .call({
+                        Action: "SubmitServerConfigChangeDiff",
+                        Param: {
+                            EnvId: currentEnvId,
+                            ServerName: input.serverName,
+                            Items,
+                        },
+                    });
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    if (/ResourceInUse|task|running|进行中/i.test(msg)) {
+                        throw new Error(buildManageCloudRunErrorMessage("updateConfig", input.serverName, new Error(`${msg} A deploy or config task may still be running. Wait, then retry; or use queryCloudRun(action="getDeployLog").`)));
+                    }
+                    throw new Error(buildManageCloudRunErrorMessage("updateConfig", input.serverName, error));
+                }
+                let verifiedConfig = (0, cloudrun_config_js_1.summarizeConfigSnapshot)(remoteServerConfig);
+                try {
+                    const after = await cloudrunService.detail({
+                        serverName: input.serverName,
+                    });
+                    verifiedConfig = (0, cloudrun_config_js_1.summarizeConfigSnapshot)(after?.ServerConfig);
+                }
+                catch {
+                    // best-effort verify
+                }
+                const likelyRedeploy = (0, cloudrun_config_js_1.listLikelyRedeployFields)(dirty);
+                const consoleUrl = `https://tcb.cloud.tencent.com/dev?envId=${currentEnvId}#/platform-run/service/detail?serverName=${input.serverName}&tabId=overview&envId=${currentEnvId}`;
+                const taskId = diffResult?.TaskId ??
+                    diffResult?.Response?.TaskId ??
+                    diffResult?.taskId;
+                const redeployHint = likelyRedeploy.length > 0
+                    ? ` Fields that often trigger redeploy-with-online-image: ${likelyRedeploy.join(", ")}.`
+                    : " Change may apply as a hot update (e.g. MinNum/MaxNum/AccessTypes).";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: "configUpdating",
+                                    itemsCount: Items.length,
+                                    itemsKeys: Items.map((i) => i.Key),
+                                    ...(taskId ? { taskId } : {}),
+                                    appliedConfig: (0, cloudrun_config_js_1.summarizeConfigSnapshot)(dirty),
+                                    verifiedConfig,
+                                    likelyRedeployFields: likelyRedeploy,
+                                    consoleUrl,
+                                },
+                                message: `Submitted config change for '${input.serverName}'.${redeployHint} Verify with queryCloudRun(action="detail"). Console: ${consoleUrl}`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             case 'run': {
                 if (!targetPath) {
                     throw new Error("targetPath is required for run operation");
@@ -10015,7 +10356,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.25.0" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.25.2" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -10359,6 +10700,7 @@ exports.registerFunctionTools = registerFunctionTools;
 const zod_1 = __webpack_require__(2971);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
 const cloud_mode_js_1 = __webpack_require__(9684);
+const gateway_access_urls_js_1 = __webpack_require__(2435);
 const json_content_js_1 = __webpack_require__(4365);
 const logger_js_1 = __webpack_require__(3039);
 const fs_1 = __webpack_require__(4421);
@@ -11111,7 +11453,7 @@ function registerFunctionTools(server) {
                         raw: imageResult,
                     }, `已基于镜像 ${createImageConfig.imageUri} 创建 HTTP 函数 ${functionName}。` +
                         `请确认 TCR、SCF 与构建管道处于同一地域；如需通过 URL 访问，请显式调用 ` +
-                        `manageGateway(action="createRoute", type="HTTP") 并按需调整函数安全规则。` +
+                        `manageGateway(action="createRoute", upstreamResourceType="WEB_SCF") 并按需调整函数安全规则。` +
                         `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪。`, [
                         {
                             tool: "queryFunctions",
@@ -11182,7 +11524,7 @@ function registerFunctionTools(server) {
                     nextActions.push({
                         tool: "manageGateway",
                         action: "createRoute",
-                        reason: "如果需要通过 URL 访问 HTTP 函数，请调用 manageGateway(action=\"createRoute\") 并显式传 type=\"HTTP\"（映射 WEB_SCF），再按实际路径和鉴权需求创建访问入口，不要默认假设 /函数名 已存在",
+                        reason: "如果需要通过 URL 访问 HTTP 函数，请调用 manageGateway(action=\"createRoute\") 并显式传 upstreamResourceType=\"WEB_SCF\"，再按实际路径和鉴权需求创建访问入口，不要默认假设 /函数名 已存在",
                     });
                     nextActions.push({
                         tool: "queryGateway",
@@ -11201,11 +11543,35 @@ function registerFunctionTools(server) {
                     });
                 }
                 const message = func.type === "HTTP"
-                    ? `已创建 HTTP 函数 ${functionName}。如果后续需要通过 URL 访问，请显式调用 manageGateway(action="createRoute")，并把 type="HTTP" 一起传入（映射 UpstreamResourceType=WEB_SCF），再按实际路径和鉴权需求创建访问入口。评测或其他外部调用方可能会以匿名身份访问，而且失败后不一定会把 EXCEED_AUTHORITY 再反馈给 AI；交付前请主动确认访问路径和函数安全规则，若已出现 EXCEED_AUTHORITY，请先调用 queryPermissions(action="getResourcePermission", resourceType="function", resourceId="${functionName}") 查看当前规则，再按需要使用 managePermissions(action="updateResourcePermission") 调整权限。`
+                    ? `已创建 HTTP 函数 ${functionName}。如果后续需要通过 URL 访问，请显式调用 manageGateway(action="createRoute")，并把 upstreamResourceType="WEB_SCF" 一起传入，再按实际路径和鉴权需求创建访问入口。评测或其他外部调用方可能会以匿名身份访问，而且失败后不一定会把 EXCEED_AUTHORITY 再反馈给 AI；交付前请主动确认访问路径和函数安全规则，若已出现 EXCEED_AUTHORITY，请先调用 queryPermissions(action="getResourcePermission", resourceType="function", resourceId="${functionName}") 查看当前规则，再按需要使用 managePermissions(action="updateResourcePermission") 调整权限。`
                     : `已创建函数 ${functionName}`;
+                let accessUrl;
+                let accessUrls = [];
+                let accessUrlSource;
+                if (func.type === "HTTP") {
+                    const envId = cloudBaseOptions?.envId ?? await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                    const gateway = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                        envId,
+                        upstreamResourceName: functionName,
+                        upstreamResourceTypes: ["WEB_SCF", "SCF"],
+                        getManager: async () => {
+                            const manager = await getManager();
+                            if (!manager) {
+                                throw new Error("cloudbase manager unavailable");
+                            }
+                            return manager;
+                        },
+                    });
+                    accessUrl = gateway.accessUrl;
+                    accessUrls = gateway.accessUrls;
+                    accessUrlSource = gateway.accessUrlSource;
+                }
                 return buildEnvelope({
                     action: input.action,
                     functionName,
+                    ...(accessUrl ? { accessUrl } : {}),
+                    ...(accessUrls.length > 0 ? { accessUrls } : {}),
+                    ...(accessUrlSource ? { accessUrlSource } : {}),
                     raw: result,
                 }, message, nextActions);
             }
@@ -11244,11 +11610,33 @@ function registerFunctionTools(server) {
                         throw wrapFunctionOperationError("updateFunctionCode", input.functionName, undefined, error);
                     }
                     (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, imageResult);
+                    const envId = cloudBaseOptions?.envId ?? await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                    const imageGatewayAccess = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                        envId,
+                        upstreamResourceName: input.functionName,
+                        upstreamResourceTypes: ["WEB_SCF", "SCF"],
+                        getManager: async () => {
+                            const manager = await getManager();
+                            if (!manager) {
+                                throw new Error("cloudbase manager unavailable");
+                            }
+                            return manager;
+                        },
+                    });
                     return buildEnvelope({
                         action: input.action,
                         functionName: input.functionName,
                         deployMode: "image",
                         imageUri: updateImageConfig.imageUri,
+                        ...(imageGatewayAccess.accessUrl
+                            ? { accessUrl: imageGatewayAccess.accessUrl }
+                            : {}),
+                        ...(imageGatewayAccess.accessUrls.length > 0
+                            ? { accessUrls: imageGatewayAccess.accessUrls }
+                            : {}),
+                        ...(imageGatewayAccess.accessUrlSource
+                            ? { accessUrlSource: imageGatewayAccess.accessUrlSource }
+                            : {}),
                         raw: imageResult,
                     }, `已将函数 ${input.functionName} 的镜像更新为 ${updateImageConfig.imageUri}。` +
                         `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪（Active）。`, [
@@ -11279,9 +11667,29 @@ function registerFunctionTools(server) {
                     throw wrapFunctionOperationError("updateFunctionCode", input.functionName, processedRootPath, error);
                 }
                 (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                const envId = cloudBaseOptions?.envId ?? await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const gatewayAccess = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                    envId,
+                    upstreamResourceName: input.functionName,
+                    upstreamResourceTypes: ["WEB_SCF", "SCF"],
+                    getManager: async () => {
+                        const manager = await getManager();
+                        if (!manager) {
+                            throw new Error("cloudbase manager unavailable");
+                        }
+                        return manager;
+                    },
+                });
                 return buildEnvelope({
                     action: input.action,
                     functionName: input.functionName,
+                    ...(gatewayAccess.accessUrl ? { accessUrl: gatewayAccess.accessUrl } : {}),
+                    ...(gatewayAccess.accessUrls.length > 0
+                        ? { accessUrls: gatewayAccess.accessUrls }
+                        : {}),
+                    ...(gatewayAccess.accessUrlSource
+                        ? { accessUrlSource: gatewayAccess.accessUrlSource }
+                        : {}),
                     raw: result,
                 }, `已更新函数 ${input.functionName} 的代码`, [
                     {
@@ -14327,7 +14735,7 @@ function registerSetupTools(server) {
     server.registerTool("downloadTemplate", {
         title: "下载项目模板",
         description: `自动下载并部署CloudBase项目模板。
-**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、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline 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- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\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编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.25.0" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+**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、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline 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- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\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编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.25.2" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
@@ -14523,6 +14931,7 @@ const zod_1 = __webpack_require__(2971);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
 const json_content_js_1 = __webpack_require__(4365);
 const cloud_mode_js_1 = __webpack_require__(9684);
+const gateway_access_urls_js_1 = __webpack_require__(2435);
 const QUERY_APP_ACTIONS = ["listApps", "getApp", "listAppVersions", "getAppVersion", "getBuildLog"];
 const MANAGE_APP_ACTIONS = ["deployApp", "getUploadUrl", "deleteApp", "deleteAppVersion"];
 const APP_FRAMEWORKS = ["vue", "react", "next", "nuxt", "vite", "angular", "static"];
@@ -14899,6 +15308,8 @@ function registerAppTools(server) {
                 let appInfo;
                 let domain;
                 let accessUrl;
+                let accessUrls = [];
+                let accessUrlSource;
                 let accessUrlLookupWarning;
                 try {
                     appInfo = await appService.describeAppInfo({
@@ -14907,9 +15318,34 @@ function registerAppTools(server) {
                     });
                     (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, appInfo);
                     ({ domain, accessUrl } = normalizeAccessUrlFromDomain(appInfo?.Domain));
+                    const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                    const gateway = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                        envId,
+                        upstreamResourceName: serviceName,
+                        upstreamResourceTypes: ["STATIC_STORE"],
+                        getManager: async () => {
+                            const manager = await getManager();
+                            if (!manager) {
+                                throw new Error("cloudbase manager unavailable");
+                            }
+                            return manager;
+                        },
+                    });
+                    const preferred = (0, gateway_access_urls_js_1.preferGatewayOrFallback)({
+                        gateway,
+                        fallbackUrl: accessUrl,
+                        fallbackSource: "describeAppInfo.Domain",
+                    });
+                    accessUrl = preferred.accessUrl;
+                    accessUrls = preferred.accessUrls;
+                    accessUrlSource = preferred.accessUrlSource;
                 }
                 catch (error) {
                     accessUrlLookupWarning = error instanceof Error ? error.message : String(error);
+                    if (accessUrl) {
+                        accessUrls = [accessUrl];
+                        accessUrlSource = "describeAppInfo.Domain";
+                    }
                 }
                 return (0, json_content_js_1.jsonContent)(buildEnvelope({
                     action,
@@ -14918,7 +15354,8 @@ function registerAppTools(server) {
                     buildId: BuildId,
                     domain,
                     accessUrl,
-                    accessUrlSource: accessUrl ? "describeAppInfo.Domain" : undefined,
+                    accessUrls: accessUrls.length > 0 ? accessUrls : undefined,
+                    accessUrlSource,
                     accessUrlLookupWarning,
                     app: appInfo,
                     upload: { cosTimestamp: cosTs },
@@ -15475,6 +15912,7 @@ const path_1 = __importDefault(__webpack_require__(2521));
 const zod_1 = __webpack_require__(2971);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
 const cloud_mode_js_1 = __webpack_require__(9684);
+const gateway_access_urls_js_1 = __webpack_require__(2435);
 const notification_js_1 = __webpack_require__(2720);
 const tool_result_js_1 = __webpack_require__(9835);
 const HOSTING_CDN_SWITCH_VALUES = ['on', 'off'];
@@ -16010,9 +16448,48 @@ function registerHostingTools(server) {
                     // StaticDomain there but not in DescribeStaticStore.
                     const cdnFromStore = (store.CdnDomain ?? store.StaticDomain);
                     const staticDomain = cdnFromStore || await resolveHostingStaticDomain(cloudbase, server.logger);
-                    const accessUrl = buildHostingAccessUrl(staticDomain, input.cloudPath, input.localPath);
+                    const fallbackAccessUrl = buildHostingAccessUrl(staticDomain, input.cloudPath, input.localPath);
+                    const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                    const gatewayCandidates = Array.from(new Set([
+                        store.StaticStoreName,
+                        store.Name,
+                        store.StoreName,
+                        store.Bucket,
+                        "staticstore",
+                    ]
+                        .map((item) => (typeof item === "string" ? item.trim() : ""))
+                        .filter(Boolean)));
+                    let accessUrl = fallbackAccessUrl;
+                    let accessUrls = accessUrl ? [accessUrl] : [];
+                    let accessUrlSource = accessUrl
+                        ? "hosting.staticDomain"
+                        : undefined;
+                    for (const upstreamName of gatewayCandidates) {
+                        const gateway = await (0, gateway_access_urls_js_1.resolveGatewayAccessUrls)({
+                            envId,
+                            upstreamResourceName: upstreamName,
+                            upstreamResourceTypes: ["STATIC_STORE"],
+                            getManager: async () => {
+                                const manager = await getManager();
+                                if (!manager) {
+                                    throw new Error("cloudbase manager unavailable");
+                                }
+                                return manager;
+                            },
+                        });
+                        const preferred = (0, gateway_access_urls_js_1.preferGatewayOrFallback)({
+                            gateway,
+                            fallbackUrl: fallbackAccessUrl || undefined,
+                            fallbackSource: "hosting.staticDomain",
+                        });
+                        if (preferred.accessUrl) {
+                            accessUrl = preferred.accessUrl;
+                            accessUrls = preferred.accessUrls;
+                            accessUrlSource = preferred.accessUrlSource;
+                            break;
+                        }
+                    }
                     try {
-                        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
                         let projectName = 'unknown';
                         if (input.localPath) {
                             try {
@@ -16047,6 +16524,8 @@ function registerHostingTools(server) {
                             ignore: input.ignore,
                             staticDomain,
                             accessUrl,
+                            accessUrls,
+                            accessUrlSource,
                             result,
                             nextActions: uploadPrefix ? [buildFindFilesNextStep(uploadPrefix.replace(/^\/+/, ''))] : undefined,
                         },
@@ -16646,6 +17125,219 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_fs_promises_f8dae9d1__;
 
 module.exports = __WEBPACK_EXTERNAL_MODULE_os__;
 
+/***/ }),
+
+/***/ 8266:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/**
+ * CloudRun serverConfig merge (RMW) and DiffConfigItem helpers.
+ * Aligns with console SubmitServerConfigChangeDiff field mapping.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CONFIG_FIELDS_LIKELY_REDEPLOY = void 0;
+exports.mergeCloudRunServerConfig = mergeCloudRunServerConfig;
+exports.assertCpuMemPair = assertCpuMemPair;
+exports.parseServerConfigToDiffItems = parseServerConfigToDiffItems;
+exports.summarizeConfigSnapshot = summarizeConfigSnapshot;
+exports.listLikelyRedeployFields = listLikelyRedeployFields;
+const SUBMIT_DIFF_MAP = {
+    Cpu: "CpuSpecs",
+    Mem: "MemSpecs",
+    OpenAccessTypes: "AccessTypes",
+    EnvParams: "EnvParam",
+    CustomLogs: "LogPath",
+};
+const STRING_KEYS = new Set([
+    "CustomLogs",
+    "EnvParams",
+    "CreateTime",
+    "Dockerfile",
+    "BuildDir",
+    "LogType",
+    "LogSetId",
+    "LogTopicId",
+    "LogParseType",
+    "Tag",
+    "InternalAccess",
+    "InternalDomain",
+    "OperationMode",
+    "SessionAffinity",
+]);
+const INT_KEYS = new Set(["MinNum", "MaxNum", "InitialDelaySeconds", "Port"]);
+const BOOL_KEYS = new Set(["HasDockerfile"]);
+const FLOAT_KEYS = new Set(["Cpu", "Mem"]);
+const ARRAY_KEYS = new Set(["OpenAccessTypes", "EntryPoint", "Cmd"]);
+function parseEnvParamsObject(raw) {
+    if (!raw || !String(raw).trim()) {
+        return {};
+    }
+    try {
+        const value = JSON.parse(String(raw));
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return {};
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (v === undefined || v === null)
+                continue;
+            out[k] = typeof v === "string" ? v : String(v);
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function stringifyEnvParams(obj) {
+    return JSON.stringify(obj);
+}
+function isCompleteVpcConf(vpc) {
+    return Boolean(vpc?.VpcId?.trim() && vpc?.SubnetId?.trim());
+}
+/**
+ * Merge remote ServerConfig with deploy/update input.
+ * Explicit input wins for provided fields; EnvParams merges by key unless replaceAll.
+ */
+function mergeCloudRunServerConfig(options) {
+    const remote = options.remote || {};
+    const input = options.input || {};
+    const mergedFromRemote = [];
+    const merged = { ...input };
+    if (isCompleteVpcConf(input.VpcConf)) {
+        merged.VpcConf = {
+            VpcId: input.VpcConf.VpcId.trim(),
+            SubnetId: input.VpcConf.SubnetId.trim(),
+            ...(input.VpcConf.VpcCIDR ? { VpcCIDR: input.VpcConf.VpcCIDR } : {}),
+            ...(input.VpcConf.SubnetCIDR ? { SubnetCIDR: input.VpcConf.SubnetCIDR } : {}),
+        };
+    }
+    else if (isCompleteVpcConf(remote.VpcConf)) {
+        merged.VpcConf = {
+            VpcId: remote.VpcConf.VpcId.trim(),
+            SubnetId: remote.VpcConf.SubnetId.trim(),
+            ...(remote.VpcConf.VpcCIDR ? { VpcCIDR: remote.VpcConf.VpcCIDR } : {}),
+            ...(remote.VpcConf.SubnetCIDR ? { SubnetCIDR: remote.VpcConf.SubnetCIDR } : {}),
+        };
+        mergedFromRemote.push("VpcConf");
+    }
+    else {
+        delete merged.VpcConf;
+    }
+    const inputHasEnv = Object.prototype.hasOwnProperty.call(input, "EnvParams");
+    const remoteEnv = parseEnvParamsObject(remote.EnvParams);
+    const inputEnv = parseEnvParamsObject(input.EnvParams);
+    if (options.envParamsReplaceAll && inputHasEnv) {
+        merged.EnvParams = stringifyEnvParams(inputEnv);
+    }
+    else if (inputHasEnv || Object.keys(remoteEnv).length > 0) {
+        const combined = options.envParamsReplaceAll
+            ? { ...inputEnv }
+            : { ...remoteEnv, ...inputEnv };
+        if (Object.keys(remoteEnv).length > 0 && !options.envParamsReplaceAll) {
+            const preserved = Object.keys(remoteEnv).filter((k) => !(k in inputEnv));
+            if (preserved.length > 0) {
+                mergedFromRemote.push("EnvParams");
+            }
+        }
+        if (Object.keys(combined).length > 0 || inputHasEnv) {
+            merged.EnvParams = stringifyEnvParams(combined);
+        }
+    }
+    // Must be explicit so Manager SDK update path cannot wipe with OA/PUBLIC/MINIAPP defaults.
+    if (Array.isArray(input.OpenAccessTypes) && input.OpenAccessTypes.length > 0) {
+        merged.OpenAccessTypes = [...input.OpenAccessTypes];
+    }
+    else if (Array.isArray(remote.OpenAccessTypes) && remote.OpenAccessTypes.length > 0) {
+        merged.OpenAccessTypes = [...remote.OpenAccessTypes];
+        mergedFromRemote.push("OpenAccessTypes");
+    }
+    return { merged, mergedFromRemote };
+}
+function assertCpuMemPair(config) {
+    const hasCpu = config.Cpu !== undefined && config.Cpu !== null;
+    const hasMem = config.Mem !== undefined && config.Mem !== null;
+    if (hasCpu !== hasMem) {
+        throw new Error("Cpu and Mem must be provided together when updating CloudRun config (platform requires the pair).");
+    }
+}
+/**
+ * Convert serverConfig object to DiffConfigItem[] for SubmitServerConfigChangeDiff.
+ */
+function parseServerConfigToDiffItems(data) {
+    assertCpuMemPair(data);
+    const Items = [];
+    for (const [k, v] of Object.entries(data)) {
+        if (v === undefined || v === null)
+            continue;
+        const Key = SUBMIT_DIFF_MAP[k] || k;
+        if (STRING_KEYS.has(k)) {
+            if (v !== "") {
+                Items.push({ Key, Value: String(v) });
+            }
+        }
+        else if (INT_KEYS.has(k)) {
+            Items.push({ Key, IntValue: Number(v) });
+        }
+        else if (BOOL_KEYS.has(k)) {
+            Items.push({ Key, BoolValue: Boolean(v) });
+        }
+        else if (FLOAT_KEYS.has(k)) {
+            Items.push({ Key, FloatValue: Number(v) });
+        }
+        else if (ARRAY_KEYS.has(k)) {
+            Items.push({ Key, ArrayValue: v });
+        }
+        else if (k === "PolicyDetails") {
+            Items.push({ Key, PolicyDetails: v });
+        }
+        else if (k === "TimerScale") {
+            Items.push({ Key, TimerScale: v });
+        }
+        else if (k === "VpcConf") {
+            Items.push({ Key, VpcConf: v });
+        }
+        else if (k === "VolumesConf") {
+            Items.push({ Key, VolumesConf: v });
+        }
+        else if (k === "PublicNetConf") {
+            Items.push({ Key, PublicNetConf: v });
+        }
+    }
+    return Items;
+}
+function summarizeConfigSnapshot(config) {
+    const vpc = config?.VpcConf;
+    const envKeys = Object.keys(parseEnvParamsObject(config?.EnvParams));
+    return {
+        hasVpcConf: isCompleteVpcConf(vpc),
+        ...(vpc?.VpcId ? { vpcId: vpc.VpcId } : {}),
+        ...(vpc?.SubnetId ? { subnetId: vpc.SubnetId } : {}),
+        ...(Array.isArray(config?.OpenAccessTypes)
+            ? { openAccessTypes: config.OpenAccessTypes }
+            : {}),
+        envParamKeys: envKeys,
+    };
+}
+exports.CONFIG_FIELDS_LIKELY_REDEPLOY = [
+    "VpcConf",
+    "EnvParams",
+    "Cpu",
+    "Mem",
+    "Port",
+    "Dockerfile",
+    "BuildDir",
+    "VolumesConf",
+    "LogType",
+    "LogSetId",
+    "LogTopicId",
+];
+function listLikelyRedeployFields(config) {
+    return exports.CONFIG_FIELDS_LIKELY_REDEPLOY.filter((k) => Object.prototype.hasOwnProperty.call(config, k));
+}
+
+
 /***/ }),
 
 /***/ 9097: