cloudflare-mcp-smart-proxy 1.5.18 → 1.5.20

package/connector-cli.js

@@ -38,6 +38,8 @@ function printUsage() {
   console.error('  --codex-device-identity-path <path> Shared CloudMCP device identity');
   console.error('  --app-server-socket <path> Current runtime Codex app-server socket');
   console.error('  --runtime-id <id>          Current Codex runtime identity');
+  console.error('  --probe-timeout-ms <ms>    Fresh MCP catalog probe timeout (30000-300000; default 120000)');
+  console.error('                              Env: CLOUDMCP_CONNECTOR_PROBE_TIMEOUT_MS');
   console.error('  --dry-run                  Show output without writing');
   console.error('  --show-secrets             Explicitly include credentials in print output');
   console.error('  --approval-code <code>     One-time code shown by the CloudMCP administrator');
@@ -85,6 +87,27 @@ function resolveRequiredOption(options, flagName, envNames = []) {
   throw new Error(`Missing required option --${flagName}`);
 }
 
+function resolveConnectorProbeTimeoutMs(options = {}, env = process.env) {
+  const raw = options['probe-timeout-ms'] || env.CLOUDMCP_CONNECTOR_PROBE_TIMEOUT_MS || '120000';
+  const timeoutMs = Number(raw);
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 30_000 || timeoutMs > 300_000) {
+    throw new Error('probe-timeout-ms must be an integer between 30000 and 300000');
+  }
+  return timeoutMs;
+}
+
+async function runCodexReload(options, serverName, {
+  reload = reloadCodexMcpServer,
+  env = process.env
+} = {}) {
+  return reload({
+    serverName,
+    socketPath: options['app-server-socket'] || env.CODEX_APP_SERVER_SOCKET || '',
+    runtimeId: options['runtime-id'] || env.CODEX_RUNTIME_ID || '',
+    timeoutMs: resolveConnectorProbeTimeoutMs(options, env)
+  });
+}
+
 function buildInstallOptions(options) {
   const workspaceRoot = path.resolve(options['workspace-root'] || process.cwd());
   return {
@@ -181,11 +204,7 @@ async function runActivation(options) {
       dryRun: options.dryRun === true
     });
     if (options.ecosystem === 'codex' && !options.dryRun) {
-      result.activation = await reloadCodexMcpServer({
-        serverName: result.serverName,
-        socketPath: options['app-server-socket'] || process.env.CODEX_APP_SERVER_SOCKET || '',
-        runtimeId: options['runtime-id'] || process.env.CODEX_RUNTIME_ID || ''
-      });
+      result.activation = await runCodexReload(options, result.serverName);
     }
     if (!options.dryRun) fs.chmodSync(paths.credentialPath, 0o600);
     if (!options.dryRun && pending) {
@@ -300,6 +319,9 @@ function printInstallResult(result, { includeContent = false, includeSecrets = f
   }
   if (result.activation) {
     console.error(`activation: ${result.activation.status}`);
+    if (result.activation.reason) {
+      console.error(`activation reason: ${result.activation.reason}`);
+    }
     if (Number.isInteger(result.activation.toolCount)) {
       console.error(`tools: ${result.activation.toolCount}`);
     }
@@ -354,11 +376,7 @@ async function main() {
     if (options.command === 'install') {
       const result = installReferenceConnector(buildInstallOptions(options));
       if (options.ecosystem === 'codex' && !options.dryRun) {
-        result.activation = await reloadCodexMcpServer({
-          serverName: result.serverName,
-          socketPath: options['app-server-socket'] || process.env.CODEX_APP_SERVER_SOCKET || '',
-          runtimeId: options['runtime-id'] || process.env.CODEX_RUNTIME_ID || ''
-        });
+        result.activation = await runCodexReload(options, result.serverName);
       }
       printInstallResult(result);
       return;
@@ -368,11 +386,7 @@ async function main() {
       if (options.ecosystem !== 'codex') {
         throw new Error('Runtime reload is currently supported only for Codex');
       }
-      const activation = await reloadCodexMcpServer({
-        serverName: options['server-name'] || 'cloudmcp',
-        socketPath: options['app-server-socket'] || process.env.CODEX_APP_SERVER_SOCKET || '',
-        runtimeId: options['runtime-id'] || process.env.CODEX_RUNTIME_ID || ''
-      });
+      const activation = await runCodexReload(options, options['server-name'] || 'cloudmcp');
       printInstallResult({
         ecosystem: 'codex',
         scope: 'user',
@@ -410,4 +424,10 @@ if (isMainEntrypoint()) {
   main();
 }
 
-export { isMainEntrypoint, parseArgs, shouldInstallExistingCredential };
+export {
+  isMainEntrypoint,
+  parseArgs,
+  resolveConnectorProbeTimeoutMs,
+  runCodexReload,
+  shouldInstallExistingCredential
+};

package/index.js

@@ -148,7 +148,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 });
 
 // 工具调用处理器
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
   const { name, arguments: args } = request.params;
 
   if (!name) {
@@ -165,7 +165,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
   try {
     await refreshProjectScope();
-    const result = await router.executeTool(name, args || {});
+    const result = await router.executeTool(name, args || {}, { signal: extra.signal });
     
     // 格式化响应
     if (typeof result === 'string') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.5.18",
+  "version": "1.5.20",
   "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
   "repository": {
     "type": "git",

package/src/codex-app-server.js

@@ -276,18 +276,25 @@ export function resolveCodexAppServerSocket({
   homeDir = os.homedir(),
   codexHome = '',
   socketPath = '',
-  runtimeDir = process.env.XDG_RUNTIME_DIR || '',
-  pathExists = fs.existsSync
+  runtimeDir = process.env.XDG_RUNTIME_DIR || ''
 } = {}) {
   const explicitSocketPath = socketPath || process.env.CODEX_APP_SERVER_SOCKET || '';
   if (explicitSocketPath) return path.resolve(explicitSocketPath);
   if (runtimeDir) return path.join(path.resolve(runtimeDir), 'codex', 'app-server.sock');
   const resolvedCodexHome = codexHome || process.env.CODEX_HOME || path.join(homeDir, '.codex');
-  const ipcSocketPath = path.join(path.resolve(resolvedCodexHome), 'ipc', 'ipc.sock');
-  if (pathExists(ipcSocketPath)) return ipcSocketPath;
   return path.join(resolvedCodexHome, 'app-server-control', 'app-server-control.sock');
 }
 
+function assertCodexAppServerSocket({ socketPath, homeDir, codexHome }) {
+  const resolvedCodexHome = codexHome || process.env.CODEX_HOME || path.join(homeDir, '.codex');
+  const chatGptIpcSocket = path.join(path.resolve(resolvedCodexHome), 'ipc', 'ipc.sock');
+  if (path.resolve(socketPath) === chatGptIpcSocket) {
+    throw new Error(
+      `Refusing ChatGPT IPC socket as a Codex app-server endpoint: socket=${socketPath}`
+    );
+  }
+}
+
 function assertIsolatedSocketPath({ socketPath, homeDir, codexHome, isolationMode }) {
   if (!isolationMode) return;
   const resolvedCodexHome = codexHome || process.env.CODEX_HOME || path.join(homeDir, '.codex');
@@ -454,6 +461,11 @@ export async function reloadCodexMcpServer({
     socketPath,
     runtimeDir
   });
+  assertCodexAppServerSocket({
+    socketPath: resolvedSocketPath,
+    homeDir,
+    codexHome
+  });
   assertIsolatedSocketPath({
     socketPath: resolvedSocketPath,
     homeDir,
@@ -461,11 +473,26 @@ export async function reloadCodexMcpServer({
     isolationMode
   });
   if (!rpcClient && !fs.existsSync(resolvedSocketPath)) {
+    const resolvedConfigPath = configPath
+      || path.join(path.resolve(codexHome || path.join(homeDir, '.codex')), 'config.toml');
+    const probeResult = toolProbe
+      ? await toolProbe({ serverName, configPath: resolvedConfigPath, timeoutMs })
+      : (fs.existsSync(resolvedConfigPath)
+        ? await probeCodexMcpServer({
+            configPath: resolvedConfigPath,
+            serverName,
+            timeoutMs
+          })
+        : null);
     return {
       status: 'next_start',
+      reason: 'app_server_control_unavailable',
       serverName,
       socketPath: resolvedSocketPath,
-      toolCount: null
+      toolCount: Number.isInteger(probeResult?.toolCount) ? probeResult.toolCount : null,
+      workspaceId: probeResult?.workspaceId || null,
+      workspaceRoot: probeResult?.workspaceRoot || null,
+      workspaceResolution: probeResult?.workspaceResolution || null
     };
   }
 

package/src/router.js

@@ -139,7 +139,7 @@ export class SmartRouter {
   /**
    * 执行工具调用
    */
-  async executeTool(toolName, params) {
+  async executeTool(toolName, params, { signal = null } = {}) {
     const route = this.routeTool(toolName);
 
     if (route === 'local') {
@@ -151,7 +151,7 @@ export class SmartRouter {
             projectIdentity: this.localTools?.connectorBridge?.state?.projectIdentity
           }
         : params;
-      return await this.callCloudTool(toolName, recoveryParams);
+      return await this.callCloudTool(toolName, recoveryParams, { signal });
     }
   }
 
@@ -179,7 +179,7 @@ export class SmartRouter {
   /**
    * 调用云端工具
    */
-  async callCloudTool(toolName, params, { workspaceId = null } = {}) {
+  async callCloudTool(toolName, params, { workspaceId = null, signal = null } = {}) {
     // 对于 skill_* 工具，自动注入项目根路径信息
     if (toolName.startsWith('skill_')) {
       // 如果参数中没有 project_root 且没有 paths，自动添加 project_root
@@ -205,9 +205,10 @@ export class SmartRouter {
     }
     
     try {
+      const requestId = Date.now();
       const body = JSON.stringify({
         jsonrpc: '2.0',
-        id: Date.now(),
+        id: requestId,
         method: 'tools/call',
         params: {
           name: toolName,
@@ -222,11 +223,13 @@ export class SmartRouter {
         headers: {
           'Authorization': `Bearer ${this.cloudApiKey}`,
           'Content-Type': 'application/json',
+          'X-Request-ID': String(requestId),
           ...this.getScopeHeaders(),
           ...(workspaceId ? { 'X-CloudMCP-Workspace-ID': workspaceId } : {}),
           ...signedHeaders
         },
-        body
+        body,
+        signal
       });
 
       if (!response.ok) {