cx-viewer 1.0.3 → 1.0.4

package/proxy.js

@@ -1,41 +1,24 @@
 
-import { createServer, request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { readFileSync, existsSync, appendFileSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { createServer } from 'node:http';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { DEFAULT_API_BASE } from './lib/constants.js';
 import { homedir } from 'node:os';
-import { setupInterceptor } from './interceptor.js';
-import { extractApiErrorMessage, formatProxyRequestError } from './lib/proxy-errors.js';
-import { LOG_FILE } from './interceptor.js';
-import { isStaleLocalCodexBaseUrl } from './lib/codex-config.js';
-
-// Setup interceptor to patch fetch
-setupInterceptor();
-
-function getBaseUrlFromSettings(settingsPath) {
-  try {
-    if (existsSync(settingsPath)) {
-      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-      if (settings.env && settings.env.OPENAI_BASE_URL) {
-        return settings.env.OPENAI_BASE_URL;
-      }
-    }
-  } catch (e) {
-    // ignore
+import { extractApiErrorMessage } from './lib/proxy-errors.js';
+import { readOriginalOpenAiBaseUrl } from './lib/codex-config.js';
+
+let _interceptorReady = null;
+
+async function ensureProxyInterceptor() {
+  if (process.env.CXV_TEST === '1') return;
+  if (!_interceptorReady) {
+    _interceptorReady = import('./interceptor.js').then(mod => {
+      mod.setupInterceptor();
+    }).catch(err => {
+      if (process.env.CXV_DEBUG) console.warn('[CX-Proxy] interceptor setup skipped:', err.message);
+    });
   }
-  return null;
-}
-
-function getCodexConfigBaseUrl(configPath) {
-  try {
-    if (existsSync(configPath)) {
-      const content = readFileSync(configPath, 'utf-8');
-      const match = content.match(/^openai_base_url\s*=\s*"([^"]*)"/m);
-      if (match && match[1]) return match[1];
-    }
-  } catch {}
-  return null;
+  await _interceptorReady;
 }
 
 function getOriginalBaseUrl() {
@@ -44,33 +27,16 @@ function getOriginalBaseUrl() {
     return process.env.CXV_ORIGINAL_BASE_URL;
   }
 
-  let cwd;
-  try { cwd = process.cwd(); } catch { cwd = null; }
-
-  // 2. Codex config.toml (user-level only — skip project-level which may contain our proxy URL)
-  const codexUserConfig = join(homedir(), '.codex', 'config.toml');
-  const codexUrl = getCodexConfigBaseUrl(codexUserConfig);
-  if (codexUrl && !isStaleLocalCodexBaseUrl(codexUrl)) return codexUrl;
-
-  // 3. Codex settings.json
-  const configPaths = [];
-  if (cwd) {
-    configPaths.push(join(cwd, '.codex', 'settings.local.json'));
-    configPaths.push(join(cwd, '.codex', 'settings.json'));
-  }
-  configPaths.push(join(homedir(), '.codex', 'settings.json'));
-
-  for (const configPath of configPaths) {
-    const url = getBaseUrlFromSettings(configPath);
-    if (url) return url;
-  }
+  // 2. Codex config.toml (user/system only — skip project-level which may contain our proxy URL)
+  const codexUrl = readOriginalOpenAiBaseUrl();
+  if (codexUrl) return codexUrl;
 
-  // 4. Check env var
+  // 3. Check env var
   if (process.env.OPENAI_BASE_URL) {
     return process.env.OPENAI_BASE_URL;
   }
 
-  // 5. Default
+  // 4. Default
   return DEFAULT_API_BASE;
 }
 
@@ -81,95 +47,157 @@ function buildUpstreamUrl(reqUrl) {
   return { fullUrl: `${cleanBase}/${cleanReq}`, originalBaseUrl };
 }
 
-// ─── WebSocket frame parser (for logging) ───
-// Minimal parser to extract text messages from WebSocket frames.
-// Only handles unfragmented text frames (opcode 0x01) for simplicity.
-
-function parseWsFrames(buf) {
-  const messages = [];
-  let offset = 0;
-  while (offset < buf.length) {
-    if (offset + 2 > buf.length) break;
-    const firstByte = buf[offset];
-    const secondByte = buf[offset + 1];
-    const fin = (firstByte & 0x80) !== 0;
-    const opcode = firstByte & 0x0f;
-    const masked = (secondByte & 0x80) !== 0;
-    let payloadLen = secondByte & 0x7f;
-    let headerLen = 2;
-
-    if (payloadLen === 126) {
-      if (offset + 4 > buf.length) break;
-      payloadLen = buf.readUInt16BE(offset + 2);
-      headerLen = 4;
-    } else if (payloadLen === 127) {
-      if (offset + 10 > buf.length) break;
-      // Read as BigUInt64BE, but limit to safe integer
-      payloadLen = Number(buf.readBigUInt64BE(offset + 2));
-      headerLen = 10;
-    }
+// ─── Auth-aware upstream routing (PTY / -c redirect mode) ───
+// Codex is redirected to this proxy via `-c openai_base_url="http://127.0.0.1:PORT/v1"`,
+// so BOTH ChatGPT-OAuth and API-key sessions arrive here at the SAME path
+// (`/v1/responses`). The path therefore can't tell the modes apart — we route by
+// the `ChatGPT-Account-Id` request header (present only in OAuth mode), falling
+// back to ~/.codex/auth.json. Codex appended its suffix to our injected `/v1`
+// base, so we strip that prefix and re-append the suffix to the REAL upstream
+// base (which may itself carry a path, e.g. a custom gateway).
 
-    if (masked) headerLen += 4;
-    const totalLen = headerLen + payloadLen;
-    if (offset + totalLen > buf.length) break;
-
-    // Only parse text frames (opcode 1) with FIN bit
-    if (fin && opcode === 1) {
-      let payload = buf.slice(offset + headerLen, offset + headerLen + payloadLen);
-      if (masked) {
-        const maskKey = buf.slice(offset + headerLen - 4, offset + headerLen);
-        payload = Buffer.from(payload);
-        for (let i = 0; i < payload.length; i++) {
-          payload[i] ^= maskKey[i & 3];
-        }
-      }
-      try {
-        messages.push(payload.toString('utf-8'));
-      } catch {}
+const INJECTED_BASE_PATH = '/v1';
+
+// The proxy's own listen port, set in startProxy(); used to break self-forward loops.
+let _proxyOwnPort = null;
+
+// Test hook: set/reset the remembered own port without starting a server.
+export function _setProxyOwnPortForTests(port) { _proxyOwnPort = port; }
+
+function _defaultOpenAiBase() {
+  return `${DEFAULT_API_BASE.replace(/\/+$/, '')}/v1`;
+}
+function _defaultChatgptBase() {
+  return 'https://chatgpt.com/backend-api/codex';
+}
+
+// Lazily-read ChatGPT-OAuth status from ~/.codex/auth.json, cached for the life
+// of the proxy (auth mode is stable within a session; the definitive signal is
+// the per-request ChatGPT-Account-Id header, so this is only a fallback).
+let _authJsonOAuth = null; // null = not yet read
+function _authJsonIsOAuth() {
+  if (_authJsonOAuth !== null) return _authJsonOAuth;
+  _authJsonOAuth = false;
+  try {
+    const authPath = join(homedir(), '.codex', 'auth.json');
+    if (existsSync(authPath)) {
+      const a = JSON.parse(readFileSync(authPath, 'utf-8'));
+      if (a && a.auth_mode === 'chatgpt') _authJsonOAuth = true;
     }
-    offset += totalLen;
-  }
-  return messages;
+  } catch { }
+  return _authJsonOAuth;
+}
+
+export function isOAuthRequest(headers = {}) {
+  // Node lowercases incoming header names; the account-id header is definitive.
+  if (headers['chatgpt-account-id']) return true;
+  if (process.env.CXV_TEST === '1') return false; // deterministic routing in tests
+  return _authJsonIsOAuth();
 }
 
-// Log a WebSocket session (connect + messages) to the interceptor JSONL file
-function logWsEntry(url, direction, messages, startTime) {
-  if (!LOG_FILE) return;
+function _isSelfForward(fullUrl) {
   try {
-    for (const msg of messages) {
-      let parsed = null;
-      try { parsed = JSON.parse(msg); } catch {}
-      const entry = {
-        timestamp: new Date().toISOString(),
-        project: (() => { try { return basename(process.cwd()); } catch { return 'unknown'; } })(),
-        url,
-        method: 'WS',
-        isWebSocket: true,
-        wsDirection: direction, // 'send' (client→upstream) or 'recv' (upstream→client)
-        body: parsed || msg,
-        response: direction === 'recv' ? { status: 200, body: parsed || msg } : null,
-        duration: Date.now() - startTime,
-        isStream: false,
-        mainAgent: false,
-      };
-      appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n---\n');
+    const u = new URL(fullUrl);
+    const host = u.hostname.replace(/^\[|\]$/g, '');
+    const loopback = host === '127.0.0.1' || host === 'localhost' || host === '::1' || host === '::ffff:127.0.0.1';
+    if (!loopback) return false;
+    const port = Number(u.port) || (u.protocol === 'https:' ? 443 : 80);
+    return _proxyOwnPort != null && port === _proxyOwnPort;
+  } catch {
+    return false;
+  }
+}
+
+// Strip our injected base path (`/v1`) prefix so we recover the suffix Codex
+// appended (e.g. `/responses`). Tolerant: unmatched paths pass through verbatim.
+// The caller re-adds a leading slash, so returning `/responses` or `?x=1` is fine.
+function _stripInjectedPrefix(reqUrl) {
+  if (reqUrl === INJECTED_BASE_PATH) return '/';
+  if (reqUrl.startsWith(INJECTED_BASE_PATH + '/') || reqUrl.startsWith(INJECTED_BASE_PATH + '?')) {
+    return reqUrl.slice(INJECTED_BASE_PATH.length);
+  }
+  return reqUrl;
+}
+
+export function resolveUpstream(reqUrl, headers = {}) {
+  const isOAuth = isOAuthRequest(headers);
+  const suffix = _stripInjectedPrefix(reqUrl);
+  const cleanSuffix = suffix.startsWith('/') ? suffix : '/' + suffix;
+
+  let cleanBase;
+  let fallbackBase;
+  if (isOAuth) {
+    // ChatGPT-OAuth: model traffic must go to the chatgpt backend, not the
+    // openai host. Strip our injected /v1 prefix and re-append the suffix.
+    cleanBase = (process.env.CXV_ORIGINAL_CHATGPT_BASE_URL || _defaultChatgptBase()).replace(/\/+$/, '');
+    fallbackBase = _defaultChatgptBase().replace(/\/+$/, '');
+  } else if (process.env.CXV_ORIGINAL_BASE_URL) {
+    // CLI PTY redirect mode: real upstream captured in CXV_ORIGINAL_BASE_URL.
+    cleanBase = process.env.CXV_ORIGINAL_BASE_URL.replace(/\/+$/, '');
+    fallbackBase = _defaultOpenAiBase();
+  } else {
+    // Backward-compat (Electron / SDK proxy callers, no redirect env): preserve
+    // the original config/OPENAI_BASE_URL resolution so custom gateways still
+    // route correctly. buildUpstreamUrl uses the raw reqUrl, not the stripped
+    // suffix, matching that path's historical behavior.
+    let { fullUrl } = buildUpstreamUrl(reqUrl);
+    if (_isSelfForward(fullUrl)) {
+      fullUrl = _defaultOpenAiBase().replace(/\/+$/, '') + cleanSuffix;
     }
-  } catch (err) {
-    if (process.env.CXV_DEBUG) console.warn('[CX-Viewer Proxy] logWsEntry error:', err.message);
+    return { fullUrl, originalBaseUrl: getOriginalBaseUrl(), authMode: 'API Key' };
+  }
+
+  let fullUrl = cleanBase + cleanSuffix;
+  // Never forward to ourselves (would loop): fall back to the public default.
+  if (_isSelfForward(fullUrl)) {
+    fullUrl = fallbackBase + cleanSuffix;
+  }
+
+  return { fullUrl, originalBaseUrl: cleanBase, authMode: isOAuth ? 'OAuth' : 'API Key' };
+}
+
+let _proxyServer = null;
+
+export function stopProxy() {
+  if (_proxyServer) {
+    try { _proxyServer.close(); } catch { }
+    _proxyServer = null;
   }
+  _proxyOwnPort = null;
 }
 
 export function startProxy() {
-  return new Promise((resolve, reject) => {
+  return ensureProxyInterceptor().then(() => new Promise((resolve, reject) => {
     const server = createServer(async (req, res) => {
-      const { fullUrl, originalBaseUrl } = buildUpstreamUrl(req.url);
-      if (process.env.CXV_DEBUG) console.error(`[CX-Proxy] ${req.method} ${req.url} → ${originalBaseUrl}`);
+      // Normalize the request target. When a client (or an upstream HTTP proxy
+      // like Clash/mihomo) routes to us in absolute-form —
+      // `POST http://127.0.0.1:PORT/v1/responses` — Node sets req.url to the full
+      // URL. Reduce it to path+query so path routing works. (We also add loopback
+      // to NO_PROXY when spawning Codex so it connects directly, origin-form.)
+      let reqPath = req.url;
+      if (/^https?:\/\//i.test(reqPath)) {
+        try { const u = new URL(reqPath); reqPath = u.pathname + u.search; } catch { }
+      }
+      const { fullUrl, originalBaseUrl, authMode } = resolveUpstream(reqPath, req.headers);
+      if (process.env.CXV_DEBUG) console.error(`[CX-Proxy] ${req.method} ${reqPath} [${authMode}] → ${fullUrl}`);
 
       // Use the patched fetch (which logs to cx-viewer)
       try {
-        // Convert incoming headers
+        // Convert incoming headers, stripping hop-by-hop + length/encoding headers.
+        // undici/fetch computes its own content-length for the Buffer body and
+        // manages the connection; forwarding Codex's content-length /
+        // transfer-encoding / connection headers makes undici reject the request
+        // (→ 502). Host is dropped so fetch sets it from the upstream URL.
         const headers = { ...req.headers };
-        delete headers.host; // Let fetch set the host
+        for (const h of ['host', 'connection', 'keep-alive', 'proxy-authenticate',
+          'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade',
+          'content-length']) {
+          delete headers[h];
+        }
+        // Force an uncompressed upstream response (like claude-tap). Forwarding
+        // Codex's Accept-Encoding (gzip/br/zstd) risks the client and our
+        // decompression disagreeing, corrupting the SSE stream; identity avoids it.
+        headers['accept-encoding'] = 'identity';
 
         const buffers = [];
         for await (const chunk of req) {
@@ -238,132 +266,50 @@ export function startProxy() {
           res.end();
         }
       } catch (err) {
-        // Log proxy errors only when debugging
-        if (process.env.CXV_DEBUG) {
-          console.error('[CX-Viewer Proxy] Error:', err);
-        }
-
+        // Surface the real reason: log it and include it in the 502 body so it
+        // shows up directly in Codex's error message (aids diagnosis without
+        // needing CXV_DEBUG). Only the upstream host is revealed, not credentials.
+        const detail = err && err.message ? err.message : String(err);
+        console.error(`[CX-Viewer Proxy] Forward to ${fullUrl} failed: ${detail}`);
         res.statusCode = 502;
-        res.end('Proxy Error');
+        res.end(`Proxy Error: ${detail} (upstream: ${fullUrl})`);
       }
     });
 
-    // ─── WebSocket upgrade handling ───
-    // Codex uses WebSocket for its /responses endpoint.
-    // We proxy the WebSocket connection to the upstream and intercept messages for logging.
-    server.on('upgrade', (clientReq, clientSocket, clientHead) => {
-      const { fullUrl: httpUrl, originalBaseUrl } = buildUpstreamUrl(clientReq.url);
-      const startTime = Date.now();
-
-      if (process.env.CXV_DEBUG) console.error(`[CX-Proxy WS] UPGRADE ${clientReq.url} → ${originalBaseUrl}`);
-
-      // Build upstream URL
-      let upstreamUrl;
+    // ─── WebSocket upgrade handling: REFUSE to force HTTP/SSE fallback ───
+    // Codex's built-in openai provider prefers a Responses-over-WebSocket
+    // transport and only falls back to HTTP/SSE when the WS attempt fails. A
+    // cleartext logging proxy can only observe the HTTP path, so we deliberately
+    // refuse the upgrade with a well-formed non-101 response (not a bare socket
+    // reset, which can read as a transient network error and trigger a retry
+    // loop). Codex then downgrades to HTTP/SSE, which we log normally.
+    server.on('upgrade', (clientReq, clientSocket) => {
+      if (process.env.CXV_DEBUG) console.error(`[CX-Proxy WS] refusing upgrade ${clientReq.url} → forcing HTTP/SSE fallback`);
       try {
-        upstreamUrl = new URL(httpUrl);
-      } catch (err) {
-        if (process.env.CXV_DEBUG) console.error('[CX-Proxy WS] Invalid upstream URL:', httpUrl);
-        clientSocket.destroy();
-        return;
+        clientSocket.write('HTTP/1.1 426 Upgrade Required\r\nConnection: close\r\nContent-Length: 0\r\n\r\n');
+        clientSocket.end();
+      } catch {
+        try { clientSocket.destroy(); } catch { }
       }
-
-      const isHttps = upstreamUrl.protocol === 'https:';
-      const requestFn = isHttps ? httpsRequest : httpRequest;
-
-      // Forward all headers except host
-      const headers = { ...clientReq.headers };
-      headers.host = upstreamUrl.host;
-
-      const proxyReq = requestFn({
-        hostname: upstreamUrl.hostname,
-        port: upstreamUrl.port || (isHttps ? 443 : 80),
-        path: upstreamUrl.pathname + upstreamUrl.search,
-        method: 'GET',
-        headers,
-      });
-
-      proxyReq.on('upgrade', (proxyRes, proxySocket, proxyHead) => {
-        if (process.env.CXV_DEBUG) console.error(`[CX-Proxy WS] Connected to upstream ${upstreamUrl.host}`);
-
-        // Send 101 response back to client
-        let response = `HTTP/1.1 101 ${proxyRes.statusMessage || 'Switching Protocols'}\r\n`;
-        const rawHeaders = proxyRes.rawHeaders;
-        for (let i = 0; i < rawHeaders.length; i += 2) {
-          response += `${rawHeaders[i]}: ${rawHeaders[i + 1]}\r\n`;
-        }
-        response += '\r\n';
-
-        clientSocket.write(response);
-        if (proxyHead.length > 0) clientSocket.write(proxyHead);
-        if (clientHead.length > 0) proxySocket.write(clientHead);
-
-        const wsUrl = httpUrl.replace(/^http/, 'ws');
-
-        // Intercept data for logging (non-blocking, best-effort)
-        clientSocket.on('data', (data) => {
-          try {
-            const msgs = parseWsFrames(data);
-            if (msgs.length > 0) logWsEntry(wsUrl, 'send', msgs, startTime);
-          } catch {}
-          // Forward to upstream (socket.pipe handles this, but we log before pipe)
-        });
-
-        proxySocket.on('data', (data) => {
-          try {
-            const msgs = parseWsFrames(data);
-            if (msgs.length > 0) logWsEntry(wsUrl, 'recv', msgs, startTime);
-          } catch {}
-        });
-
-        // Pipe bidirectionally
-        proxySocket.pipe(clientSocket);
-        clientSocket.pipe(proxySocket);
-
-        // Handle errors and close
-        proxySocket.on('error', (err) => {
-          if (process.env.CXV_DEBUG) console.error('[CX-Proxy WS] Upstream socket error:', err.message);
-          clientSocket.destroy();
-        });
-        clientSocket.on('error', (err) => {
-          if (process.env.CXV_DEBUG) console.error('[CX-Proxy WS] Client socket error:', err.message);
-          proxySocket.destroy();
-        });
-        proxySocket.on('close', () => clientSocket.destroy());
-        clientSocket.on('close', () => proxySocket.destroy());
-      });
-
-      // Handle non-upgrade response (e.g. 401, 403)
-      proxyReq.on('response', (proxyRes) => {
-        if (process.env.CXV_DEBUG) {
-          console.error(`[CX-Proxy WS] Non-upgrade response: ${proxyRes.statusCode}`);
-        }
-        // Forward the HTTP response to the client socket
-        let responseHead = `HTTP/1.1 ${proxyRes.statusCode} ${proxyRes.statusMessage}\r\n`;
-        const rawHeaders = proxyRes.rawHeaders;
-        for (let i = 0; i < rawHeaders.length; i += 2) {
-          responseHead += `${rawHeaders[i]}: ${rawHeaders[i + 1]}\r\n`;
-        }
-        responseHead += '\r\n';
-        clientSocket.write(responseHead);
-        proxyRes.pipe(clientSocket);
-      });
-
-      proxyReq.on('error', (err) => {
-        if (process.env.CXV_DEBUG) console.error('[CX-Proxy WS] Proxy request error:', err.message);
-        clientSocket.destroy();
-      });
-
-      proxyReq.end();
     });
 
+    // Store server reference for stopProxy()
+    _proxyServer = server;
+
     // Start on random port
     server.listen(0, '127.0.0.1', () => {
       const address = server.address();
+      _proxyOwnPort = address.port;
       resolve(address.port);
     });
 
     server.on('error', (err) => {
+      _proxyServer = null;
       reject(err);
     });
-  });
+
+    server.on('close', () => {
+      _proxyServer = null;
+    });
+  }));
 }

package/pty-manager.js

@@ -24,7 +24,7 @@ let _ptyImportForTests = null;
 let outputHistoryPath = null;
 
 function ensureOutputHistory({ reset = false } = {}) {
-  const historyDir = join(homedir(), '.codex', 'cx-viewer', 'runtime');
+  const historyDir = process.env.CXV_RUNTIME_DIR || join(homedir(), '.codex', 'cx-viewer', 'runtime');
   mkdirSync(historyDir, { recursive: true });
   if (reset || !outputHistoryPath) {
     outputHistoryPath = join(historyDir, `terminal-history-${Date.now()}.log`);
@@ -36,6 +36,22 @@ export function _setPtyImportForTests(fn) {
   _ptyImportForTests = fn;
 }
 
+export function _resetPtyManagerForTests() {
+  killPty();
+  dataListeners = [];
+  exitListeners = [];
+  lastExitCode = null;
+  outputBuffer = '';
+  currentWorkspacePath = null;
+  lastWorkspacePath = null;
+  lastPtyCols = 120;
+  lastPtyRows = 30;
+  batchBuffer = '';
+  batchScheduled = false;
+  _ptyImportForTests = null;
+  outputHistoryPath = null;
+}
+
 async function getPty() {
   if (typeof _ptyImportForTests === 'function') {
     return _ptyImportForTests();

package/public/voice-packs/default/pack.json

@@ -0,0 +1,24 @@
+{
+  "name": "default-butler",
+  "displayName": "Butler (Default)",
+  "placeholder": false,
+  "events": {
+    "planApproval": {
+      "file": "The_plan_awaits_your_approval_sir.MP3",
+      "size": 52712
+    },
+    "askQuestion": {
+      "file": "A_choice_for_your_consideration_sir.MP3",
+      "size": 60236
+    },
+    "turnEnd": {
+      "file": "It_is_done_sir.MP3",
+      "size": 45816
+    }
+  },
+  "voiceLines": {
+    "planApproval": "The plan awaits your approval, sir.",
+    "askQuestion": "A choice for your consideration, sir.",
+    "turnEnd": "It is done, sir."
+  }
+}

package/public/voice-packs/sanguo/pack.json

@@ -0,0 +1,24 @@
+{
+  "name": "sanguo",
+  "displayName": "三国 (Sanguo)",
+  "placeholder": false,
+  "events": {
+    "planApproval": {
+      "file": "plan.MP3",
+      "size": 67759
+    },
+    "askQuestion": {
+      "file": "ask.MP3",
+      "size": 75282
+    },
+    "turnEnd": {
+      "file": "end.MP3",
+      "size": 70894
+    }
+  },
+  "voiceLines": {
+    "planApproval": "请陛下御览。",
+    "askQuestion": "请陛下圣裁。",
+    "turnEnd": "臣已办妥。"
+  }
+}