customer-map-codex-bridge 0.5.0 → 0.5.2

package/index.mjs

@@ -1,527 +1,654 @@
-#!/usr/bin/env node
-import { existsSync } from 'node:fs';
-import { spawn, spawnSync } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { delimiter, dirname, join } from 'node:path';
-import process from 'node:process';
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
 import WebSocket from 'ws';
 import { executeCustomerMapMailAction } from './mail-action.mjs';
-
-const BRIDGE_VERSION = '0.5.0';
-
-const args = parseArgs(process.argv.slice(2));
-if (args.help) {
-  console.log('Usage: customer-map-codex-bridge --site <Customer Map URL> --code <one-time code> [--cwd <folder>] [--codex <path>] [--gog <path>]');
-  process.exit(0);
-}
-
-const uri = args.uri || process.argv.slice(2).find(value => String(value).startsWith('customer-map-codex://'));
-const uriValues = uri ? parseConnectUri(uri) : {};
-const site = validateSite(args.site || uriValues.site);
-const code = validateCode(args.code || uriValues.code);
-const clientId = args.client || `codex-bridge-${process.platform}-${process.pid}`;
-const stateDir = args.state || join(homedir(), '.customer-map-codex');
-const stateFile = join(stateDir, 'state.json');
-
-let bridgeToken = '';
-let connectionId = '';
-let codex = null;
-let codexLines = null;
-let relay = null;
-let state = { threads: {} };
-let rpcId = 0;
-let initialized = false;
-let closed = false;
-let active = null;
-let shutdownPromise = null;
-const pendingRpc = new Map();
-const loadedThreads = new Set();
-
-process.once('SIGINT', () => { void shutdown(new Error('Codex Bridge interrupted')); });
-process.once('SIGTERM', () => { void shutdown(new Error('Codex Bridge terminated')); });
-
-await main();
-
-async function main() {
-  try {
-    await requestAuthorization(site);
-    state = await loadState();
-
-    const codexCommand = resolveCodexCommand(args.codex);
-    codex = startCodexAppServer(args.cwd || process.cwd(), codexCommand);
-    codexLines = createInterface({ input: codex.stdout });
-    attachCodexHandlers();
-
-    await rpc('initialize', {
-      clientInfo: { name: 'customer_map_codex_bridge', title: 'Customer Map Codex Bridge', version: BRIDGE_VERSION },
-      capabilities: { experimentalApi: true },
-    });
-    sendCodex({ method: 'initialized', params: {} });
-    initialized = true;
-    const accountStatus = await rpc('account/read', { refreshToken: true }, 30_000);
-    if (accountStatus?.requiresOpenaiAuth && !accountStatus.account) {
-      throw new Error('Codex CLI 尚未登录，请先运行 codex login。');
-    }
-
-    // Only consume the one-time code after the local Codex runtime is healthy.
-    // A failed app-server launch must not strand the code as "expired".
-    const bridge = await claim();
-    bridgeToken = bridge.bridgeToken;
-    connectionId = bridge.connectionId;
-    relay = await connectRelay(bridge);
-    console.log('Customer Map Codex Bridge connected.');
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error || 'Codex Bridge failed'));
-    await shutdown(error);
-    process.exitCode = 1;
-  }
-}
-
-function attachCodexHandlers() {
-  codexLines.on('line', handleCodexLine);
-  codex.on('error', error => {
-    rejectPendingRpc(error);
-    if (!closed) {
-      console.error(`Could not start Codex app-server: ${error.message}`);
-      void shutdown(error);
-    }
-  });
-  codex.on('exit', codeValue => {
-    const error = new Error(`Codex app-server exited (${codeValue ?? 'unknown'})`);
-    rejectPendingRpc(error);
-    if (active) failActiveJob(error.message);
-    if (!closed) {
-      console.error(error.message);
-      void shutdown(error);
-    }
-  });
-}
-
-function handleCodexLine(line) {
-  let message;
-  try { message = JSON.parse(line); } catch { return; }
-  if (message.id !== undefined && pendingRpc.has(message.id)) {
-    const entry = pendingRpc.get(message.id);
-    pendingRpc.delete(message.id);
-    if (message.error) entry.reject(new Error(message.error.message || 'Codex app-server request failed'));
-    else entry.resolve(message.result);
-    return;
-  }
-  if (message.method === 'item/agentMessage/delta') {
-    const job = activeJob(message.params);
-    const delta = String(message.params?.delta || message.params?.text || '');
-    if (job && delta) {
-      job.text += delta;
-      sendRelay({ type: 'progress', jobId: job.id, content: job.text.slice(-100000) });
-    }
-  }
-  if (message.method === 'item/completed') {
-    const item = message.params?.item;
-    if ((item?.type === 'agent_message' || item?.type === 'agentMessage') && typeof item.text === 'string') {
-      const job = activeJob(message.params);
-      if (job) job.text = item.text;
-    }
-  }
-  if (message.method === 'error' && !message.params?.willRetry && activeJob(message.params)) {
-    failActiveJob(message.params?.error?.message || 'Codex turn failed');
-  }
-  if (message.method === 'turn/completed' && activeJob(message.params)) {
-    const turn = message.params?.turn;
-    if (turn?.status === 'failed' || turn?.status === 'interrupted') {
-      failActiveJob(turn?.error?.message || `Codex turn ${turn.status}`);
-    } else {
-      finishActiveJob();
-    }
-  }
-  if (message.method === 'turn/failed' && activeJob(message.params)) {
-    failActiveJob(message.params?.error?.message || 'Codex turn failed');
-  }
-}
-
-function connectRelay(bridge) {
-  return new Promise((resolve, reject) => {
-    const socket = new WebSocket(webSocketUrl(bridge.relayUrl));
-    relay = socket;
-    let ready = false;
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      socket.close();
-      reject(new Error('Codex Relay 握手超时，请检查 Relay 或 Tunnel 是否在线。'));
-    }, 20_000);
-
-    socket.on('open', () => {
-      sendRelay({
-        type: 'hello',
-        runtime: 'codex',
-        bridgeToken: bridge.bridgeToken,
-        connectionId: bridge.connectionId,
-        clientId,
-        pluginVersion: BRIDGE_VERSION,
-        capabilities: {
-          runtime: 'verified',
-          sessionContext: 'verified',
-          customerMapData: 'declared',
-          webRead: 'declared',
-          webSearch: 'declared',
-          gmailDraft: 'declared',
-          gmailSend: 'confirmation',
-        },
-      });
-    });
-
-    socket.on('message', raw => {
-      let message;
-      try { message = JSON.parse(String(raw)); } catch { return; }
-      if (message.type === 'ready') {
-        if (ready) return;
-        ready = true;
-        settled = true;
-        clearTimeout(timer);
-        resolve(socket);
-        return;
-      }
-      if (message.type === 'error' && !ready && !settled) {
-        settled = true;
-        clearTimeout(timer);
-        socket.close();
-        reject(new Error(String(message.error || 'Codex Relay rejected the Bridge')));
-        return;
-      }
-      handleRelayMessage(message);
-    });
-
-    socket.on('error', error => {
-      if (!ready && !settled) {
-        settled = true;
-        clearTimeout(timer);
-        reject(new Error(`Codex Relay 连接失败：${error.message}`));
-      } else {
-        console.error(`Codex Relay error: ${error.message}`);
-      }
-    });
-
-    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}` : ''}`));
-        return;
-      }
-      if (!closed) void shutdown(new Error(`Codex Relay 已断开 (${codeValue ?? 'unknown'})${reason ? `: ${reason}` : ''}`));
-    });
-  });
-}
-
-function handleRelayMessage(message) {
-  if (message.type === 'ping') {
-    sendRelay({ type: 'pong', at: Date.now() });
-    return;
-  }
-  if (message.type === 'job') {
-    void runJob(message.job).catch(error => sendRelay({ type: 'complete', jobId: message.job?.id, error: error?.message || 'Codex request failed' }));
-  }
-}
-
-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 (activeJob()) throw new Error('Codex is already processing another request');
-
-  if (job.request?.mailAction) {
-    const controller = new AbortController();
-    active = { id: String(job.id), threadId: '', text: '', abort: () => controller.abort() };
-    try {
-      const response = await executeCustomerMapMailAction(job.request.mailAction, {
-        signal: controller.signal,
-        timeoutMs: job.timeoutMs,
-        gogCommand: args.gog,
-      });
-      if (!active || active.id !== String(job.id)) return;
-      active = null;
-      sendRelay({ type: 'complete', jobId: String(job.id), response: { output_text: JSON.stringify(response) } });
-    } catch (error) {
-      failActiveJob(error instanceof Error ? error.message : String(error || 'Codex mail action failed'));
-    }
-    return;
-  }
-
-  const sessionKey = String(job.request?.sessionKey || job.request?.conversationSessionId || 'default');
-  const threadId = await ensureThread(sessionKey);
-  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: '' };
-  try {
-    await rpc('turn/start', {
-      threadId,
-      approvalPolicy: 'never',
-      sandboxPolicy: { type: 'readOnly', networkAccess: false },
-      input: [{ type: 'text', text: prompt }],
-    });
-  } catch (error) {
-    failActiveJob(error instanceof Error ? error.message : String(error || 'Codex turn failed'));
-  }
-}
-
-async function ensureThread(sessionKey) {
-  let threadId = String(state.threads?.[sessionKey] || '');
-  if (threadId && !loadedThreads.has(threadId)) {
-    try {
-      const resumed = await rpc('thread/resume', {
-        threadId,
-        sandbox: 'read-only',
-        approvalPolicy: 'never',
-        excludeTurns: true,
-      }, 60_000);
-      threadId = String(resumed?.thread?.id || threadId);
-      loadedThreads.add(threadId);
-    } catch (error) {
-      if (!/thread not found/i.test(String(error?.message || error))) throw error;
-      threadId = '';
-    }
-  }
-  if (!threadId) {
-    threadId = String((await rpc('thread/start', {
-      sandbox: 'read-only',
-      approvalPolicy: 'never',
-    }, 60_000)).thread?.id || '');
-    if (!threadId) throw new Error('Codex did not return a thread id');
-    loadedThreads.add(threadId);
-  }
-  state.threads = { ...(state.threads || {}), [sessionKey]: threadId };
-  await saveState();
-  return threadId;
-}
-
-function activeJob(params) {
-  if (!active) return null;
-  const threadId = String(params?.threadId || '');
-  return threadId && threadId !== active.threadId ? null : active;
-}
-function finishActiveJob() {
-  if (!active) return;
-  const job = active;
-  active = null;
-  sendRelay({ type: 'complete', jobId: job.id, response: { output_text: job.text.trim() || 'Codex returned an empty response.' } });
-}
-function failActiveJob(error) {
-  if (!active) return;
-  const job = active;
-  active = null;
-  sendRelay({ type: 'complete', jobId: job.id, error: String(error || 'Codex request failed') });
-}
-
-function rpc(method, params, timeoutMs = 20_000) {
-  const id = ++rpcId;
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      pendingRpc.delete(id);
-      reject(new Error(`Codex app-server ${method} 超时`));
-    }, timeoutMs);
-    pendingRpc.set(id, {
-      resolve: value => { clearTimeout(timer); resolve(value); },
-      reject: error => { clearTimeout(timer); reject(error); },
-    });
-    try {
-      sendCodex({ method, id, params });
-    } catch (error) {
-      pendingRpc.delete(id);
-      clearTimeout(timer);
-      reject(error);
-    }
-  });
-}
-
-function rejectPendingRpc(error) {
-  for (const entry of pendingRpc.values()) entry.reject(error);
-  pendingRpc.clear();
-}
-
-function sendCodex(message) {
-  if (!codex?.stdin?.writable) throw new Error('Codex app-server stdin is unavailable');
-  codex.stdin.write(`${JSON.stringify(message)}\n`);
-}
-
-function sendRelay(message) {
-  if (relay?.readyState === WebSocket.OPEN) relay.send(JSON.stringify(message));
-}
-
-function startCodexAppServer(cwd, command) {
-  const codexArgs = ['app-server', '--listen', 'stdio://', '-c', 'web_search="live"'];
-  const pathValue = [dirname(process.execPath), dirname(command), process.env.PATH || ''].filter(Boolean).join(delimiter);
-  const options = { cwd, stdio: ['pipe', 'pipe', 'inherit'], windowsHide: true, env: { ...process.env, PATH: pathValue } };
-  if (process.platform !== 'win32') return spawn(command, codexArgs, options);
-  const commandShell = process.env.ComSpec || process.env.COMSPEC || 'C:\\Windows\\System32\\cmd.exe';
-  const commandLine = [command, ...codexArgs].map(quoteWindowsArg).join(' ');
-  return spawn(commandShell, ['/d', '/s', '/c', commandLine], options);
-}
-
+import { startCodexAppServer } from './codex-process.mjs';
+
+const BRIDGE_VERSION = '0.5.2';
+const RELAY_RECONNECT_BASE_MS = 1_000;
+const RELAY_RECONNECT_MAX_MS = 30_000;
+
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+  console.log('Usage: customer-map-codex-bridge --site <Customer Map URL> --code <one-time code> [--cwd <folder>] [--codex <path>] [--gog <path>]');
+  process.exit(0);
+}
+
+const uri = args.uri || process.argv.slice(2).find(value => String(value).startsWith('customer-map-codex://'));
+const uriValues = uri ? parseConnectUri(uri) : {};
+const site = validateSite(args.site || uriValues.site);
+const code = validateCode(args.code || uriValues.code);
+const clientId = args.client || `codex-bridge-${process.platform}-${process.pid}`;
+const stateDir = args.state || join(homedir(), '.customer-map-codex');
+const stateFile = join(stateDir, 'state.json');
+
+let bridgeToken = '';
+let connectionId = '';
+let codex = null;
+let codexLines = null;
+let relay = null;
+let state = { threads: {} };
+let rpcId = 0;
+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();
+
+process.once('SIGINT', () => { void shutdown(new Error('Codex Bridge interrupted')); });
+process.once('SIGTERM', () => { void shutdown(new Error('Codex Bridge terminated')); });
+
+await main();
+
+async function main() {
+  try {
+    await requestAuthorization(site);
+    state = await loadState();
+
+    const codexCommand = resolveCodexCommand(args.codex);
+    codex = startCodexAppServer(args.cwd || process.cwd(), codexCommand);
+    codexLines = createInterface({ input: codex.stdout });
+    attachCodexHandlers();
+
+    await rpc('initialize', {
+      clientInfo: { name: 'customer_map_codex_bridge', title: 'Customer Map Codex Bridge', version: BRIDGE_VERSION },
+      capabilities: { experimentalApi: true },
+    });
+    sendCodex({ method: 'initialized', params: {} });
+    initialized = true;
+    const accountStatus = await rpc('account/read', { refreshToken: true }, 30_000);
+    if (accountStatus?.requiresOpenaiAuth && !accountStatus.account) {
+      throw new Error('Codex CLI 尚未登录，请先运行 codex login。');
+    }
+
+    // Only consume the one-time code after the local Codex runtime is healthy.
+    // A failed app-server launch must not strand the code as "expired".
+    const bridge = await claim();
+    bridgeToken = bridge.bridgeToken;
+    connectionId = bridge.connectionId;
+    await connectRelayWithRetry(bridge);
+    console.log('Customer Map Codex Bridge connected.');
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error || 'Codex Bridge failed'));
+    await shutdown(error);
+    process.exitCode = 1;
+  }
+}
+
+function attachCodexHandlers() {
+  codexLines.on('line', handleCodexLine);
+  codex.on('error', error => {
+    rejectPendingRpc(error);
+    if (!closed) {
+      console.error(`Could not start Codex app-server: ${error.message}`);
+      void shutdown(error);
+    }
+  });
+  codex.on('exit', codeValue => {
+    const error = new Error(`Codex app-server exited (${codeValue ?? 'unknown'})`);
+    rejectPendingRpc(error);
+    if (active) failActiveJob(error.message);
+    if (!closed) {
+      console.error(error.message);
+      void shutdown(error);
+    }
+  });
+}
+
+function handleCodexLine(line) {
+  let message;
+  try { message = JSON.parse(line); } catch { return; }
+  if (message.id !== undefined && pendingRpc.has(message.id)) {
+    const entry = pendingRpc.get(message.id);
+    pendingRpc.delete(message.id);
+    if (message.error) entry.reject(new Error(message.error.message || 'Codex app-server request failed'));
+    else entry.resolve(message.result);
+    return;
+  }
+  if (message.method === 'item/agentMessage/delta') {
+    const job = activeJob(message.params);
+    const delta = String(message.params?.delta || message.params?.text || '');
+    if (job && delta) {
+      job.text += delta;
+      sendRelay({ type: 'progress', jobId: job.id, content: job.text.slice(-100000) });
+    }
+  }
+  if (message.method === 'item/completed') {
+    const item = message.params?.item;
+    if ((item?.type === 'agent_message' || item?.type === 'agentMessage') && typeof item.text === 'string') {
+      const job = activeJob(message.params);
+      if (job) job.text = item.text;
+    }
+  }
+  if (message.method === 'error' && !message.params?.willRetry && activeJob(message.params)) {
+    failActiveJob(message.params?.error?.message || 'Codex turn failed');
+  }
+  if (message.method === 'turn/completed' && activeJob(message.params)) {
+    const turn = message.params?.turn;
+    if (turn?.status === 'failed' || turn?.status === 'interrupted') {
+      failActiveJob(turn?.error?.message || `Codex turn ${turn.status}`);
+    } else {
+      finishActiveJob();
+    }
+  }
+  if (message.method === 'turn/failed' && activeJob(message.params)) {
+    failActiveJob(message.params?.error?.message || 'Codex turn failed');
+  }
+}
+
+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));
+    relay = socket;
+    let ready = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      socket.close();
+      reject(createRelayError('Codex Relay 握手超时，请检查 Relay 或 Tunnel 是否在线。'));
+    }, 20_000);
+
+    socket.on('open', () => {
+      sendRelay({
+        type: 'hello',
+        runtime: 'codex',
+        bridgeToken: bridge.bridgeToken,
+        connectionId: bridge.connectionId,
+        clientId,
+        pluginVersion: BRIDGE_VERSION,
+        capabilities: {
+          runtime: 'verified',
+          sessionContext: 'verified',
+          customerMapData: 'declared',
+          webRead: 'declared',
+          webSearch: 'declared',
+          gmailDraft: 'declared',
+          gmailSend: 'confirmation',
+        },
+      }, socket);
+    });
+
+    socket.on('message', raw => {
+      let message;
+      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);
+        resolve(socket);
+        return;
+      }
+      if (message.type === 'error' && !ready && !settled) {
+        settled = true;
+        clearTimeout(timer);
+        socket.close();
+        reject(createRelayError(String(message.error || 'Codex Relay rejected the Bridge'), message.code));
+        return;
+      }
+      if (relay !== socket) return;
+      handleRelayMessage(message);
+    });
+
+    socket.on('error', error => {
+      if (!ready && !settled) {
+        settled = true;
+        clearTimeout(timer);
+        socket.close();
+        reject(createRelayError(`Codex Relay 连接失败：${error.message}`));
+      } else {
+        console.error(`Codex Relay error: ${error.message}`);
+      }
+    });
+
+    socket.on('close', (codeValue, reasonValue) => {
+      const reason = String(reasonValue || '').trim();
+      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) {
+        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() });
+    return;
+  }
+  if (message.type === 'job') {
+    void runJob(message.job).catch(error => sendRelay({ type: 'complete', jobId: message.job?.id, error: error?.message || 'Codex request failed' }));
+  }
+}
+
+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) {
+    const controller = new AbortController();
+    active = { id: String(job.id), threadId: '', text: '', abort: () => controller.abort() };
+    try {
+      const response = await executeCustomerMapMailAction(job.request.mailAction, {
+        signal: controller.signal,
+        timeoutMs: job.timeoutMs,
+        gogCommand: args.gog,
+      });
+      if (!active || active.id !== String(job.id)) return;
+      active = null;
+      sendRelay({ type: 'complete', jobId: String(job.id), response: { output_text: JSON.stringify(response) } });
+    } catch (error) {
+      failActiveJob(error instanceof Error ? error.message : String(error || 'Codex mail action failed'));
+    }
+    return;
+  }
+
+  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);
+  const jobState = {
+    id: String(job.id),
+    threadId,
+    text: '',
+    turnId: '',
+    interrupted: false,
+    abort: () => {
+      jobState.interrupted = true;
+      interruptActiveTurn(jobState);
+    },
+  };
+  active = jobState;
+  try {
+    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)) {
+    try {
+      const resumed = await rpc('thread/resume', {
+        threadId,
+        sandbox: 'read-only',
+        approvalPolicy: 'never',
+        excludeTurns: true,
+      }, 60_000);
+      threadId = String(resumed?.thread?.id || threadId);
+      loadedThreads.add(threadId);
+    } catch (error) {
+      if (!/thread not found/i.test(String(error?.message || error))) throw error;
+      threadId = '';
+    }
+  }
+  if (!threadId) {
+    threadId = String((await rpc('thread/start', {
+      sandbox: 'read-only',
+      approvalPolicy: 'never',
+    }, 60_000)).thread?.id || '');
+    if (!threadId) throw new Error('Codex did not return a thread id');
+    loadedThreads.add(threadId);
+  }
+  state.threads = { ...(state.threads || {}), [sessionKey]: threadId };
+  await saveState();
+  return threadId;
+}
+
+function activeJob(params) {
+  if (!active) return null;
+  const threadId = String(params?.threadId || '');
+  return threadId && threadId !== active.threadId ? null : active;
+}
+function finishActiveJob() {
+  if (!active) return;
+  const job = active;
+  active = null;
+  sendRelay({ type: 'complete', jobId: job.id, response: { output_text: job.text.trim() || 'Codex returned an empty response.' } });
+}
+function failActiveJob(error) {
+  if (!active) return;
+  const job = active;
+  active = null;
+  sendRelay({ type: 'complete', jobId: job.id, error: String(error || 'Codex request failed') });
+}
+
+function rpc(method, params, timeoutMs = 20_000) {
+  const id = ++rpcId;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingRpc.delete(id);
+      reject(new Error(`Codex app-server ${method} 超时`));
+    }, timeoutMs);
+    pendingRpc.set(id, {
+      resolve: value => { clearTimeout(timer); resolve(value); },
+      reject: error => { clearTimeout(timer); reject(error); },
+    });
+    try {
+      sendCodex({ method, id, params });
+    } catch (error) {
+      pendingRpc.delete(id);
+      clearTimeout(timer);
+      reject(error);
+    }
+  });
+}
+
+function rejectPendingRpc(error) {
+  for (const entry of pendingRpc.values()) entry.reject(error);
+  pendingRpc.clear();
+}
+
+function sendCodex(message) {
+  if (!codex?.stdin?.writable) throw new Error('Codex app-server stdin is unavailable');
+  codex.stdin.write(`${JSON.stringify(message)}\n`);
+}
+
+function sendRelay(message, socket = relay) {
+  if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
+}
+
 function resolveCodexCommand(value) {
   const requested = String(value || process.env.CUSTOMER_MAP_CODEX_BIN || '').trim();
+  if (process.platform === 'win32') {
+    if (requested && requested !== 'codex' && requested !== 'codex.cmd') {
+      return normalizeWindowsCodexPath(requested);
+    }
+    return requested || 'codex.cmd';
+  }
   if (requested && requested !== 'codex' && requested !== 'codex.cmd') return requested;
-  if (process.platform === 'win32') return requested || 'codex.cmd';
-  const candidates = [
-    join(homedir(), '.npm-global', 'bin', 'codex'),
-    join(homedir(), '.local', 'bin', 'codex'),
-    '/opt/homebrew/bin/codex',
-    '/usr/local/bin/codex',
-    '/usr/bin/codex',
-  ];
+  const candidates = [
+    join(homedir(), '.npm-global', 'bin', 'codex'),
+    join(homedir(), '.local', 'bin', 'codex'),
+    '/opt/homebrew/bin/codex',
+    '/usr/local/bin/codex',
+    '/usr/bin/codex',
+  ];
   return candidates.find(candidate => existsSync(candidate)) || 'codex';
 }
 
-function quoteWindowsArg(value) {
-  return `"${String(value).replaceAll('"', '\\"')}"`;
+function normalizeWindowsCodexPath(value) {
+  if (!/\.ps1$/i.test(value)) return value;
+  const cmdPath = value.replace(/\.ps1$/i, '.cmd');
+  return existsSync(cmdPath) ? cmdPath : value;
 }
 
 async function claim() {
-  const response = await fetch(`${site.replace(/\/$/, '')}/api/codex-link`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ action: 'claim', code, clientId }),
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(data?.error || `Claim failed (${response.status})`);
-  const nextBridgeToken = String(data?.bridgeToken || '');
-  const nextConnectionId = String(data?.connectionId || '');
-  if (!nextBridgeToken || !nextConnectionId) throw new Error('Customer Map returned an incomplete Codex connection');
-  return { ...data, bridgeToken: nextBridgeToken, connectionId: nextConnectionId };
-}
-
-async function notifyOffline(error) {
-  if (!bridgeToken || !clientId) return;
-  const response = await fetch(`${site.replace(/\/$/, '')}/api/codex-link`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ action: 'bridge-offline', bridgeToken, clientId, error: String(error?.message || error || '') }),
-  });
-  if (!response.ok) throw new Error(`Customer Map offline status failed (${response.status})`);
-}
-
-async function shutdown(error) {
-  if (shutdownPromise) return shutdownPromise;
-  shutdownPromise = (async () => {
-    if (closed) return;
-    closed = true;
-    active?.abort?.();
-    if (active) failActiveJob(error instanceof Error ? error.message : String(error || 'Codex Bridge stopped'));
-    rejectPendingRpc(error instanceof Error ? error : new Error(String(error || 'Codex Bridge stopped')));
-    await notifyOffline(error).catch(() => undefined);
-    if (relay && (relay.readyState === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING)) relay.close();
-    if (codex && !codex.killed) codex.kill();
-    codexLines?.close();
-  })();
-  return shutdownPromise;
-}
-
-async function loadState() {
-  try {
-    const parsed = JSON.parse(await readFile(stateFile, 'utf8'));
-    return parsed && typeof parsed === 'object' && parsed.threads && typeof parsed.threads === 'object'
-      ? parsed
-      : { threads: {} };
-  } catch {
-    return { threads: {} };
-  }
-}
-
-async function saveState() {
-  await mkdir(stateDir, { recursive: true });
-  await writeFile(stateFile, JSON.stringify(state, null, 2), 'utf8');
-}
-
-function stringifyContent(value) {
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) return value.map(item => stringifyContent(item)).join('\n');
-  if (value && typeof value === 'object') {
-    const text = value.text || value.content || value.value;
-    if (typeof text === 'string') return text;
-    try { return JSON.stringify(value); } catch { return String(value); }
-  }
-  return String(value ?? '');
-}
-
-function required(value, name) { if (!value) throw new Error(`Missing ${name}`); return value; }
-function validateSite(value) {
-  const url = new URL(required(value, '--site'));
-  const localHttp = url.protocol === 'http:' && ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname);
-  if (url.protocol !== 'https:' && !localHttp) throw new Error('Customer Map site must use HTTPS (localhost may use HTTP)');
-  return url.origin;
-}
-function validateCode(value) {
-  const normalized = String(required(value, '--code')).trim().toUpperCase().replace(/\s+/g, '');
-  if (!/^CMAP-CODEX-[A-F0-9]{12}$/.test(normalized)) throw new Error('Invalid Customer Map Codex connection code');
-  return normalized;
-}
-function parseArgs(values) {
-  const result = {};
-  for (let i = 0; i < values.length; i += 1) {
-    const value = values[i];
-    if (!value.startsWith('--')) continue;
-    const key = value.slice(2);
-    const next = values[i + 1];
-    if (!next || next.startsWith('--')) result[key] = true;
-    else { result[key] = next; i += 1; }
-  }
-  return result;
-}
-function webSocketUrl(value) {
-  const url = new URL(required(value, 'relayUrl'));
-  if (url.protocol === 'https:') url.protocol = 'wss:';
-  if (url.protocol === 'http:') url.protocol = 'ws:';
-  if (!/^wss?:$/.test(url.protocol)) throw new Error('Invalid relay URL');
-  return url.toString();
-}
-function parseConnectUri(value) {
-  const url = new URL(value);
-  return { site: url.searchParams.get('site') || '', code: url.searchParams.get('code') || '' };
-}
-
-async function requestAuthorization(siteUrl) {
-  if (process.platform === 'win32') {
-    const dialog = spawnSync('powershell.exe', [
-      '-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
-      '-WindowStyle', 'Hidden', '-Command',
-      "$ErrorActionPreference='Stop'; Add-Type -AssemblyName PresentationFramework; $site = $env:CUSTOMER_MAP_CODEX_SITE; $message = \"Customer Map wants to connect to the Codex installed on this computer.`n`nSite: $site`n`nCodex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local.\"; $result = [System.Windows.MessageBox]::Show($message, 'Customer Map - Codex authorization', 'YesNo', 'Question', 'No'); if ($result -eq 'Yes') { exit 0 }; exit 1",
-    ], { env: { ...process.env, CUSTOMER_MAP_CODEX_SITE: siteUrl }, stdio: 'ignore', windowsHide: true });
-    if (!dialog.error) {
-      if (dialog.status === 0) return;
-      console.log('Codex connection cancelled.');
-      process.exit(0);
-    }
-  }
-  if (process.platform === 'darwin') {
-    const dialog = spawnSync('osascript', ['-e', [
-      'on run argv',
-      '  set siteUrl to item 1 of argv',
-      '  set promptText to "Customer Map wants to connect to the Codex installed on this Mac." & return & return & "Site: " & siteUrl & return & return & "Codex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local."',
-      '  display dialog promptText with title "Customer Map - Codex authorization" buttons {"Cancel", "Allow"} default button "Cancel"',
-      '  if button returned of result is "Allow" then return 0',
-      '  return 1',
-      'end run',
-    ].join('\n'), siteUrl], { stdio: 'ignore' });
-    if (!dialog.error) {
-      if (dialog.status === 0) return;
-      console.log('Codex connection cancelled.');
-      process.exit(0);
-    }
-  }
-  console.log(`\nCustomer Map wants to connect to the Codex installed on this computer.`);
-  console.log(`Site: ${siteUrl}`);
-  console.log('Codex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local.');
-  process.stdout.write('Allow this connection? [y/N] ');
-  const input = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise(resolve => input.once('line', resolve));
-  input.close();
-  if (String(answer).trim().toLowerCase() !== 'y') {
-    console.log('Codex connection cancelled.');
-    process.exit(0);
-  }
-}
+  const response = await fetch(`${site.replace(/\/$/, '')}/api/codex-link`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ action: 'claim', code, clientId }),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(data?.error || `Claim failed (${response.status})`);
+  const nextBridgeToken = String(data?.bridgeToken || '');
+  const nextConnectionId = String(data?.connectionId || '');
+  if (!nextBridgeToken || !nextConnectionId) throw new Error('Customer Map returned an incomplete Codex connection');
+  return { ...data, bridgeToken: nextBridgeToken, connectionId: nextConnectionId };
+}
+
+async function notifyOffline(error) {
+  if (!bridgeToken || !clientId) return;
+  const response = await fetch(`${site.replace(/\/$/, '')}/api/codex-link`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ action: 'bridge-offline', bridgeToken, clientId, error: String(error?.message || error || '') }),
+  });
+  if (!response.ok) throw new Error(`Customer Map offline status failed (${response.status})`);
+}
+
+async function shutdown(error) {
+  if (shutdownPromise) return shutdownPromise;
+  shutdownPromise = (async () => {
+    if (closed) return;
+    closed = true;
+    active?.abort?.();
+    if (active) failActiveJob(error instanceof Error ? error.message : String(error || 'Codex Bridge stopped'));
+    rejectPendingRpc(error instanceof Error ? error : new Error(String(error || 'Codex Bridge stopped')));
+    await notifyOffline(error).catch(() => undefined);
+    if (relay && (relay.readyState === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING)) relay.close();
+    if (codex && !codex.killed) codex.kill();
+    codexLines?.close();
+  })();
+  return shutdownPromise;
+}
+
+async function loadState() {
+  try {
+    const parsed = JSON.parse(await readFile(stateFile, 'utf8'));
+    return parsed && typeof parsed === 'object' && parsed.threads && typeof parsed.threads === 'object'
+      ? parsed
+      : { threads: {} };
+  } catch {
+    return { threads: {} };
+  }
+}
+
+async function saveState() {
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(stateFile, JSON.stringify(state, null, 2), 'utf8');
+}
+
+function stringifyContent(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(item => stringifyContent(item)).join('\n');
+  if (value && typeof value === 'object') {
+    const text = value.text || value.content || value.value;
+    if (typeof text === 'string') return text;
+    try { return JSON.stringify(value); } catch { return String(value); }
+  }
+  return String(value ?? '');
+}
+
+function required(value, name) { if (!value) throw new Error(`Missing ${name}`); return value; }
+function validateSite(value) {
+  const url = new URL(required(value, '--site'));
+  const localHttp = url.protocol === 'http:' && ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname);
+  if (url.protocol !== 'https:' && !localHttp) throw new Error('Customer Map site must use HTTPS (localhost may use HTTP)');
+  return url.origin;
+}
+function validateCode(value) {
+  const normalized = String(required(value, '--code')).trim().toUpperCase().replace(/\s+/g, '');
+  if (!/^CMAP-CODEX-[A-F0-9]{12}$/.test(normalized)) throw new Error('Invalid Customer Map Codex connection code');
+  return normalized;
+}
+function parseArgs(values) {
+  const result = {};
+  for (let i = 0; i < values.length; i += 1) {
+    const value = values[i];
+    if (!value.startsWith('--')) continue;
+    const key = value.slice(2);
+    const next = values[i + 1];
+    if (!next || next.startsWith('--')) result[key] = true;
+    else { result[key] = next; i += 1; }
+  }
+  return result;
+}
+function webSocketUrl(value) {
+  const url = new URL(required(value, 'relayUrl'));
+  if (url.protocol === 'https:') url.protocol = 'wss:';
+  if (url.protocol === 'http:') url.protocol = 'ws:';
+  if (!/^wss?:$/.test(url.protocol)) throw new Error('Invalid relay URL');
+  return url.toString();
+}
+function parseConnectUri(value) {
+  const url = new URL(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', [
+      '-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+      '-WindowStyle', 'Hidden', '-Command',
+      "$ErrorActionPreference='Stop'; Add-Type -AssemblyName PresentationFramework; $site = $env:CUSTOMER_MAP_CODEX_SITE; $message = \"Customer Map wants to connect to the Codex installed on this computer.`n`nSite: $site`n`nCodex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local.\"; $result = [System.Windows.MessageBox]::Show($message, 'Customer Map - Codex authorization', 'YesNo', 'Question', 'No'); if ($result -eq 'Yes') { exit 0 }; exit 1",
+    ], { env: { ...process.env, CUSTOMER_MAP_CODEX_SITE: siteUrl }, stdio: 'ignore', windowsHide: true });
+    if (!dialog.error) {
+      if (dialog.status === 0) return;
+      console.log('Codex connection cancelled.');
+      process.exit(0);
+    }
+  }
+  if (process.platform === 'darwin') {
+    const dialog = spawnSync('osascript', ['-e', [
+      'on run argv',
+      '  set siteUrl to item 1 of argv',
+      '  set promptText to "Customer Map wants to connect to the Codex installed on this Mac." & return & return & "Site: " & siteUrl & return & return & "Codex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local."',
+      '  display dialog promptText with title "Customer Map - Codex authorization" buttons {"Cancel", "Allow"} default button "Cancel"',
+      '  if button returned of result is "Allow" then return 0',
+      '  return 1',
+      'end run',
+    ].join('\n'), siteUrl], { stdio: 'ignore' });
+    if (!dialog.error) {
+      if (dialog.status === 0) return;
+      console.log('Codex connection cancelled.');
+      process.exit(0);
+    }
+  }
+  console.log(`\nCustomer Map wants to connect to the Codex installed on this computer.`);
+  console.log(`Site: ${siteUrl}`);
+  console.log('Codex chat stays read-only. Live web search may read public sites; shell network and file writes stay blocked. Only explicit Gmail draft/send actions may run local gog. Credentials stay local.');
+  process.stdout.write('Allow this connection? [y/N] ');
+  const input = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise(resolve => input.once('line', resolve));
+  input.close();
+  if (String(answer).trim().toLowerCase() !== 'y') {
+    console.log('Codex connection cancelled.');
+    process.exit(0);
+  }
+}