@carjms/codexswitch 0.5.0 → 0.6.1

package/README.ko.md

@@ -223,6 +223,8 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs restore <파일>` | 백업 파일에서 계정 복원 (다른 PC 이전용) |
 | `cxs completion <bash\|zsh>` | 셸 자동완성 스크립트 출력 |
 | `cxs <그 외 명령>` | codex로 그대로 전달 — `cxs resume`, `cxs goal ...`, `cxs apply` 등 codex의 모든 명령을 관리 계정으로 바로 사용 가능 |
+| `cxs server [--port N]` | **실험 기능** 로컬 프록시(teamclaude 방식): 요청마다 인증을 교체하고, 429는 다음 계정으로 재시도, 응답 헤더에서 사용량을 실시간 수집 |
+| `cxs run --proxy [인자]` | codex를 로컬 프록시 경유로 실행 — 대화형 세션 안에서도 요청 단위 로테이션 |
 | `cxs remove <이름>` | 계정 삭제 |
 | `cxs rename <옛이름> <새이름>` | 계정 이름 변경 |
 | `cxs disable / enable <이름>` | 로테이션에서 임시 제외 / 복귀 |

package/README.md

@@ -225,6 +225,8 @@ cxs list                # per-account 5h/week usage columns
 | `cxs restore <file>` | Restore accounts from a backup (for moving machines) |
 | `cxs completion <bash\|zsh>` | Print a shell completion script |
 | `cxs <anything else>` | Forwarded to codex under the managed account — `cxs resume`, `cxs goal ...`, `cxs apply` all work like their codex counterparts |
+| `cxs server [--port N]` | **EXPERIMENTAL** local proxy (teamclaude-style): swaps credentials per request, retries 429s on the next account, and feeds usage gauges live from response headers |
+| `cxs run --proxy [args]` | Run codex routed through the local proxy — per-request rotation even inside interactive sessions |
 | `cxs remove <name>` | Delete an account |
 | `cxs rename <old> <new>` | Rename an account |
 | `cxs disable / enable <name>` | Temporarily exclude from / restore to rotation |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carjms/codexswitch",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Multi-account manager for OpenAI Codex CLI with quota-based rotation (inspired by KarpelesLab/teamclaude)",
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -45,6 +45,9 @@ Running codex
                           the same session (--skip-git-repo-check added automatically)
       -a, --account <n>   start exec with a specific account
       --no-resume         restart the prompt instead of resuming on rotation
+  server [--port N]       EXPERIMENTAL local proxy: per-request account
+                          rotation with live usage from response headers
+  run --proxy [args...]   run codex routed through the local proxy
 
 Settings
   model [name|default]    show/set the default model injected into run/exec
@@ -638,7 +641,7 @@ function cmdNames() {
 }
 
 const COMMANDS =
-  'login import add-key list usage watch probe log chat use current next run exec order model remove rename ' +
+  'login import add-key list usage watch probe log chat server use current next run exec order model remove rename ' +
   'enable disable priority clear-limit cooldown threshold patterns export restore sync completion help';
 
 function cmdCompletion(args) {
@@ -682,8 +685,49 @@ function injectExecFlags(rest, meta) {
   return args;
 }
 
+// EXPERIMENTAL: foreground proxy server for per-request rotation.
+async function cmdServer(args) {
+  const proxy = require('./proxy.js');
+  let port = proxy.DEFAULT_PORT;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port' || args[i] === '-p') port = parseInt(args[++i], 10);
+  }
+  if (Number.isNaN(port) || port < 1 || port > 65535) throw new Error('invalid port');
+  if (store.listAccounts().length === 0) throw new Error('no accounts — add one with "codexswitch login"');
+  const log = (type, msg) => {
+    const paint = { rotate: ui.warn, error: ui.fail, ws: ui.info, req: (s) => ui.dim(`  ${s}`) }[type] || ui.info;
+    out(paint(msg));
+  };
+  const server = await proxy.startServer({ port, log });
+  const stateFile = path.join(store.paths().home, 'proxy.json');
+  writeJSONAtomic(stateFile, { port, pid: process.pid, startedAt: Date.now() });
+  out(`${ui.bold('codexswitch proxy')} ${ui.yellow('(experimental)')} listening on ${ui.cyan(`http://127.0.0.1:${port}`)}`);
+  out(ui.dim('per-request account rotation · 429 retries on the next account · live usage from response headers'));
+  out(ui.dim(`use it with:  codexswitch run --proxy    (Ctrl-C to stop)\n`));
+  await new Promise((resolve) => {
+    const stop = () => {
+      server.close();
+      fs.rmSync(stateFile, { force: true });
+      resolve();
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+  });
+  return 0;
+}
+
 async function cmdRun(args) {
   store.syncBack(); // pick up tokens refreshed by plain codex before overlaying
+  let proxyPort = null;
+  if (args.includes('--proxy')) {
+    const proxy = require('./proxy.js');
+    args = args.filter((a) => a !== '--proxy');
+    const state = readJSONSafe(path.join(store.paths().home, 'proxy.json'));
+    proxyPort = (state && state.port) || proxy.DEFAULT_PORT;
+    if (!(await proxy.ping(proxyPort))) {
+      throw new Error(`no proxy on port ${proxyPort} — start it first with "codexswitch server"`);
+    }
+  }
   let name = null;
   let rest = args;
   if (args[0] && store.accountExists(args[0])) {
@@ -703,9 +747,9 @@ async function cmdRun(args) {
   } else if (meta.model && rest.length === 0) {
     rest = ['-m', meta.model];
   }
-  out(ui.info(`running codex as ${ui.bold(`"${name}"`)}`));
+  out(ui.info(`running codex as ${ui.bold(`"${name}"`)}${proxyPort ? ui.dim(` via proxy :${proxyPort}`) : ''}`));
   const startTs = Date.now();
-  const res = await runner.runCodex(name, rest);
+  const res = await runner.runCodex(name, rest, { proxyPort });
   runner.recordUsage(name, res.profile, startTs);
   return res.code;
 }
@@ -728,6 +772,14 @@ async function cmdExec(args) {
   if (explicit && !store.accountExists(explicit)) throw new Error(`no such account: ${explicit}`);
   if (rest[0] === 'resume') allowResume = false; // user drives resume themselves
 
+  // A prompt like "- item one ..." would be parsed as an option by codex;
+  // if the last argument starts with "-" but contains whitespace it can only
+  // be a prompt, so protect it with a "--" separator.
+  if (!rest.includes('--')) {
+    const last = rest[rest.length - 1];
+    if (last && /^-/.test(last) && /\s/.test(last)) rest.splice(rest.length - 1, 0, '--');
+  }
+
   store.syncBack(); // pick up tokens refreshed by plain codex before overlaying
   const meta = store.loadMeta();
   const total = store.listAccounts().length;
@@ -751,7 +803,7 @@ async function cmdExec(args) {
     // On rotation, continue the same session with the next account instead
     // of restarting the whole prompt — the session files are shared.
     const codexArgs = useResume
-      ? ['exec', 'resume', '--last', ...buildExecArgs([], meta), RESUME_PROMPT]
+      ? ['exec', 'resume', '--last', ...buildExecArgs([], meta), '--', RESUME_PROMPT]
       : ['exec', ...buildExecArgs(rest, meta)];
     const startTs = Date.now();
     const res = await runner.runCodex(name, codexArgs, { capture: true });
@@ -856,7 +908,9 @@ async function cmdChat() {
       continue;
     }
 
-    const code = await cmdExec(inSession ? ['resume', '--last', line] : [line]);
+    // "--" marks the prompt as positional so lines starting with "-" are
+    // never parsed as codex options.
+    const code = await cmdExec(inSession ? ['resume', '--last', '--', line] : ['--', line]);
     if (code === 0) inSession = true;
     else if (code === 2) out(ui.fail('all accounts exhausted — try again later or /use a specific account'));
   }
@@ -968,6 +1022,9 @@ async function main(argv) {
     case 'chat':
     case 'repl':
       return cmdChat();
+    case 'server':
+    case 'proxy':
+      return cmdServer(args);
     default:
       // Forward everything else to codex under the managed account, so
       // codexswitch is a drop-in replacement: "cxs goal", "cxs resume", ...

package/src/proxy.js

@@ -0,0 +1,220 @@
+'use strict';
+
+// EXPERIMENTAL local proxy (teamclaude-style): codex is pointed at
+// http://127.0.0.1:<port>/backend-api via chatgpt_base_url, and every
+// request gets its Authorization / chatgpt-account-id swapped to the
+// account chosen by the rotation rules — so even interactive codex
+// sessions rotate per request. 429 responses retry on the next account.
+// Rate-limit response headers (x-codex-*) feed the usage gauges live.
+
+const http = require('http');
+const https = require('https');
+const net = require('net');
+const tls = require('tls');
+const { URL } = require('url');
+const store = require('./store.js');
+
+const DEFAULT_PORT = 8437;
+const MAX_BODY = 32 * 1024 * 1024;
+
+function upstreamBase() {
+  return new URL(process.env.CODEX_SWITCH_UPSTREAM || 'https://chatgpt.com');
+}
+
+function pickAuth(exclude = []) {
+  const acct = store.pickAccount(exclude);
+  if (!acct) return null;
+  const auth = store.readAccountAuth(acct.name);
+  const tokens = auth.tokens || {};
+  return {
+    name: acct.name,
+    accountId: tokens.account_id || null,
+    token: tokens.access_token || auth.OPENAI_API_KEY || '',
+  };
+}
+
+// Parse x-codex-(primary|secondary)-* response headers into a usage
+// snapshot compatible with the session-file scanner.
+function usageFromHeaders(headers) {
+  const wins = { primary: {}, secondary: {} };
+  let found = false;
+  for (const [key, value] of Object.entries(headers)) {
+    const m = /^x-codex-(primary|secondary)-(.+)$/i.exec(key);
+    if (!m) continue;
+    found = true;
+    wins[m[1].toLowerCase()][m[2].toLowerCase()] = Number(value);
+  }
+  if (!found) return null;
+  const at = Date.now();
+  const win = (w) => {
+    const pct = w['used-percent'] ?? w['used_percent'];
+    if (typeof pct !== 'number' || Number.isNaN(pct)) return null;
+    const resets = w['resets-in-seconds'] ?? w['reset-after-seconds'] ?? w['resets_in_seconds'];
+    return {
+      pct,
+      resetAt: typeof resets === 'number' && !Number.isNaN(resets) ? at + resets * 1000 : null,
+      windowMinutes: w['window-minutes'] ?? null,
+    };
+  };
+  const p5h = win(wins.primary);
+  const weekly = win(wins.secondary);
+  if (!p5h && !weekly) return null;
+  return { p5h, weekly, at };
+}
+
+function swapHeaders(headers, acct, host) {
+  const h = {};
+  for (const [k, v] of Object.entries(headers)) {
+    const lk = k.toLowerCase();
+    if (lk === 'host' || lk === 'content-length' || lk === 'connection') continue;
+    h[k] = v;
+  }
+  h.host = host;
+  h.authorization = `Bearer ${acct.token}`;
+  if (acct.accountId) h['chatgpt-account-id'] = acct.accountId;
+  return h;
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(new Error('request body too large'));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function forwardOnce(req, body, acct) {
+  return new Promise((resolve, reject) => {
+    const base = upstreamBase();
+    const mod = base.protocol === 'https:' ? https : http;
+    const up = mod.request(
+      {
+        hostname: base.hostname,
+        port: base.port || (base.protocol === 'https:' ? 443 : 80),
+        path: req.url,
+        method: req.method,
+        headers: { ...swapHeaders(req.headers, acct, base.host), 'content-length': body.length },
+      },
+      (upRes) => resolve(upRes)
+    );
+    up.on('error', reject);
+    up.end(body);
+  });
+}
+
+function startServer({ port = DEFAULT_PORT, log = () => {} } = {}) {
+  const server = http.createServer(async (req, res) => {
+    if (req.url === '/__codexswitch') {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, accounts: store.listAccounts().length }));
+      return;
+    }
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (e) {
+      res.writeHead(413).end(e.message);
+      return;
+    }
+    const meta = store.loadMeta();
+    const total = store.listAccounts().length;
+    const tried = [];
+    for (let attempt = 0; attempt < Math.max(1, total); attempt++) {
+      const acct = pickAuth(tried);
+      if (!acct) {
+        res.writeHead(503, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'codexswitch: no usable account' }));
+        return;
+      }
+      tried.push(acct.name);
+      let upRes;
+      try {
+        upRes = await forwardOnce(req, body, acct);
+      } catch (e) {
+        log('error', `${acct.name}: upstream ${e.message}`);
+        res.writeHead(502).end(`codexswitch: upstream error: ${e.message}`);
+        return;
+      }
+      const usage = usageFromHeaders(upRes.headers);
+      if (usage) store.saveUsage(acct.name, usage);
+      if (upRes.statusCode === 429 && tried.length < total) {
+        store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
+        store.logEvent('limit', `proxy: "${acct.name}" got 429 — rotating`);
+        log('rotate', `${acct.name} hit 429 -> trying next account`);
+        upRes.resume(); // discard
+        continue;
+      }
+      log('req', `${acct.name} ${req.method} ${req.url} -> ${upRes.statusCode}`);
+      res.writeHead(upRes.statusCode, upRes.headers);
+      upRes.pipe(res);
+      return;
+    }
+    res.writeHead(503).end('codexswitch: all accounts exhausted');
+  });
+
+  // WebSocket passthrough: swap auth on the handshake, then pipe raw bytes.
+  server.on('upgrade', (req, socket, head) => {
+    const acct = pickAuth();
+    if (!acct) {
+      socket.end('HTTP/1.1 503 Service Unavailable\r\n\r\n');
+      return;
+    }
+    const base = upstreamBase();
+    const isTls = base.protocol === 'https:';
+    const upPort = base.port || (isTls ? 443 : 80);
+    const upstream = isTls
+      ? tls.connect({ host: base.hostname, port: upPort, servername: base.hostname })
+      : net.connect({ host: base.hostname, port: upPort });
+    const onReady = () => {
+      const headers = swapHeaders(req.headers, acct, base.host);
+      headers.connection = 'Upgrade';
+      const lines = [`${req.method} ${req.url} HTTP/1.1`];
+      for (const [k, v] of Object.entries(headers)) lines.push(`${k}: ${v}`);
+      upstream.write(lines.join('\r\n') + '\r\n\r\n');
+      if (head && head.length) upstream.write(head);
+      upstream.pipe(socket);
+      socket.pipe(upstream);
+      log('ws', `${acct.name} ${req.url}`);
+      store.logEvent('exec', `proxy ws opened as "${acct.name}"`);
+    };
+    upstream.on(isTls ? 'secureConnect' : 'connect', onReady);
+    const drop = () => {
+      socket.destroy();
+      upstream.destroy();
+    };
+    upstream.on('error', drop);
+    socket.on('error', drop);
+  });
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => resolve(server));
+  });
+}
+
+// Is a codexswitch proxy answering on this port?
+function ping(port) {
+  return new Promise((resolve) => {
+    const req = http.get({ host: '127.0.0.1', port, path: '/__codexswitch', timeout: 1500 }, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+module.exports = { startServer, ping, DEFAULT_PORT, usageFromHeaders };

package/src/runner.js

@@ -60,9 +60,9 @@ function assertCodexAvailable() {
 // history are shared — except auth.json (per-account, copied from the store)
 // and sqlite databases (excluded: two codex processes writing the same
 // sqlite file through symlinks risks corruption; each profile keeps its own).
-function buildProfile(name) {
+function buildProfile(name, dirName = name) {
   const p = store.paths();
-  const profile = path.join(p.profilesDir, name);
+  const profile = path.join(p.profilesDir, dirName);
   ensureDir(profile);
 
   // Sessions must exist in the real CODEX_HOME before linking, so that every
@@ -109,6 +109,26 @@ function buildProfile(name) {
   return profile;
 }
 
+// Proxy-mode profile: like a normal overlay, but config.toml is a patched
+// copy pointing chatgpt_base_url at the local codexswitch proxy so every
+// codex request flows through it (and rotates per request).
+function buildProxyProfile(name, port) {
+  const p = store.paths();
+  const profile = buildProfile(name, `${name}.proxy`);
+  const cfgDest = path.join(profile, 'config.toml');
+  let cfg = '';
+  try {
+    cfg = fs.readFileSync(path.join(p.codexHome, 'config.toml'), 'utf8');
+  } catch {
+    /* no config yet */
+  }
+  cfg = cfg.replace(/^\s*chatgpt_base_url\s*=.*$/gm, '').trimEnd();
+  cfg += `\n\n# managed by codexswitch proxy mode\nchatgpt_base_url = "http://127.0.0.1:${port}/backend-api/"\n`;
+  fs.rmSync(cfgDest, { force: true });
+  fs.writeFileSync(cfgDest, cfg);
+  return profile;
+}
+
 function shareable(entry) {
   if (entry === 'auth.json') return false;
   if (/\.sqlite(-wal|-shm|-journal)?$/.test(entry)) return false;
@@ -165,9 +185,10 @@ function refreshCopy(target, dest) {
 // capture=false: interactive, stdio inherited. capture=true: stream output
 // through while also collecting it so the caller can detect limit errors.
 // silent=true (with capture): collect without echoing (used by probe).
-function runCodex(name, args, { capture = false, silent = false } = {}) {
+// proxyPort: route the run through the local codexswitch proxy.
+function runCodex(name, args, { capture = false, silent = false, proxyPort = null } = {}) {
   assertCodexAvailable();
-  const profile = buildProfile(name);
+  const profile = proxyPort ? buildProxyProfile(name, proxyPort) : buildProfile(name);
   const env = { ...process.env, CODEX_HOME: profile };
 
   return new Promise((resolve) => {
@@ -321,6 +342,7 @@ module.exports = {
   spawnCodexSync,
   assertCodexAvailable,
   buildProfile,
+  buildProxyProfile,
   runCodex,
   looksRateLimited,
   looksAuthFailed,