@carjms/codexswitch 0.4.0 → 0.6.0

package/README.ko.md

@@ -205,7 +205,8 @@ cxs list                # 계정별 5h/week 사용량 % 확인
 | `cxs add-key <이름> [키]` | OpenAI API 키 계정 등록 (키 생략 시 `$OPENAI_API_KEY` 사용) |
 | `cxs list` | 계정 목록: 활성 표시, 이메일, 플랜, 우선순위, 한도 상태, 사용량 % |
 | `cxs usage [이름]` | 계정별 사용량 대시보드: 5시간/주간 게이지 바, 리셋 카운트다운, 다음 로테이션 계정 (별칭: `status`) |
-| `cxs watch` | 실시간 대시보드 — 5초마다 자동 갱신 + 최근 활동 표시 (q로 종료) |
+| `cxs chat` | **대화형 입력창 (Claude Code 스타일)**: 매 턴이 로테이션을 거치고 같은 codex 세션을 이어가므로, 계정이 바뀌어도 대화가 유지됨. 내부 명령: `/usage /use /next /model /new /quit` |
+| `cxs watch` | 실시간 인터랙티브 대시보드 — 5초마다 갱신; 키: `↑/↓` 선택, `s` 전환, `e` 활성/비활성, `p` 프로브, `q` 종료 |
 | `cxs probe [이름]` | 계정마다 최소 요청 1회를 보내 사용량 게이지 워밍업 (토큰 소량 소모) |
 | `cxs log [개수]` | 최근 활동 기록: 계정 전환, 한도 도달, 로테이션, 프로브 |
 | `cxs use <이름>` | 활성 계정 전환 |
@@ -222,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

@@ -207,7 +207,8 @@ cxs list                # per-account 5h/week usage columns
 | `cxs add-key <name> [key]` | Register an OpenAI API-key account (falls back to `$OPENAI_API_KEY`) |
 | `cxs list` | List accounts: active marker, email, plan, priority, limit status, usage % |
 | `cxs usage [name]` | Per-account usage dashboard: 5h/weekly gauge bars, reset countdowns, next rotation pick (alias: `status`) |
-| `cxs watch` | Live dashboard — auto-refreshes every 5s with recent activity (q to quit) |
+| `cxs chat` | **Interactive prompt loop (Claude Code-style)**: each turn runs through rotation and resumes the same codex session, so the conversation survives account switches. Slash commands inside: `/usage /use /next /model /new /quit` |
+| `cxs watch` | Live interactive dashboard — refreshes every 5s; keys: `↑/↓` select, `s` switch, `e` enable/disable, `p` probe, `q` quit |
 | `cxs probe [name]` | Warm up the usage gauges with one minimal request per account (costs a few tokens) |
 | `cxs log [count]` | Recent activity: account switches, limits hit, rotations, probes |
 | `cxs use <name>` | Switch the active account |
@@ -224,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.4.0",
+  "version": "0.6.0",
   "description": "Multi-account manager for OpenAI Codex CLI with quota-based rotation (inspired by KarpelesLab/teamclaude)",
   "license": "MIT",
   "repository": {

package/src/cli.js

@@ -34,6 +34,10 @@ Accounts
   clear-limit <name>      forget a recorded rate-limit for an account
 
 Running codex
+  chat                    interactive prompt loop (Claude Code-style): each turn
+                          runs through rotation and resumes the same session,
+                          so the conversation survives account switches
+                          (/usage /use /next /model /new /quit inside)
   run [name] [args...]    run codex as <name> (or active account) in an isolated
                           per-account CODEX_HOME; config/sessions are shared
   exec [args...]          run "codex exec ..." and auto-rotate through accounts in
@@ -41,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
@@ -360,47 +367,54 @@ function cmdModel(args) {
   out(`default model set to "${meta.model}" (applied to run/exec)`);
 }
 
-// Per-account usage dashboard: gauge bars for the 5h / weekly windows with
-// reset countdowns, based on what codex recorded in its session files.
-function cmdUsage(args) {
-  const meta = store.loadMeta();
-  let accounts = store.listAccounts();
-  if (args[0]) {
-    accounts = accounts.filter((a) => a.name === args[0]);
-    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
-  }
-  if (accounts.length === 0) {
-    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
-    return;
-  }
+// Render the per-account usage view (gauge bars for the 5h / weekly windows
+// with reset countdowns). `cursor` marks the selected row in watch mode.
+function usageLines(accounts, meta, { cursor = -1 } = {}) {
   const now = Date.now();
+  const lines = [];
   const bar = (pct, threshold) => {
     const width = 20;
     const filled = Math.max(0, Math.min(width, Math.round((pct / 100) * width)));
     const paint = pct >= threshold ? ui.red : pct >= 70 ? ui.yellow : ui.green;
     return `[${paint('█'.repeat(filled))}${ui.dim('░'.repeat(width - filled))}]`;
   };
-  const line = (label, win, threshold) => {
+  const gauge = (label, win, threshold) => {
     if (!win || typeof win.pct !== 'number') return `  ${label} ${ui.dim('no data')}`;
     const pct = Math.round(win.pct);
     const reset = win.resetAt && win.resetAt > now ? ` resets in ${fmtRemaining(win.resetAt)}` : '';
     const overMark = win.pct >= threshold ? ` ${ui.red(`≥ threshold ${threshold}%`)}` : '';
     return `  ${label} ${bar(win.pct, threshold)} ${String(pct).padStart(3)}%${ui.dim(reset)}${overMark}`;
   };
-  for (const a of accounts) {
+  accounts.forEach((a, i) => {
+    const sel = i === cursor ? ui.cyan('▶') : ' ';
     const mark = a.active ? ui.green('●') : ' ';
     const state = a.disabled ? ui.red(' [disabled]') : a.limitedUntil && a.limitedUntil > now ? ui.yellow(` [limited ${fmtRemaining(a.limitedUntil)}]`) : '';
-    out(`${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
+    lines.push(`${cursor >= 0 ? sel : ''}${mark} ${ui.bold(a.name)}${ui.dim(` (${a.plan || a.email || '-'})`)}${state}`);
     if (!a.usage) {
-      out(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
+      lines.push(ui.dim('  no usage data yet — codex records it during runs (try "codexswitch run" once)'));
     } else {
-      out(line('5h    ', a.usage.p5h, meta.threshold5h));
-      out(line('weekly', a.usage.weekly, meta.thresholdWeekly));
-      if (a.usage.at) out(ui.dim(`  measured ${fmtDate(a.usage.at)}`));
+      lines.push(gauge('5h    ', a.usage.p5h, meta.threshold5h));
+      lines.push(gauge('weekly', a.usage.weekly, meta.thresholdWeekly));
+      if (a.usage.at) lines.push(ui.dim(`  measured ${fmtDate(a.usage.at)}`));
     }
-  }
+  });
   const next = store.pickAccount();
-  out(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+  lines.push(ui.dim(`\nrotation would pick: ${next ? next.name : '(none usable)'} · threshold 5h ${meta.threshold5h}% / weekly ${meta.thresholdWeekly}%`));
+  return lines;
+}
+
+function cmdUsage(args) {
+  const meta = store.loadMeta();
+  let accounts = store.listAccounts();
+  if (args[0]) {
+    accounts = accounts.filter((a) => a.name === args[0]);
+    if (accounts.length === 0) throw new Error(`no such account: ${args[0]}`);
+  }
+  if (accounts.length === 0) {
+    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
+    return;
+  }
+  for (const l of usageLines(accounts, meta)) out(l);
 }
 
 // Warm up quota measurements: send a minimal request per account so the
@@ -417,32 +431,38 @@ async function cmdProbe(args) {
   out(ui.info(ui.dim(`probing ${accounts.length} account(s) with a minimal request...`)));
   let failures = 0;
   for (const a of accounts) {
-    const startTs = Date.now();
-    const res = await runner.runCodex(
-      a.name,
-      ['exec', ...buildExecArgs(['Reply with exactly: ok'], meta)],
-      { capture: true, silent: true }
-    );
-    const usage = runner.recordUsage(a.name, res.profile, startTs);
-    if (res.code !== 0) {
-      failures++;
-      const why = runner.looksAuthFailed(res.output)
-        ? `login revoked — fix with "codexswitch login ${a.name}"`
-        : runner.looksRateLimited(res.output, meta.limitPatterns)
-          ? 'rate limited'
-          : `exit ${res.code}`;
-      out(ui.fail(`${a.name}: ${why}`));
-      store.logEvent('probe', `${a.name} failed: ${why}`);
-    } else if (usage && usage.p5h) {
-      out(ui.ok(`${a.name}: 5h ${Math.round(usage.p5h.pct)}%${usage.weekly ? ` / weekly ${Math.round(usage.weekly.pct)}%` : ''}`));
-      store.logEvent('probe', `${a.name} measured`);
-    } else {
-      out(ui.warn(`${a.name}: reachable, but codex reported no usage data`));
-    }
+    const line = await probeOne(a, meta);
+    out(line.text);
+    if (!line.ok) failures++;
   }
   return failures > 0 ? 1 : 0;
 }
 
+// Probe a single account; returns a printable result line.
+async function probeOne(a, meta) {
+  const startTs = Date.now();
+  const res = await runner.runCodex(
+    a.name,
+    ['exec', ...buildExecArgs(['Reply with exactly: ok'], meta)],
+    { capture: true, silent: true }
+  );
+  const usage = runner.recordUsage(a.name, res.profile, startTs);
+  if (res.code !== 0) {
+    const why = runner.looksAuthFailed(res.output)
+      ? `login revoked — fix with "codexswitch login ${a.name}"`
+      : runner.looksRateLimited(res.output, meta.limitPatterns)
+        ? 'rate limited'
+        : `exit ${res.code}`;
+    store.logEvent('probe', `${a.name} failed: ${why}`);
+    return { ok: false, text: ui.fail(`${a.name}: ${why}`) };
+  }
+  store.logEvent('probe', `${a.name} measured`);
+  if (usage && usage.p5h) {
+    return { ok: true, text: ui.ok(`${a.name}: 5h ${Math.round(usage.p5h.pct)}%${usage.weekly ? ` / weekly ${Math.round(usage.weekly.pct)}%` : ''}`) };
+  }
+  return { ok: true, text: ui.warn(`${a.name}: reachable, but codex reported no usage data`) };
+}
+
 function cmdLog(args) {
   const count = args[0] ? parseInt(args[0], 10) : 20;
   if (Number.isNaN(count) || count < 1) throw new Error('usage: codexswitch log [count]');
@@ -458,35 +478,81 @@ function cmdLog(args) {
   }
 }
 
-// Live dashboard: re-renders the usage view every few seconds until "q".
+// Live interactive dashboard: usage gauges + recent activity, refreshed
+// every 5s. Keyboard: up/down select, s switch, e enable/disable, p probe,
+// r refresh, q quit.
 async function cmdWatch() {
   if (!process.stdout.isTTY) {
     cmdUsage([]);
     return 0;
   }
+  let cursor = 0;
+  let message = '';
+  let busy = false;
   const render = () => {
+    const meta = store.loadMeta();
+    const accounts = store.listAccounts();
+    if (cursor >= accounts.length) cursor = Math.max(0, accounts.length - 1);
     process.stdout.write('\x1b[2J\x1b[H');
-    out(`${ui.bold('codexswitch watch')}${ui.dim(`  ${new Date().toLocaleTimeString()} · refreshes every 5s · q to quit`)}\n`);
-    cmdUsage([]);
-    const events = store.readEvents(5);
+    out(`${ui.bold('codexswitch watch')}${ui.dim(`  ${new Date().toLocaleTimeString()} \u00b7 refreshes every 5s`)}\n`);
+    if (accounts.length === 0) {
+      out('no accounts yet \u2014 add one with "codexswitch login"');
+    } else {
+      for (const l of usageLines(accounts, meta, { cursor })) out(l);
+    }
+    const events = store.readEvents(4);
     if (events.length > 0) {
       out(ui.dim('\nrecent activity:'));
       for (const e of events) out(ui.dim(`  ${e.at.replace('T', ' ').slice(11, 19)}  ${e.type}: ${e.message}`));
     }
+    out(`\n${ui.dim('keys:')} ${ui.cyan('\u2191/\u2193')} select  ${ui.cyan('s')} switch  ${ui.cyan('e')} enable/disable  ${ui.cyan('p')} probe  ${ui.cyan('r')} refresh  ${ui.cyan('q')} quit`);
+    if (message) out(message);
   };
   render();
-  const timer = setInterval(render, 5000);
+  const timer = setInterval(() => {
+    if (!busy) render();
+  }, 5000);
   await new Promise((resolve) => {
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
     process.stdin.resume();
-    process.stdin.on('data', (b) => {
+    process.stdin.on('data', async (b) => {
+      if (busy) return;
       const s = b.toString();
+      const accounts = store.listAccounts();
+      const selected = accounts[cursor];
       if (s === 'q' || s === '\u0003') {
         clearInterval(timer);
         if (process.stdin.isTTY) process.stdin.setRawMode(false);
         process.stdin.pause();
         resolve();
+        return;
       }
+      if (s === '\x1b[A' || s === 'k') cursor = Math.max(0, cursor - 1);
+      else if (s === '\x1b[B' || s === 'j') cursor = Math.min(accounts.length - 1, cursor + 1);
+      else if (s === 'r') message = '';
+      else if (s === 's' && selected) {
+        try {
+          cmdUse([selected.name]);
+          message = ui.ok(`switched to "${selected.name}"`);
+        } catch (e) {
+          message = ui.fail(e.message);
+        }
+      } else if (s === 'e' && selected) {
+        setFlag(selected.name, { disabled: !selected.disabled });
+        message = selected.disabled ? ui.ok(`enabled "${selected.name}"`) : ui.warn(`disabled "${selected.name}"`);
+      } else if (s === 'p' && selected) {
+        busy = true;
+        message = ui.dim(`probing "${selected.name}"...`);
+        render();
+        try {
+          const result = await probeOne(selected, store.loadMeta());
+          message = result.text;
+        } catch (e) {
+          message = ui.fail(e.message);
+        }
+        busy = false;
+      }
+      render();
     });
   });
   return 0;
@@ -575,7 +641,7 @@ function cmdNames() {
 }
 
 const COMMANDS =
-  'login import add-key list usage watch probe log 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) {
@@ -600,6 +666,18 @@ complete -F _codexswitch codexswitch cxs`;
 // non-git folders, and the configured default model — unless the user
 // already passed their own flags.
 function buildExecArgs(rest, meta) {
+  // "exec resume [--last|<id>] ..." — the subcommand and its target must
+  // stay in front; flags are injected after them.
+  if (rest[0] === 'resume') {
+    const head = ['resume'];
+    let i = 1;
+    if (rest[i] === '--last' || (rest[i] && /^[0-9a-f][0-9a-f-]{7,}$/i.test(rest[i]))) head.push(rest[i++]);
+    return [...head, ...injectExecFlags(rest.slice(i), meta)];
+  }
+  return injectExecFlags(rest, meta);
+}
+
+function injectExecFlags(rest, meta) {
   const args = [...rest];
   if (!args.includes('--skip-git-repo-check')) args.unshift('--skip-git-repo-check');
   const hasModel = args.some((a) => a === '-m' || a === '--model' || a.startsWith('--model='));
@@ -607,8 +685,49 @@ function buildExecArgs(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])) {
@@ -628,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;
 }
@@ -716,6 +835,79 @@ async function cmdExec(args) {
   return 2;
 }
 
+// Interactive chat: a Claude Code-style prompt loop on top of exec.
+// Every turn goes through the rotation engine, and turns 2+ resume the same
+// codex session — so the conversation continues even when the account under
+// it changes between (or during) turns.
+async function cmdChat() {
+  const readline = require('readline');
+  runner.assertCodexAvailable();
+  if (store.listAccounts().length === 0) {
+    throw new Error('no accounts — add one with "codexswitch login"');
+  }
+  const meta = store.loadMeta();
+  out(`${ui.bold('codexswitch chat')} ${ui.dim(`· model ${meta.model || '(codex default)'} · rotation on limits`)}`);
+  out(ui.dim('type a prompt, or /help for commands (/quit to exit)\n'));
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.setPrompt(ui.enabled ? `${ui.cyan('cxs')} ${ui.dim('›')} ` : 'cxs › ');
+  // Buffer lines ourselves: input can arrive while a turn is still running
+  // (type-ahead, piped input) and must not be dropped or hit a closed rl.
+  const pending = [];
+  const waiters = [];
+  let closed = false;
+  rl.on('line', (l) => {
+    const w = waiters.shift();
+    if (w) w(l);
+    else pending.push(l);
+  });
+  rl.on('close', () => {
+    closed = true;
+    for (const w of waiters.splice(0)) w(null);
+  });
+  const ask = () => {
+    if (pending.length > 0) return Promise.resolve(pending.shift());
+    if (closed) return Promise.resolve(null);
+    rl.prompt();
+    return new Promise((resolve) => waiters.push(resolve));
+  };
+
+  let inSession = false;
+  for (;;) {
+    const raw = await ask();
+    if (raw == null) break; // EOF (Ctrl-D or piped input ended)
+    const line = raw.trim();
+    if (!line) continue;
+
+    if (line[0] === '/') {
+      const [cmd, ...rest] = line.slice(1).split(/\s+/);
+      try {
+        if (cmd === 'quit' || cmd === 'exit' || cmd === 'q') break;
+        else if (cmd === 'help')
+          out(ui.dim('/usage /list /use <name> /next /model [m] /new (fresh session) /quit'));
+        else if (cmd === 'usage') cmdUsage([]);
+        else if (cmd === 'list') cmdList();
+        else if (cmd === 'use') cmdUse(rest);
+        else if (cmd === 'next') cmdNext();
+        else if (cmd === 'model') cmdModel(rest);
+        else if (cmd === 'new') {
+          inSession = false;
+          out(ui.ok('starting a fresh session on the next prompt'));
+        } else out(ui.warn(`unknown command /${cmd} — try /help`));
+      } catch (e) {
+        out(ui.fail(e.message));
+      }
+      continue;
+    }
+
+    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'));
+  }
+  rl.close();
+  return 0;
+}
+
 function warnIfOverThreshold(name) {
   const meta = store.loadMeta();
   const account = store.listAccounts().find((a) => a.name === name);
@@ -817,6 +1009,12 @@ async function main(argv) {
       return cmdRun(args);
     case 'exec':
       return cmdExec(args);
+    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,