@rikcodes/teamclaude 1.1.13-rik.2 → 1.1.13-rik.4

package/README.md

@@ -1,8 +1,12 @@
 # TeamClaude
 
-> **Fork notice (rikbrown).** This fork adds three features and two reload fixes on top of
+> **Fork notice (rikbrown).** This fork adds four features and two reload fixes on top of
 > [KarpelesLab/teamclaude](https://github.com/KarpelesLab/teamclaude):
 >
+> - **[OpenAI models via a Codex sidecar](docs/openai.md)** (`sidecars` + `customModels`, opt-in):
+>   route `gpt-*` requests through a supervised local translating proxy to a ChatGPT subscription,
+>   under real model names — `/model gpt-5.6-sol` in the picker and typed, correct 272k context
+>   sizing, and dispatchable GPT subagents — while Claude traffic stays on the Claude accounts.
 > - **[Soonest-weekly rotation](docs/routing.md#soonest-weekly-rotation)** (`soonestWeekly`, opt-in): rank
 >   equal-priority accounts by the weekly window that governs the requested model, continuously — preempt the
 >   current account when another resets more than `poolHours` sooner, and balance `distributeSessions` within
@@ -68,6 +72,7 @@ Already logged into Claude Code? `teamclaude import` takes its credentials inste
 - Holds the request open until quota resets instead of returning 429 when every account is spent, so an unattended run finishes on its own (`holdSeconds`, off by default).
 - Refreshes OAuth tokens before they expire and writes them back to config. Client refreshes pass through untouched.
 - Takes any Anthropic-compatible API (DeepSeek, GLM) as a low-priority fallback for when the Claude accounts are done.
+- Serves OpenAI models next to Claude ones — a supervised local sidecar translates `gpt-*` requests onto a ChatGPT subscription, with real model names in `/model` and GPT subagents dispatchable from a Claude parent (`sidecars` + `customModels`, this fork).
 - No dependencies. Node built-ins only.
 
 ## Everyday commands
@@ -107,6 +112,7 @@ Step-by-step lifecycle: [docs/routing.md](docs/routing.md#request-lifecycle).
 | [Usage](docs/usage.md) | Server and TUI, running Claude Code, shell alias, command reference, logging |
 | [Routing](docs/routing.md) | Rotation, the two kinds of 429, storm control, model routes, session spreading, pinning, prompt cache |
 | [Quota](docs/quota.md) | Quota probe, keep-warm, holding on exhaustion |
+| [OpenAI models](docs/openai.md) | Codex sidecar setup, custom model registration, GPT subagents, limitations |
 | [Configuration](docs/configuration.md) | Config format, every field, environment variables, network tuning |
 | [Proxy modes](docs/proxy-modes.md) | MITM forward proxy, sx.org residential egress |
 | [Compliance](docs/compliance.md) | Terms of service notes |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.13-rik.2",
+  "version": "1.1.13-rik.4",
   "description": "Multi-account Claude proxy with automatic quota-based rotation",
   "type": "module",
   "main": "src/index.js",

package/src/account-manager.js

@@ -22,6 +22,22 @@ const PERSISTED_QUOTA_FIELDS = [
   'tokensLimit', 'tokensRemaining', 'requestsLimit', 'requestsRemaining', 'resetsAt',
 ];
 
+// Longest Codex window still treated as a session bucket. The two lengths seen
+// in practice are 300 minutes (5h) and 10080 (weekly), so a day sits safely
+// between them.
+const CODEX_WEEKLY_MIN_MINUTES = 1440;
+
+// A Codex `*-reset-at` header as a ms timestamp. The wire format isn't pinned
+// down (the sidecar forwards it opaquely), so accept epoch seconds, epoch ms,
+// or an ISO-8601 date; anything else is null.
+function parseResetAt(value) {
+  if (value == null || value === '') return null;
+  const n = Number(value);
+  if (Number.isFinite(n)) return n > 1e12 ? n : n * 1000;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
 function emptyQuota() {
   return {
     // Standard API rate limits (API key accounts)
@@ -1204,6 +1220,25 @@ export class AccountManager {
     const uStatus = headers['anthropic-ratelimit-unified-status'];
     if (uStatus) account.quota.unifiedStatus = uStatus;
 
+    // OpenAI/Codex windows (`x-codex-*`, forwarded by a translating sidecar for
+    // a ChatGPT-subscription account). Codex reports two windows, `primary` and
+    // `secondary`, whose meaning comes from the declared length rather than the
+    // position: a ChatGPT Pro plan reports its weekly limit as the primary one
+    // and meters no secondary window at all. So each window is filed by length,
+    // which lands it in the same 5h/weekly slots the rest of the code reads —
+    // display, projection and switch-threshold logic apply unchanged. A window
+    // with no length is a bucket the plan does not have, not one at 0% used.
+    // used-percent is 0-100 (not the 0-1 fraction Anthropic reports).
+    for (const window of ['primary', 'secondary']) {
+      const used = parseFloat(headers[`x-codex-${window}-used-percent`]);
+      const minutes = parseInt(headers[`x-codex-${window}-window-minutes`], 10);
+      if (isNaN(used) || !(minutes > 0)) continue;
+      const reset = parseResetAt(headers[`x-codex-${window}-reset-at`]);
+      const weekly = minutes > CODEX_WEEKLY_MIN_MINUTES;
+      account.quota[weekly ? 'unified7d' : 'unified5h'] = used / 100;
+      if (reset != null) account.quota[weekly ? 'unified7dReset' : 'unified5hReset'] = reset;
+    }
+
     // Standard rate limits (API key accounts)
     const tokensLimit = parseInt(headers['anthropic-ratelimit-tokens-limit'], 10);
     const tokensRemaining = parseInt(headers['anthropic-ratelimit-tokens-remaining'], 10);

package/src/claude-env.js

@@ -30,7 +30,66 @@ export function encodePinComponent(s) {
 // `/tc-acct/` prefix. TC_ACCT itself is then unset, so the pin does not leak
 // into claude or anything it spawns — same reasoning as `run` deleting it from
 // the child environment.
-export function buildClaudeEnvLines({ port, useMitm = true, caPath = null, holdSeconds = 0, account = null, proxyApiKey = '' }) {
+// `config.customModels` → the `--settings` JSON that puts each model in the
+// /model picker under its REAL id ({model, label?, description?} rows; typed
+// `/model <id>` also accepts picker rows). contextTokens is ours, not Claude
+// Code's — it feeds CLAUDE_CODE_MAX_CONTEXT_TOKENS below. Null when empty so
+// callers can skip the flag entirely.
+export function buildCustomModelSettings(customModels) {
+  if (!customModels?.length) return null;
+  const options = customModels.map(({ model, label, description }) => ({
+    model,
+    ...(label ? { label } : {}),
+    ...(description ? { description } : {}),
+  }));
+  return JSON.stringify({ modelPicker: { options } });
+}
+
+// `config.customModels` → the `--agents` JSON that makes each model
+// dispatchable as a subagent. The Agent tool's per-invocation `model`
+// parameter is an alias enum (sonnet|opus|haiku|fable) and rejects custom ids;
+// an agent DEFINITION's `model:` field accepts any id, so each custom model
+// gets a general-purpose agent named after it ("dispatch a gpt-5.6-terra
+// subagent" then works out of the box). Null when empty.
+export function buildCustomModelAgents(customModels) {
+  if (!customModels?.length) return null;
+  const agents = {};
+  for (const { model, label } of customModels) {
+    agents[model] = {
+      description: `General-purpose subagent running on ${label || model} (via TeamClaude). `
+        + `Use when asked to run a task on ${model}.`,
+      prompt: `You are a general-purpose subagent running on the ${model} model. `
+        + 'Complete the task you are given and report the results concisely.',
+      model,
+    };
+  }
+  return JSON.stringify(agents);
+}
+
+// The env-only registration for launchers we can't pass flags to (`teamclaude
+// env`). ANTHROPIC_CUSTOM_MODEL_OPTION registers ONE model (env can't express a
+// list — the picker rows need `--settings`, i.e. `teamclaude run`), so the
+// first entry is the one that gets a picker row and typed-/model acceptance.
+// CLAUDE_CODE_MAX_CONTEXT_TOKENS is global for all unknown model ids: use the
+// largest declared window so no custom model is compacted early; deliberately
+// NOT modelOverrides, which would pin the window to the mapped Claude model's.
+export function buildCustomModelVars(customModels) {
+  if (!customModels?.length) return {};
+  const vars = { ANTHROPIC_CUSTOM_MODEL_OPTION: customModels[0].model };
+  if (customModels[0].label) vars.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME = customModels[0].label;
+  if (customModels[0].description) vars.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION = customModels[0].description;
+  const windows = customModels.map(m => m.contextTokens).filter(n => Number.isFinite(n));
+  if (windows.length) vars.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(Math.max(...windows));
+  return vars;
+}
+
+// Single-quote a value for an unquoted-context shell `export` line (labels and
+// descriptions contain spaces). POSIX: close, escaped quote, reopen.
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+export function buildClaudeEnvLines({ port, useMitm = true, caPath = null, holdSeconds = 0, account = null, proxyApiKey = '', customModels = null }) {
   const lines = [];
   const pin = (account || '').trim();
 
@@ -61,5 +120,10 @@ export function buildClaudeEnvLines({ port, useMitm = true, caPath = null, holdS
   const holdMs = (holdSeconds || 0) * 1000;
   if (holdMs > 0) lines.push(`export API_TIMEOUT_MS=${holdMs + 60_000}`);
 
+  // Custom (third-party) model registration — see buildCustomModelVars.
+  for (const [key, value] of Object.entries(buildCustomModelVars(customModels))) {
+    lines.push(`export ${key}=${shellQuote(value)}`);
+  }
+
   return lines;
 }

package/src/index.js

@@ -15,13 +15,14 @@ import * as alias from './alias.js';
 import { ensureCerts } from './mitm.js';
 import { Prober } from './prober.js';
 import { Warmer } from './warmer.js';
+import { Sidecar } from './sidecar.js';
 import { TUI } from './tui.js';
 import { SessionTitles } from './session-titles.js';
 import { RemoteControl, createAttachSession } from './tui-remote.js';
 import { SxManager } from './sx.js';
 import { autoUpdate, checkForUpdate, currentVersion, runUpdate, installKind, PKG_NAME } from './updater.js';
 import { renderStatus } from './status-renderer.js';
-import { buildClaudeEnvLines, encodePinComponent } from './claude-env.js';
+import { buildClaudeEnvLines, buildCustomModelAgents, buildCustomModelSettings, buildCustomModelVars, encodePinComponent } from './claude-env.js';
 import { serviceKind, installService, uninstallService, serviceStatus, renderService, logPath } from './service.js';
 import { formatTerminalTitle, titleSequence, TITLE_STACK_PUSH, TITLE_STACK_POP } from './terminal-title.js';
 import { getUpstreamProxy, describeProxy } from './upstream-proxy.js';
@@ -248,6 +249,9 @@ async function serverCommand() {
   let prober = null;
   // Opt-in keep-warm scheduler (config.warmupSeconds, default 0 = off).
   let warmer = null;
+  // Supervised sidecar processes (config.sidecars, default none) — e.g. a local
+  // Anthropic→OpenAI translating proxy that a third-party account routes to.
+  let sidecar = null;
   const serverStartedAt = Date.now();
 
   // sx.org proxy (IP-based-429 workaround). Dormant unless an API key is set in
@@ -428,6 +432,7 @@ async function serverCommand() {
         error: null,
       })),
     },
+    sidecars: sidecar?.getStatus() || [],
   });
 
   const server = createProxyServer(accountManager, config, hooks, sx);
@@ -497,6 +502,10 @@ async function serverCommand() {
   });
   warmer.start();
 
+  // Launch supervised sidecars (no-op when config.sidecars is empty).
+  sidecar = new Sidecar(config.sidecars);
+  sidecar.start();
+
   // Background self-update for a backgrounded (headless) server. Skipped under
   // the TUI, where npm's install output would corrupt the display — interactive
   // users update via `teamclaude run` (post-session) or `teamclaude update`.
@@ -517,6 +526,7 @@ async function serverCommand() {
     if (!tui) console.log('\n[TeamClaude] Shutting down...');
     prober?.stop();
     warmer?.stop();
+    sidecar?.stop();
     if (quotaSaveInterval) clearInterval(quotaSaveInterval);
     await persistQuotaState();
     // Don't linger waiting on keep-alive / streaming connections: actively
@@ -679,6 +689,7 @@ async function envCommand() {
   const lines = buildClaudeEnvLines({
     port, useMitm, caPath, holdSeconds: config.holdSeconds,
     account, proxyApiKey: config.proxy?.apiKey || '',
+    customModels: config.customModels,
   });
   process.stdout.write(`${lines.join('\n')}\n`);
 
@@ -736,7 +747,8 @@ async function runCommand() {
   // also pins (shipped in 1.1.10). TC_ACCT is the supported way now — it works in
   // MITM mode too, and keeps the pin out of the API path.
   const pinnedBase = isLocalAccountPin(process.env.ANTHROPIC_BASE_URL, port);
-  if (await isProxyUp(port)) {
+  const proxyUp = await isProxyUp(port);
+  if (proxyUp) {
     if (useMitm) {
       // Route ALL of claude's traffic through us as an HTTPS forward proxy, so
       // even hardcoded api.anthropic.com endpoints (e.g. the design MCP) get the
@@ -784,6 +796,21 @@ async function runCommand() {
     process.exit(1);
   }
 
+  // Register custom (third-party) models with Claude Code — /model picker rows
+  // via --settings, typed-/model + window sizing via env — but only when routed
+  // through the proxy: launched directly, those models aren't reachable. A
+  // caller-supplied --settings wins; merging two would silently drop keys.
+  if (proxyUp && config.customModels?.length) {
+    Object.assign(env, buildCustomModelVars(config.customModels));
+    const settings = buildCustomModelSettings(config.customModels);
+    if (settings && !claudeArgs.includes('--settings')) claudeArgs.push('--settings', settings);
+    // Dispatchable subagents per custom model — the Agent tool's `model`
+    // parameter is an alias enum, so only a named agent definition can carry a
+    // custom model id into a subagent.
+    const agents = buildCustomModelAgents(config.customModels);
+    if (agents && !claudeArgs.includes('--agents')) claudeArgs.push('--agents', agents);
+  }
+
   // If holdSeconds is set, ensure API_TIMEOUT_MS on the Claude Code side is
   // large enough for the hold to complete. Add 60s padding (one extra poll
   // cycle) so the client doesn't time out while we're still waiting.

package/src/server.js

@@ -918,12 +918,7 @@ export async function forwardRequest(req, res, body, accountManager, upstream, r
     }
 
     // Extract rate limit headers
-    const rateLimitHeaders = {};
-    for (const [key, value] of upstreamRes.headers.entries()) {
-      if (key.startsWith('anthropic-ratelimit-')) {
-        rateLimitHeaders[key] = value;
-      }
-    }
+    const rateLimitHeaders = collectRateLimitHeaders(upstreamRes.headers);
     accountManager.updateQuota(account.index, rateLimitHeaders);
 
     // Any non-429 response is live proof a rate-limit hold no longer binds —
@@ -950,7 +945,10 @@ export async function forwardRequest(req, res, body, accountManager, upstream, r
       // already recorded the spent bucket's utilization from the headers).
       const rl = rateLimitHeaders;
       const generalRejected = rl['anthropic-ratelimit-unified-5h-status'] === 'rejected'
-        || rl['anthropic-ratelimit-unified-7d-status'] === 'rejected';
+        || rl['anthropic-ratelimit-unified-7d-status'] === 'rejected'
+        // A spent Codex window on a sidecar-backed account is the same shape:
+        // a durable quota rejection, not a transient throttle.
+        || codexQuotaRejected(rl);
       const fableRejected = rl['anthropic-ratelimit-unified-7d_oi-status'] === 'rejected' && !generalRejected;
       if ((generalRejected || fableRejected) && retryCount < maxRetries) {
         // A Fable-only rejection leaves the account fine for other models, so we
@@ -1306,6 +1304,25 @@ export function rewriteModel(body, modelMap) {
   return body;
 }
 
+// Rate-limit telemetry we pass to AccountManager.updateQuota: Anthropic's
+// `anthropic-ratelimit-*` family, plus the OpenAI/Codex `x-codex-*` family a
+// translating sidecar may forward from the ChatGPT backend. Exported for tests.
+export function collectRateLimitHeaders(headers) {
+  const out = {};
+  for (const [key, value] of headers.entries()) {
+    if (key.startsWith('anthropic-ratelimit-') || key.startsWith('x-codex-')) out[key] = value;
+  }
+  return out;
+}
+
+// Durable Codex quota exhaustion: either subscription window (primary ≈ 5h,
+// secondary ≈ weekly) reports fully spent. Like a unified "rejected" status,
+// retrying the same account is futile until the window resets. Exported for tests.
+export function codexQuotaRejected(rl) {
+  return parseFloat(rl['x-codex-primary-used-percent']) >= 100
+    || parseFloat(rl['x-codex-secondary-used-percent']) >= 100;
+}
+
 function computeRetryAfter(accounts) {
   let soonest = Infinity;
   for (const acct of accounts) {

package/src/sidecar.js

@@ -0,0 +1,133 @@
+// Sidecar supervisor (codex-proxy feature).
+//
+// TeamClaude is the controller: when a third-party backend account points at a
+// local translating proxy (e.g. raine/claude-code-proxy for the ChatGPT/Codex
+// backend), the server owns that process rather than asking the user to run it
+// by hand or via brew services. Each `config.sidecars[]` entry is spawned on
+// server start, respawned with exponential backoff when it dies, and killed on
+// shutdown. Supervision is process-level only — routing to the sidecar is
+// unchanged (a normal `accounts[].upstream` + route).
+//
+// stdout is ignored (sidecars keep their own log files); stderr's last few
+// lines are kept in a ring buffer so `getStatus()` can say WHY a sidecar is
+// crash-looping without anyone hunting for its logs.
+
+import { spawn } from 'node:child_process';
+
+/** Delay before restart attempt N (0-based): base, doubled per consecutive
+ *  crash, capped. Pure so the schedule is testable without timers. */
+export function restartDelayMs(restarts, { baseRestartMs, maxRestartMs }) {
+  return Math.min(baseRestartMs * 2 ** restarts, maxRestartMs);
+}
+
+export class Sidecar {
+  constructor(entries, {
+    spawnFn = defaultSpawn,
+    baseRestartMs = 1000,
+    maxRestartMs = 30_000,
+    stableMs = 30_000,
+    stderrTailLines = 20,
+    log = console.log,
+  } = {}) {
+    this.entries = Array.isArray(entries) ? entries : [];
+    this.spawnFn = spawnFn;
+    this.baseRestartMs = baseRestartMs;
+    this.maxRestartMs = maxRestartMs;
+    this.stableMs = stableMs;
+    this.stderrTailLines = stderrTailLines;
+    this.log = log;
+    this.stopping = false;
+    // Per-entry runtime state, keyed by entry (parallel array to this.entries).
+    this.states = this.entries.map(entry => ({
+      entry,
+      child: null,
+      startedAt: null,
+      restarts: 0,
+      lastExit: null,
+      timer: null,
+      stderrTail: [],
+    }));
+  }
+
+  start() {
+    for (const state of this.states) this._spawn(state);
+  }
+
+  stop() {
+    this.stopping = true;
+    for (const state of this.states) {
+      if (state.timer) { clearTimeout(state.timer); state.timer = null; }
+      state.child?.kill('SIGTERM');
+    }
+  }
+
+  getStatus() {
+    return this.states.map(state => ({
+      name: state.entry.name,
+      running: !!state.child,
+      pid: state.child?.pid ?? null,
+      restarts: state.restarts,
+      lastExit: state.lastExit,
+      stderrTail: [...state.stderrTail],
+    }));
+  }
+
+  _spawn(state) {
+    const { entry } = state;
+    const [command, ...args] = entry.command;
+    let child;
+    try {
+      child = this.spawnFn({
+        name: entry.name,
+        command,
+        args,
+        env: { ...process.env, ...(entry.env || {}) },
+      });
+    } catch (err) {
+      this._onDown(state, `spawn failed: ${err?.message || err}`);
+      return;
+    }
+    state.child = child;
+    state.startedAt = Date.now();
+    child.stderr?.on('data', (chunk) => this._recordStderr(state, chunk));
+    child.once('error', (err) => {
+      if (state.child !== child) return;
+      this._onDown(state, `spawn error: ${err?.message || err}`);
+    });
+    child.once('exit', (code, signal) => {
+      if (state.child !== child) return;
+      this._onDown(state, signal ? `signal ${signal}` : `code ${code}`);
+    });
+  }
+
+  _onDown(state, lastExit) {
+    // A run that survived long enough resets the backoff: the next crash is a
+    // fresh incident, not a continuation of a crash loop.
+    if (state.startedAt && Date.now() - state.startedAt >= this.stableMs) state.restarts = 0;
+    state.child = null;
+    state.lastExit = lastExit;
+    if (this.stopping) return;
+    const delay = restartDelayMs(state.restarts, this);
+    this.log(`[TeamClaude] Sidecar "${state.entry.name}" down (${lastExit}); restarting in ${Math.round(delay / 1000)}s`);
+    state.restarts += 1;
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      this._spawn(state);
+    }, delay);
+    state.timer.unref?.();
+  }
+
+  _recordStderr(state, chunk) {
+    const lines = String(chunk).split('\n').map(s => s.trim()).filter(Boolean);
+    state.stderrTail.push(...lines);
+    if (state.stderrTail.length > this.stderrTailLines) {
+      state.stderrTail.splice(0, state.stderrTail.length - this.stderrTailLines);
+    }
+  }
+}
+
+// Real spawner: stdout ignored (sidecars log to their own files), stderr piped
+// for the ring buffer. detached:false so the child dies with us as a backstop.
+function defaultSpawn({ command, args, env }) {
+  return spawn(command, args, { env, stdio: ['ignore', 'ignore', 'pipe'] });
+}