@carjms/codexswitch 0.6.3 → 0.7.0

package/src/proxy.js

@@ -16,6 +16,7 @@ const store = require('./store.js');
 
 const DEFAULT_PORT = 8437;
 const MAX_BODY = 32 * 1024 * 1024;
+const RATE_LIMIT_ABSORB_MAX_MS = 60000;
 
 function upstreamBase() {
   return new URL(process.env.CODEX_SWITCH_UPSTREAM || 'https://chatgpt.com');
@@ -62,6 +63,29 @@ function usageFromHeaders(headers) {
   return { p5h, weekly, at };
 }
 
+function retryAfterMs(headers, now = Date.now()) {
+  const value = headers['retry-after'];
+  if (value == null) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? null : Math.max(0, date - now);
+}
+
+// Inspired by teamclaude: a quota rejection should rotate immediately, while
+// a short per-minute throttle should stay on the same account to preserve its
+// prompt cache and avoid cascading the burst across every account.
+function classify429(headers, usage, meta) {
+  const rejected = Object.entries(headers).some(
+    ([key, value]) => /(?:codex|quota|limit).*(?:status|state)/i.test(key) && /rejected|exhausted|quota/i.test(String(value))
+  );
+  const overQuota = [
+    usage && usage.p5h && [usage.p5h.pct, meta.threshold5h],
+    usage && usage.weekly && [usage.weekly.pct, meta.thresholdWeekly],
+  ].some((pair) => pair && pair[0] >= pair[1]);
+  return rejected || overQuota ? 'quota' : 'rate';
+}
+
 function swapHeaders(headers, acct, host) {
   const h = {};
   for (const [k, v] of Object.entries(headers)) {
@@ -129,6 +153,7 @@ function startServer({ port = DEFAULT_PORT, log = () => {} } = {}) {
     const meta = store.loadMeta();
     const total = store.listAccounts().length;
     const tried = [];
+    const absorbed = new Set();
     for (let attempt = 0; attempt < Math.max(1, total); attempt++) {
       const acct = pickAuth(tried);
       if (!acct) {
@@ -147,12 +172,32 @@ function startServer({ port = DEFAULT_PORT, log = () => {} } = {}) {
       }
       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;
+      if (upRes.statusCode === 429) {
+        const kind = classify429(upRes.headers, usage, meta);
+        const retryMs = retryAfterMs(upRes.headers);
+        if (kind === 'rate') {
+          if (retryMs != null && retryMs <= RATE_LIMIT_ABSORB_MAX_MS && !absorbed.has(acct.name)) {
+            absorbed.add(acct.name);
+            log('rate', `${acct.name} throttled for ${Math.ceil(retryMs)}ms — retrying same account`);
+            upRes.resume();
+            await new Promise((resolve) => setTimeout(resolve, retryMs));
+            tried.pop();
+            attempt--;
+            continue;
+          }
+          const pauseMs = retryMs == null ? Math.min(meta.cooldownMinutes * 60000, RATE_LIMIT_ABSORB_MAX_MS) : retryMs;
+          store.markLimited(acct.name, Date.now() + pauseMs);
+          store.logEvent('limit', `proxy: "${acct.name}" temporarily throttled — not rotating`);
+          log('rate', `${acct.name} temporarily throttled — preserving account cache`);
+        } else if (tried.length < total) {
+          store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
+          store.logEvent('limit', `proxy: "${acct.name}" quota exhausted — rotating`);
+          log('rotate', `${acct.name} quota exhausted -> trying next account`);
+          upRes.resume();
+          continue;
+        } else {
+          store.markLimited(acct.name, Date.now() + meta.cooldownMinutes * 60000);
+        }
       }
       log('req', `${acct.name} ${req.method} ${req.url} -> ${upRes.statusCode}`);
       res.writeHead(upRes.statusCode, upRes.headers);
@@ -217,4 +262,4 @@ function ping(port) {
   });
 }
 
-module.exports = { startServer, ping, DEFAULT_PORT, usageFromHeaders };
+module.exports = { startServer, ping, DEFAULT_PORT, usageFromHeaders, retryAfterMs, classify429 };

package/src/store.js

@@ -19,6 +19,7 @@ function paths() {
     codexHome,
     accountsDir: path.join(home, 'accounts'),
     profilesDir: path.join(home, 'profiles'),
+    memoryDir: path.join(home, 'memory'),
     metaPath: path.join(home, 'meta.json'),
     authPath: path.join(codexHome, 'auth.json'),
   };
@@ -64,10 +65,80 @@ function readEvents(count = 20) {
   }
 }
 
+// Structured work history is separate from the operational activity log.
+// It intentionally contains user prompts, so the file is created private.
+function logRun(record) {
+  try {
+    ensureDir(paths().home);
+    fs.appendFileSync(path.join(paths().home, 'history.jsonl'), JSON.stringify(record) + '\n', { mode: 0o600 });
+  } catch {
+    /* history must never break an actual Codex run */
+  }
+}
+
+function readRuns(count = 20) {
+  try {
+    const lines = fs.readFileSync(path.join(paths().home, 'history.jsonl'), 'utf8').trim().split('\n');
+    return lines.slice(-count).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean).reverse();
+  } catch {
+    return [];
+  }
+}
+
+function findRun(id) {
+  const runs = readRuns(1000);
+  if (id === 'latest') return runs[0] || null;
+  return runs.find((run) => run.id === id || run.id.startsWith(id)) || null;
+}
+
 function saveMeta(meta) {
   writeJSONAtomic(paths().metaPath, meta);
 }
 
+function memoryPath(mode, accountName = null) {
+  const p = paths();
+  if (mode === 'shared') return path.join(p.memoryDir, 'shared.md');
+  if (mode === 'isolated') {
+    if (!accountName) throw new Error('isolated memory requires an account name');
+    // Reuse the account-name validation used for credential filenames.
+    accountPath(accountName);
+    return path.join(p.memoryDir, 'accounts', `${accountName}.md`);
+  }
+  return null;
+}
+
+function readMemory(mode, accountName = null) {
+  const file = memoryPath(mode, accountName);
+  if (!file) return '';
+  try {
+    // Bound prompt growth even if the file was edited externally.
+    const text = fs.readFileSync(file, 'utf8');
+    return text.length > 32768 ? text.slice(-32768) : text;
+  } catch {
+    return '';
+  }
+}
+
+function appendMemory(mode, accountName, text) {
+  const file = memoryPath(mode, accountName);
+  if (!file) throw new Error('memory is off — enable it with "codexswitch memory shared" or "memory isolated"');
+  const clean = String(text || '').trim();
+  if (!clean) throw new Error('memory text cannot be empty');
+  ensureDir(path.dirname(file));
+  if (!fs.existsSync(file)) {
+    const title = mode === 'shared' ? '# Shared Codex memory\n' : `# Memory for ${accountName}\n`;
+    fs.writeFileSync(file, `${title}\n`, { mode: 0o600 });
+  }
+  fs.appendFileSync(file, `- ${clean.replace(/\n/g, '\n  ')}\n`, { mode: 0o600 });
+  return file;
+}
+
 function accountPath(name) {
   // Unicode letters/digits are fine (names become filenames); block path
   // separators, traversal, and characters invalid on Windows filesystems.
@@ -268,10 +339,17 @@ module.exports = {
   nextAccount,
   logEvent,
   readEvents,
+  logRun,
+  readRuns,
+  findRun,
+  memoryPath,
+  readMemory,
+  appendMemory,
   ensureDirs() {
     const p = paths();
     ensureDir(p.home);
     ensureDir(p.accountsDir);
     ensureDir(p.profilesDir);
+    ensureDir(p.memoryDir);
   },
 };

package/src/util.js

@@ -89,11 +89,37 @@ function fmtRemaining(untilTs) {
   return h > 0 ? `${h}h${m}m` : `${m}m`;
 }
 
+// Terminal columns are not the same as JavaScript string length: Korean,
+// Japanese, Chinese and emoji commonly occupy two columns. Keeping this
+// small and dependency-free is sufficient for account names and table data.
+function displayWidth(value) {
+  const text = require('./ui.js').visible(String(value));
+  let width = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    // Combining marks and variation selectors do not advance the cursor.
+    if (/\p{Mark}/u.test(ch) || (cp >= 0xfe00 && cp <= 0xfe0f)) continue;
+    const wide =
+      cp >= 0x1100 &&
+      (cp <= 0x115f ||
+        cp === 0x2329 || cp === 0x232a ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe10 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd));
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+
 function table(rows, headers) {
-  const { visible, dim } = require('./ui.js');
+  const { dim } = require('./ui.js');
   const all = [headers, ...rows].map((r) => r.map((c) => String(c == null ? '-' : c)));
-  const widths = headers.map((_, i) => Math.max(...all.map((r) => visible(r[i]).length)));
-  const pad = (c, w) => c + ' '.repeat(Math.max(0, w - visible(c).length));
+  const widths = headers.map((_, i) => Math.max(...all.map((r) => displayWidth(r[i]))));
+  const pad = (c, w) => c + ' '.repeat(Math.max(0, w - displayWidth(c)));
   const line = (r) => r.map((c, i) => pad(c, widths[i])).join('  ').trimEnd();
   return [dim(line(all[0])), dim(line(widths.map((w) => '-'.repeat(w)))), ...all.slice(1).map(line)].join('\n');
 }
@@ -108,5 +134,6 @@ module.exports = {
   parseDurationMs,
   fmtDate,
   fmtRemaining,
+  displayWidth,
   table,
 };

package/src/welcome.js

@@ -0,0 +1,184 @@
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const store = require('./store.js');
+const ui = require('./ui.js');
+const { displayWidth, fmtRemaining } = require('./util.js');
+const pkg = require('../package.json');
+
+const MIN_WIDTH = 76;
+const MIN_HEIGHT = 22;
+
+function crop(value, width) {
+  const text = String(value == null ? '' : value);
+  if (displayWidth(text) <= width) return text;
+  let out = '';
+  for (const ch of text) {
+    if (displayWidth(out + ch + '…') > width) break;
+    out += ch;
+  }
+  return out + '…';
+}
+
+function fit(value, width) {
+  const text = crop(value, width);
+  return text + ' '.repeat(Math.max(0, width - displayWidth(text)));
+}
+
+function center(value, width) {
+  const text = crop(value, width);
+  const gap = Math.max(0, width - displayWidth(text));
+  return ' '.repeat(Math.floor(gap / 2)) + text + ' '.repeat(Math.ceil(gap / 2));
+}
+
+function percent(account) {
+  const win = account.usage && account.usage.p5h;
+  return win && typeof win.pct === 'number' ? `${Math.round(win.pct)}%` : '--';
+}
+
+function accountState(account, now = Date.now()) {
+  if (account.disabled) return 'disabled';
+  if (account.limitedUntil && account.limitedUntil > now) return `paused ${fmtRemaining(account.limitedUntil)}`;
+  return 'ready';
+}
+
+function projectPulse(cwd = process.cwd()) {
+  const branch = spawnSync('git', ['branch', '--show-current'], { cwd, encoding: 'utf8' });
+  const status = spawnSync('git', ['status', '--short'], { cwd, encoding: 'utf8' });
+  return {
+    branch: branch.status === 0 && branch.stdout.trim() ? branch.stdout.trim() : '(not a git repository)',
+    changes: status.status === 0 && status.stdout.trim() ? status.stdout.trim().split(/\r?\n/).length : 0,
+  };
+}
+
+function welcomeState() {
+  const meta = store.loadMeta();
+  const accounts = store.listAccounts();
+  const active = accounts.find((a) => a.active) || store.pickAccount() || accounts[0] || null;
+  return {
+    version: pkg.version,
+    accounts,
+    active,
+    model: meta.model || 'default',
+    reasoning: meta.reasoning || 'show',
+    memory: meta.memoryMode || 'off',
+    output: meta.outputMode || 'auto',
+    history: store.readRuns(3),
+    project: projectPulse(),
+    cwd: process.cwd(),
+  };
+}
+
+function buildWelcomeFrame({ width, height, input = '', state = welcomeState() }) {
+  if (width < MIN_WIDTH || height < MIN_HEIGHT) return null;
+  const inner = width - 2;
+  const leftW = Math.max(34, Math.floor(inner * 0.49));
+  const rightW = inner - leftW - 1;
+  const bodyH = height - 6;
+  const left = [];
+  const right = [];
+
+  const logo = [
+    ' ██████╗██╗  ██╗███████╗',
+    '██╔════╝╚██╗██╔╝██╔════╝',
+    '██║      ╚███╔╝ ███████╗',
+    '██║      ██╔██╗ ╚════██║',
+    '╚██████╗██╔╝ ██╗███████║',
+    ' ╚═════╝╚═╝  ╚═╝╚══════╝',
+  ];
+  const topPad = Math.max(1, Math.floor((bodyH - 14) / 2));
+  for (let i = 0; i < topPad; i++) left.push('');
+  left.push(center(ui.bold(ui.cyan('CODEX SWITCH')), leftW));
+  left.push(center(ui.dim('rotate · continue · remember'), leftW));
+  left.push('');
+  logo.forEach((line) => left.push(center(ui.cyan(line), leftW)));
+  left.push('');
+  left.push(center(state.active ? `${ui.green('●')} ${ui.bold(state.active.name)} · ${accountState(state.active)} · ${percent(state.active)}` : ui.yellow('No usable account'), leftW));
+  left.push(center(ui.dim(`${state.accounts.length} account(s) · memory ${state.memory}`), leftW));
+
+  right.push(ui.bold(ui.cyan('Quick commands')));
+  right.push(ui.dim('/help  /usage  /history  /output  /memory  /new'));
+  right.push(ui.dim('Enter send · /paste multiline · /quit exit'));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Account pool')));
+  for (const account of state.accounts.slice(0, 5)) {
+    const mark = account.active ? ui.green('●') : '○';
+    right.push(`${mark} ${account.name}  ${ui.dim(`${accountState(account)} · 5h ${percent(account)}`)}`);
+  }
+  if (state.accounts.length > 5) right.push(ui.dim(`… ${state.accounts.length - 5} more`));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Project pulse')));
+  right.push(`branch ${ui.bold(state.project.branch)} · ${state.project.changes} change(s)`);
+  right.push(ui.dim(crop(state.cwd, rightW)));
+  right.push(ui.dim('─'.repeat(Math.max(1, rightW))));
+  right.push(ui.bold(ui.cyan('Session trail')));
+  if (state.history.length === 0) right.push(ui.dim('No saved work history'));
+  else state.history.forEach((run) => right.push(`${run.status === 'done' ? ui.green('✓') : ui.yellow('!')} ${crop(run.prompt || '(no prompt)', Math.max(8, rightW - 13))} ${ui.dim(run.id)}`));
+
+  while (left.length < bodyH) left.push('');
+  while (right.length < bodyH) right.push('');
+  const title = ` cxs v${state.version} · persistent Codex workspace `;
+  const topLeft = Math.max(0, leftW - displayWidth(title) - 1);
+  const lines = [`┌─${title}${'─'.repeat(topLeft)}┬${'─'.repeat(rightW)}┐`];
+  for (let i = 0; i < bodyH; i++) lines.push(`│${fit(left[i], leftW)}│${fit(right[i], rightW)}│`);
+  lines.push(`└${'─'.repeat(leftW)}┴${'─'.repeat(rightW)}┘`);
+
+  const status = state.active
+    ? `${ui.green('●')} ${state.active.name} · model ${state.model} · reasoning ${state.reasoning} · ${crop(state.cwd, Math.max(8, width - 48))}`
+    : ui.yellow('No usable account');
+  lines.push(fit(status, width));
+  lines.push(`┌${'─'.repeat(width - 2)}┐`);
+  const prompt = input ? `› ${input}` : ui.dim('› Type your message…  Enter: send · /help: commands · Ctrl-C: exit');
+  lines.push(`│${fit(prompt, width - 2)}│`);
+  lines.push(`└${'─'.repeat(width - 2)}┘`);
+  return lines.slice(0, height).map((line) => fit(line, width)).join('\r\n');
+}
+
+async function readWelcomePrompt() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || process.env.CXS_SIMPLE_UI === '1') return { prompt: null, shown: false };
+  if ((process.stdout.columns || 80) < MIN_WIDTH || (process.stdout.rows || 24) < MIN_HEIGHT) return { prompt: null, shown: false };
+  let input = '';
+  let done = false;
+  const draw = () => {
+    const frame = buildWelcomeFrame({
+      width: process.stdout.columns || 80,
+      height: process.stdout.rows || 24,
+      input,
+    });
+    if (frame) process.stdout.write(`\x1b[H${frame}`);
+  };
+  process.stdout.write('\x1b[?1049h\x1b[2J\x1b[H\x1b[?25h');
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  draw();
+  const prompt = await new Promise((resolve) => {
+    const onResize = () => draw();
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      process.stdin.removeListener('data', onData);
+      process.stdout.removeListener('resize', onResize);
+      resolve(value);
+    };
+    const onData = (data) => {
+      if (data === '\u0003' || data === '\u0004' || data === '\u001b') return finish(null);
+      if (data === '\r' || data === '\n') {
+        if (input.trim()) finish(input.trim());
+        return;
+      }
+      if (data === '\u007f' || data === '\b') input = Array.from(input).slice(0, -1).join('');
+      else if (!data.startsWith('\u001b')) input += Array.from(data).filter((ch) => ch >= ' ' && ch !== '\u007f').join('');
+      draw();
+    };
+    process.stdin.on('data', onData);
+    process.stdout.on('resize', onResize);
+  });
+  try { process.stdin.setRawMode(false); } catch { /* best effort */ }
+  process.stdin.pause();
+  process.stdout.write('\x1b[?25h\x1b[?1049l');
+  return { prompt, shown: true };
+}
+
+module.exports = { buildWelcomeFrame, readWelcomePrompt, welcomeState, MIN_WIDTH, MIN_HEIGHT };