@cloudbase/cloudbase-mcp 2.25.1 → 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.1" || 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.1" : 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}`;
             // 创建新的错误对象，保持原有的错误类型但更新消息
@@ -2908,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:
@@ -7148,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",
@@ -7223,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 ?? [];
@@ -7336,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 路由`);
@@ -7377,6 +7550,7 @@ function registerGatewayTools(server) {
                     routes: matches,
                     total: matches.length,
                     urls,
+                    ...buildAccessUrlFields(matches),
                     raw: result,
                 }, matches.length === 0
                     ? "未找到对应路由"
@@ -7430,6 +7604,11 @@ function registerGatewayTools(server) {
                     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}）` +
                     (payload.resolved.enablePathTransmission === true
@@ -7456,6 +7635,11 @@ function registerGatewayTools(server) {
                     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}` +
                     (payload.resolved.enablePathTransmission === true
@@ -8218,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
@@ -8237,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）。影响服务性能和计费'),
@@ -8279,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表示云文件存储'),
@@ -8289,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)
@@ -8473,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
  */
@@ -8706,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,
@@ -8897,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;
                 }
@@ -8905,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
@@ -8938,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(),
@@ -8982,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
@@ -9033,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
@@ -9053,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}`
@@ -9061,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");
@@ -9984,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.1" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.25.2" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -10328,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);
@@ -11172,9 +11545,33 @@ function registerFunctionTools(server) {
                 const message = func.type === "HTTP"
                     ? `已创建 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);
             }
@@ -11213,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）。`, [
@@ -11248,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} 的代码`, [
                     {
@@ -14296,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.1" : 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"])
@@ -14492,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"];
@@ -14868,6 +15308,8 @@ function registerAppTools(server) {
                 let appInfo;
                 let domain;
                 let accessUrl;
+                let accessUrls = [];
+                let accessUrlSource;
                 let accessUrlLookupWarning;
                 try {
                     appInfo = await appService.describeAppInfo({
@@ -14876,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,
@@ -14887,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 },
@@ -15444,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'];
@@ -15979,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 {
@@ -16016,6 +16524,8 @@ function registerHostingTools(server) {
                             ignore: input.ignore,
                             staticDomain,
                             accessUrl,
+                            accessUrls,
+                            accessUrlSource,
                             result,
                             nextActions: uploadPrefix ? [buildFindFilesNextStep(uploadPrefix.replace(/^\/+/, ''))] : undefined,
                         },
@@ -16615,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: