customer-map-codex-bridge 0.5.0 → 0.5.1

package/README.md

@@ -14,13 +14,15 @@ The settings panel reports **Connected** only after both the local Codex app-ser
 ## Run
 
 ```bash
-npx -y customer-map-codex-bridge@0.5.0 \
+npx -y customer-map-codex-bridge@0.5.1 \
   --site https://your-customer-map.example \
   --code CMAP-CODEX-XXXXXXXXXXXX
 ```
 
 Starting a newly authorized Bridge automatically replaces the older Bridge for the same Customer Map account. Clicking **Remove connection** in Customer Map disconnects the running Bridge, so users do not need to find or kill local processes.
 
+The Bridge automatically reconnects to the Relay after temporary network or Relay interruptions, using exponential backoff from 1 second up to 30 seconds. It keeps the local Codex process and bridge token in memory during retries. A removed connection, an expired token, or a Bridge replaced by a newer Bridge exits instead of retrying.
+
 The bridge initializes Codex App Server with native live web search enabled, then explicitly applies a read-only sandbox with no approval prompts and command network access disabled to every new thread and every turn. This lets the assistants search and read public pages without granting model-generated shell commands arbitrary network or file-write access. Credentials stay on the local machine, and thread IDs are stored under `~/.customer-map-codex/state.json` and resumed after Bridge restarts. Task Assistant, Workbench Assistant, and Sales Assistant use separate thread scopes.
 
 When the user explicitly chooses **Save Gmail draft** or **Send email** in Customer Map, the bridge bypasses the Codex turn and executes only a validated, fixed `gog gmail drafts create` or `gog gmail send` argument list. It verifies the content hash and requires a real Gmail message/draft ID before reporting success. Chat cannot turn this into an arbitrary shell or network action.
@@ -28,7 +30,7 @@ When the user explicitly chooses **Save Gmail draft** or **Send email** in Custo
 If the protocol handler cannot find `codex`, pass its absolute path explicitly:
 
 ```bash
-npx -y customer-map-codex-bridge@0.5.0 \
+npx -y customer-map-codex-bridge@0.5.1 \
   --site https://your-customer-map.example \
   --code CMAP-CODEX-XXXXXXXXXXXX \
   --codex /absolute/path/to/codex
@@ -37,7 +39,7 @@ npx -y customer-map-codex-bridge@0.5.0 \
 If `gog` is outside the standard Homebrew/system paths, pass it explicitly:
 
 ```bash
-npx -y customer-map-codex-bridge@0.5.0 \
+npx -y customer-map-codex-bridge@0.5.1 \
   --site https://your-customer-map.example \
   --code CMAP-CODEX-XXXXXXXXXXXX \
   --gog /absolute/path/to/gog

package/index.mjs

@@ -9,7 +9,9 @@ import process from 'node:process';
 import WebSocket from 'ws';
 import { executeCustomerMapMailAction } from './mail-action.mjs';
 
-const BRIDGE_VERSION = '0.5.0';
+const BRIDGE_VERSION = '0.5.1';
+const RELAY_RECONNECT_BASE_MS = 1_000;
+const RELAY_RECONNECT_MAX_MS = 30_000;
 
 const args = parseArgs(process.argv.slice(2));
 if (args.help) {
@@ -36,6 +38,8 @@ let initialized = false;
 let closed = false;
 let active = null;
 let shutdownPromise = null;
+let relayReconnectPromise = null;
+let pendingRelayDisconnect = null;
 const pendingRpc = new Map();
 const loadedThreads = new Set();
 
@@ -70,7 +74,7 @@ async function main() {
     const bridge = await claim();
     bridgeToken = bridge.bridgeToken;
     connectionId = bridge.connectionId;
-    relay = await connectRelay(bridge);
+    await connectRelayWithRetry(bridge);
     console.log('Customer Map Codex Bridge connected.');
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error || 'Codex Bridge failed'));
@@ -140,6 +144,23 @@ function handleCodexLine(line) {
   }
 }
 
+async function connectRelayWithRetry(bridge) {
+  let attempt = 0;
+  while (!closed) {
+    try {
+      await connectRelay(bridge);
+      return;
+    } catch (error) {
+      if (isPermanentRelayError(error)) throw error;
+      const delayMs = relayReconnectDelay(attempt);
+      attempt += 1;
+      console.warn(`Codex Relay unavailable; retrying in ${Math.ceil(delayMs / 1000)}s.`);
+      await wait(delayMs);
+    }
+  }
+  throw new Error('Codex Bridge stopped');
+}
+
 function connectRelay(bridge) {
   return new Promise((resolve, reject) => {
     const socket = new WebSocket(webSocketUrl(bridge.relayUrl));
@@ -150,7 +171,7 @@ function connectRelay(bridge) {
       if (settled) return;
       settled = true;
       socket.close();
-      reject(new Error('Codex Relay 握手超时，请检查 Relay 或 Tunnel 是否在线。'));
+      reject(createRelayError('Codex Relay 握手超时，请检查 Relay 或 Tunnel 是否在线。'));
     }, 20_000);
 
     socket.on('open', () => {
@@ -170,7 +191,7 @@ function connectRelay(bridge) {
           gmailDraft: 'declared',
           gmailSend: 'confirmation',
         },
-      });
+      }, socket);
     });
 
     socket.on('message', raw => {
@@ -178,6 +199,13 @@ function connectRelay(bridge) {
       try { message = JSON.parse(String(raw)); } catch { return; }
       if (message.type === 'ready') {
         if (ready) return;
+        if (relay !== socket) {
+          settled = true;
+          clearTimeout(timer);
+          socket.close();
+          reject(new Error('Codex Relay connection superseded'));
+          return;
+        }
         ready = true;
         settled = true;
         clearTimeout(timer);
@@ -188,9 +216,10 @@ function connectRelay(bridge) {
         settled = true;
         clearTimeout(timer);
         socket.close();
-        reject(new Error(String(message.error || 'Codex Relay rejected the Bridge')));
+        reject(createRelayError(String(message.error || 'Codex Relay rejected the Bridge'), message.code));
         return;
       }
+      if (relay !== socket) return;
       handleRelayMessage(message);
     });
 
@@ -198,7 +227,8 @@ function connectRelay(bridge) {
       if (!ready && !settled) {
         settled = true;
         clearTimeout(timer);
-        reject(new Error(`Codex Relay 连接失败：${error.message}`));
+        socket.close();
+        reject(createRelayError(`Codex Relay 连接失败：${error.message}`));
       } else {
         console.error(`Codex Relay error: ${error.message}`);
       }
@@ -206,17 +236,88 @@ function connectRelay(bridge) {
 
     socket.on('close', (codeValue, reasonValue) => {
       const reason = String(reasonValue || '').trim();
-      if (!ready && !settled) {
-        settled = true;
-        clearTimeout(timer);
-        reject(new Error(`Codex Relay 在握手前断开 (${codeValue ?? 'unknown'})${reason ? `: ${reason}` : ''}`));
+      const current = relay === socket;
+      if (current) relay = null;
+      if (!current) return;
+      if (!ready) {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          reject(createRelayError(`Codex Relay 在握手前断开 (${codeValue ?? 'unknown'})${reason ? `: ${reason}` : ''}`, codeValue));
+        }
         return;
       }
-      if (!closed) void shutdown(new Error(`Codex Relay 已断开 (${codeValue ?? 'unknown'})${reason ? `: ${reason}` : ''}`));
+      if (!closed) {
+        const error = createRelayError(`Codex Relay 已断开 (${codeValue ?? 'unknown'})${reason ? `: ${reason}` : ''}`, codeValue);
+        void handleRelayDisconnect(bridge, error);
+      }
     });
   });
 }
 
+async function handleRelayDisconnect(bridge, error) {
+  if (closed) return;
+  if (isPermanentRelayError(error)) {
+    await shutdown(error);
+    return;
+  }
+  if (active) {
+    active.abort?.();
+    failActiveJob(error instanceof Error ? error.message : String(error || 'Codex Relay disconnected'));
+  }
+  if (relayReconnectPromise) {
+    pendingRelayDisconnect = { bridge, error };
+    return;
+  }
+  const reconnectPromise = (async () => {
+    let attempt = 0;
+    while (!closed) {
+      const delayMs = relayReconnectDelay(attempt);
+      attempt += 1;
+      console.warn(`Codex Relay disconnected; retrying in ${Math.ceil(delayMs / 1000)}s.`);
+      await wait(delayMs);
+      if (closed) return;
+      try {
+        await connectRelay(bridge);
+        console.log('Customer Map Codex Bridge reconnected.');
+        return;
+      } catch (retryError) {
+        if (isPermanentRelayError(retryError)) {
+          await shutdown(retryError);
+          return;
+        }
+        console.warn(`Codex Relay reconnect failed: ${retryError instanceof Error ? retryError.message : String(retryError || '')}`);
+      }
+    }
+  })();
+  relayReconnectPromise = reconnectPromise;
+  try {
+    await reconnectPromise;
+  } finally {
+    if (relayReconnectPromise === reconnectPromise) relayReconnectPromise = null;
+    const pending = pendingRelayDisconnect;
+    pendingRelayDisconnect = null;
+    if (pending && !closed) void handleRelayDisconnect(pending.bridge, pending.error);
+  }
+}
+
+function createRelayError(message, code) {
+  const error = new Error(message);
+  if (code !== undefined && code !== null && code !== '') error.relayCode = Number(code) || String(code);
+  return error;
+}
+
+function isPermanentRelayError(error) {
+  const code = error?.relayCode;
+  if ([4001, 4002, 4401].includes(Number(code))) return true;
+  const message = String(error?.message || error || '');
+  return /unauthorized|invalid.*token|token.*invalid|connection removed|replaced by newer|bridge token|invalid relay url|invalid url|missing relayurl|connectionid does not match/i.test(message);
+}
+
+function relayReconnectDelay(attempt) {
+  return Math.min(RELAY_RECONNECT_MAX_MS, RELAY_RECONNECT_BASE_MS * (2 ** Math.min(attempt, 5)));
+}
+
 function handleRelayMessage(message) {
   if (message.type === 'ping') {
     sendRelay({ type: 'pong', at: Date.now() });
@@ -230,6 +331,7 @@ function handleRelayMessage(message) {
 async function runJob(job) {
   if (!initialized) throw new Error('Codex app-server is not initialized');
   if (!job?.id) throw new Error('Missing relay job id');
+  if (relay?.readyState !== WebSocket.OPEN) throw new Error('Codex Relay disconnected');
   if (activeJob()) throw new Error('Codex is already processing another request');
 
   if (job.request?.mailAction) {
@@ -252,24 +354,44 @@ async function runJob(job) {
 
   const sessionKey = String(job.request?.sessionKey || job.request?.conversationSessionId || 'default');
   const threadId = await ensureThread(sessionKey);
+  if (relay?.readyState !== WebSocket.OPEN) throw new Error('Codex Relay disconnected');
   const input = Array.isArray(job.request?.input) ? job.request.input : [];
   const prompt = input
     .map(item => `${String(item.role || 'user').toUpperCase()}:\n${stringifyContent(item.content)}`)
     .join('\n\n')
     .slice(-200000);
-  active = { id: String(job.id), threadId, text: '' };
+  const jobState = {
+    id: String(job.id),
+    threadId,
+    text: '',
+    turnId: '',
+    interrupted: false,
+    abort: () => {
+      jobState.interrupted = true;
+      interruptActiveTurn(jobState);
+    },
+  };
+  active = jobState;
   try {
-    await rpc('turn/start', {
+    const started = await rpc('turn/start', {
       threadId,
       approvalPolicy: 'never',
       sandboxPolicy: { type: 'readOnly', networkAccess: false },
       input: [{ type: 'text', text: prompt }],
     });
+    jobState.turnId = String(started?.turn?.id || '');
+    interruptActiveTurn(jobState);
   } catch (error) {
     failActiveJob(error instanceof Error ? error.message : String(error || 'Codex turn failed'));
   }
 }
 
+function interruptActiveTurn(job) {
+  if (!job?.interrupted || !job.turnId || job.interruptSent) return;
+  job.interruptSent = true;
+  void rpc('turn/interrupt', { threadId: job.threadId, turnId: job.turnId }, 10_000).catch(() => undefined);
+}
+
 async function ensureThread(sessionKey) {
   let threadId = String(state.threads?.[sessionKey] || '');
   if (threadId && !loadedThreads.has(threadId)) {
@@ -349,8 +471,8 @@ function sendCodex(message) {
   codex.stdin.write(`${JSON.stringify(message)}\n`);
 }
 
-function sendRelay(message) {
-  if (relay?.readyState === WebSocket.OPEN) relay.send(JSON.stringify(message));
+function sendRelay(message, socket = relay) {
+  if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
 }
 
 function startCodexAppServer(cwd, command) {
@@ -484,6 +606,13 @@ function parseConnectUri(value) {
   return { site: url.searchParams.get('site') || '', code: url.searchParams.get('code') || '' };
 }
 
+function wait(delayMs) {
+  return new Promise(resolve => {
+    const timer = setTimeout(resolve, delayMs);
+    timer.unref?.();
+  });
+}
+
 async function requestAuthorization(siteUrl) {
   if (process.platform === 'win32') {
     const dialog = spawnSync('powershell.exe', [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "customer-map-codex-bridge",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Connect a locally authenticated Codex CLI to Customer Map.",
   "type": "module",
   "bin": {