codex-rotating-proxy 0.1.0 → 0.1.1

package/dist/server.js

@@ -0,0 +1,223 @@
+import { createServer } from "node:http";
+import { execSync } from "node:child_process";
+import { type as osType, release, arch } from "node:os";
+import { getAccounts, getSettings, writePid, removePid } from "./config.js";
+import { refreshAccount } from "./login.js";
+import { AccountPool, log } from "./pool.js";
+const ROTATE_ON = new Set([429, 402]);
+const STRIP_REQ = new Set([
+    "host", "authorization", "connection", "content-length",
+    "user-agent", "originator",
+]);
+const STRIP_RES = new Set(["transfer-encoding", "connection"]);
+// ── Codex-style User-Agent ──────────────────────────────────────
+// Map TERM_PROGRAM values to Codex CLI terminal tokens
+const TERMINAL_MAP = {
+    "iterm.app": "iterm2",
+    "iterm": "iterm2",
+    "apple_terminal": "apple-terminal",
+    "terminal": "apple-terminal",
+    "warpterminal": "warp",
+    "wezterm": "wezterm",
+    "vscode": "vscode",
+    "ghostty": "ghostty",
+    "alacritty": "alacritty",
+    "kitty": "kitty",
+    "konsole": "konsole",
+    "gnome-terminal": "gnome-terminal",
+    "windows terminal": "windows-terminal",
+};
+function buildUserAgent() {
+    let os = osType();
+    let ver = release();
+    if (os === "Darwin") {
+        os = "Mac OS";
+        try {
+            ver = execSync("sw_vers -productVersion", { encoding: "utf-8" }).trim();
+        }
+        catch { }
+    }
+    const raw = (process.env.TERM_PROGRAM ?? "").toLowerCase().replace(/\.app$/i, "");
+    const terminal = TERMINAL_MAP[raw] ?? (raw || "unknown-terminal");
+    return `codex_cli_rs/0.1.0 (${os} ${ver}; ${arch()}) ${terminal}`;
+}
+const CODEX_USER_AGENT = buildUserAgent();
+function codexHeaders(account) {
+    const h = {
+        "user-agent": CODEX_USER_AGENT,
+        "originator": "codex_cli_rs",
+    };
+    if (account.accountId) {
+        h["chatgpt-account-id"] = account.accountId;
+    }
+    return h;
+}
+export function startProxy() {
+    const settings = getSettings();
+    const accounts = getAccounts();
+    const upstream = settings.upstream.replace(/\/$/, "");
+    if (accounts.length === 0) {
+        console.error("\x1b[31mNo accounts configured. Run `codex-proxy login` first.\x1b[0m");
+        process.exit(1);
+    }
+    const pool = new AccountPool(accounts, settings.cooldownMinutes);
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${settings.port}`);
+        // ── Internal endpoints ────────────────────────────────────
+        if (url.pathname === "/_status") {
+            json(res, 200, { accounts: pool.getStatus() });
+            return;
+        }
+        if (url.pathname === "/_reload") {
+            pool.reload(getAccounts());
+            log("green", "↻ accounts reloaded");
+            json(res, 200, { ok: true, accounts: pool.size });
+            return;
+        }
+        // ── Buffer body for retries ───────────────────────────────
+        const chunks = [];
+        for await (const chunk of req)
+            chunks.push(chunk);
+        let body = chunks.length > 0 ? Buffer.concat(chunks) : null;
+        // ── Forward headers ───────────────────────────────────────
+        const fwdHeaders = {};
+        for (const [k, v] of Object.entries(req.headers)) {
+            if (v && !STRIP_REQ.has(k.toLowerCase())) {
+                fwdHeaders[k] = Array.isArray(v) ? v.join(", ") : v;
+            }
+        }
+        // ── Try each account ──────────────────────────────────────
+        for (let attempt = 0; attempt < pool.size; attempt++) {
+            const entry = pool.getNext();
+            if (!entry)
+                break;
+            const target = `${upstream}${url.pathname}${url.search}`;
+            log("cyan", `→ ${req.method} ${url.pathname} via ${entry.name}`);
+            // Inner loop: try once, and if 401 + refreshable, refresh and retry
+            let currentToken = entry.account.token;
+            for (let retry = 0; retry < 2; retry++) {
+                try {
+                    const fetchRes = await fetch(target, {
+                        method: req.method,
+                        headers: {
+                            ...fwdHeaders,
+                            ...codexHeaders(entry.account),
+                            authorization: `Bearer ${currentToken}`,
+                            ...(body ? { "content-length": String(body.byteLength) } : {}),
+                        },
+                        body,
+                    });
+                    // ── 401: try token refresh before rotating ────────
+                    if (fetchRes.status === 401 && retry === 0 && entry.account.refreshToken) {
+                        await fetchRes.text();
+                        log("yellow", `⟳ ${entry.name} got 401 — refreshing token`);
+                        const newToken = await refreshAccount(entry.account);
+                        if (newToken) {
+                            currentToken = newToken;
+                            entry.account.token = newToken;
+                            pool.updateToken(entry.name, newToken);
+                            log("green", `✓ ${entry.name} token refreshed`);
+                            continue; // retry inner loop
+                        }
+                        log("red", `✗ ${entry.name} refresh failed — rotating`);
+                        pool.markCooldown(entry.name);
+                        break; // move to next account
+                    }
+                    // ── Rate limit / quota → rotate ───────────────────
+                    if (ROTATE_ON.has(fetchRes.status)) {
+                        await fetchRes.text();
+                        log("red", `✗ ${entry.name} hit ${fetchRes.status} — rotating`);
+                        pool.markCooldown(entry.name);
+                        break;
+                    }
+                    if (fetchRes.status === 403) {
+                        const text = await fetchRes.text();
+                        if (/quota|limit|exceeded|rate/i.test(text)) {
+                            log("red", `✗ ${entry.name} 403 quota — rotating`);
+                            pool.markCooldown(entry.name);
+                            break;
+                        }
+                        log("yellow", `✗ 403 (not quota) — forwarding`);
+                        forward(res, 403, fetchRes.headers, text);
+                        return;
+                    }
+                    // ── Stream response back ──────────────────────────
+                    log("green", `✓ ${fetchRes.status}`);
+                    const resHeaders = {};
+                    fetchRes.headers.forEach((v, k) => {
+                        if (!STRIP_RES.has(k.toLowerCase()))
+                            resHeaders[k] = v;
+                    });
+                    res.writeHead(fetchRes.status, resHeaders);
+                    if (fetchRes.body) {
+                        const reader = fetchRes.body.getReader();
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                res.write(value);
+                            }
+                        }
+                        catch { }
+                        res.end();
+                    }
+                    else {
+                        res.end();
+                    }
+                    return;
+                }
+                catch (err) {
+                    log("red", `✗ ${entry.name} network error: ${err}`);
+                    pool.markCooldown(entry.name);
+                    break;
+                }
+            }
+        }
+        log("red", "✗ all accounts exhausted");
+        json(res, 503, {
+            error: {
+                message: "All accounts exhausted. Check /_status for cooldown times.",
+                type: "proxy_error",
+            },
+        });
+    });
+    // ── Lifecycle ─────────────────────────────────────────────────
+    writePid(process.pid);
+    const shutdown = () => {
+        log("yellow", "shutting down...");
+        removePid();
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 3000);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    server.listen(settings.port, () => {
+        console.log();
+        console.log("  \x1b[36mcodex-proxy\x1b[0m");
+        console.log(`  upstream   ${upstream}`);
+        console.log(`  port       ${settings.port}`);
+        console.log(`  accounts   ${accounts.map((a) => a.name).join(", ")}`);
+        console.log(`  cooldown   ${settings.cooldownMinutes}m`);
+        console.log();
+        log("green", `listening on http://localhost:${settings.port}`);
+        console.log();
+    });
+}
+function json(res, status, data) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(data, null, 2));
+}
+function forward(res, status, headers, body) {
+    const h = {};
+    headers.forEach((v, k) => {
+        if (!STRIP_RES.has(k.toLowerCase()))
+            h[k] = v;
+    });
+    res.writeHead(status, h);
+    res.end(body);
+}
+// Allow running directly for daemon mode
+if (process.env.CODEX_PROXY_DAEMON === "1") {
+    startProxy();
+}

package/package.json

@@ -1,18 +1,33 @@
 {
   "name": "codex-rotating-proxy",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenAI API proxy that rotates between multiple accounts when rate limits hit",
   "type": "module",
   "bin": {
-    "codex-proxy": "bin/codex-proxy"
+    "codex-proxy": "dist/cli.js"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
+    "build": "tsc && node -e \"const f='dist/cli.js';const c=require('fs').readFileSync(f,'utf8');require('fs').writeFileSync(f,'#!/usr/bin/env node\\n'+c)\"",
     "dev": "node --experimental-strip-types src/cli.ts",
-    "postinstall": "chmod +x bin/codex-proxy 2>/dev/null || true"
+    "prepublishOnly": "npm run build"
   },
-  "keywords": ["openai", "proxy", "rate-limit", "rotation", "chatgpt", "codex"],
+  "keywords": [
+    "openai",
+    "proxy",
+    "rate-limit",
+    "rotation",
+    "chatgpt",
+    "codex"
+  ],
   "license": "MIT",
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "^5.9.3"
   }
 }

package/bin/codex-proxy

@@ -1,10 +0,0 @@
-#!/bin/sh
-# Resolve symlinks (npm link creates one)
-SELF="$0"
-while [ -L "$SELF" ]; do
-  DIR="$(cd "$(dirname "$SELF")" && pwd)"
-  SELF="$(readlink "$SELF")"
-  case "$SELF" in /*) ;; *) SELF="$DIR/$SELF" ;; esac
-done
-SCRIPT_DIR="$(cd "$(dirname "$SELF")" && pwd)"
-exec node --experimental-strip-types "$SCRIPT_DIR/../src/cli.ts" "$@"

package/src/cli.ts

@@ -1,307 +0,0 @@
-import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  getAccounts,
-  getSettings,
-  updateSettings,
-  removeAccount,
-  readPid,
-  isRunning,
-  removePid,
-  ensureDataDir,
-  LOG_FILE,
-} from "./config.ts";
-import { loginFlow } from "./login.ts";
-import { startProxy } from "./server.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const VERSION = "0.1.0";
-
-// ── Parse args ──────────────────────────────────────────────────
-const args = process.argv.slice(2);
-const command = args[0];
-const flags = new Set(args.slice(1));
-const getFlag = (short: string, long: string): string | undefined => {
-  for (let i = 1; i < args.length; i++) {
-    if (args[i] === short || args[i] === long) return args[i + 1];
-  }
-  return undefined;
-};
-const positional = args.slice(1).filter((a) => !a.startsWith("-"));
-
-// ── Colors ──────────────────────────────────────────────────────
-const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
-const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
-const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
-const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
-const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
-const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
-
-// ── Commands ────────────────────────────────────────────────────
-async function main(): Promise<void> {
-  ensureDataDir();
-
-  switch (command) {
-    case "start":
-      return cmdStart();
-    case "stop":
-      return cmdStop();
-    case "status":
-      return cmdStatus();
-    case "login":
-      return cmdLogin();
-    case "logout":
-    case "remove":
-      return cmdLogout();
-    case "accounts":
-    case "list":
-      return cmdAccounts();
-    case "config":
-      return cmdConfig();
-    case "-v":
-    case "--version":
-      console.log(VERSION);
-      return;
-    case "-h":
-    case "--help":
-    case "help":
-    case undefined:
-      return cmdHelp();
-    default:
-      console.log(red(`Unknown command: ${command}`));
-      console.log(`Run ${cyan("codex-proxy --help")} for usage.`);
-      process.exit(1);
-  }
-}
-
-// ── start ───────────────────────────────────────────────────────
-function cmdStart(): void {
-  const pid = readPid();
-  if (pid && isRunning(pid)) {
-    console.log(yellow(`Proxy already running (PID ${pid}).`));
-    console.log(`Run ${cyan("codex-proxy stop")} first, or ${cyan("codex-proxy status")} to check.`);
-    return;
-  }
-
-  // Apply flag overrides
-  const port = getFlag("-p", "--port");
-  const upstream = getFlag("-u", "--upstream");
-  if (port) updateSettings({ port: parseInt(port) });
-  if (upstream) updateSettings({ upstream });
-
-  const isDaemon = flags.has("-d") || flags.has("--daemon");
-
-  if (isDaemon) {
-    const logFd = openSync(LOG_FILE, "a");
-    const child = spawn(
-      process.execPath,
-      ["--experimental-strip-types", join(__dirname, "server.ts")],
-      {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        env: { ...process.env, CODEX_PROXY_DAEMON: "1" },
-      }
-    );
-    child.unref();
-
-    const settings = getSettings();
-    console.log(green(`✓`) + ` Proxy started in background (PID ${child.pid})`);
-    console.log(`  ${dim("port")}      ${settings.port}`);
-    console.log(`  ${dim("log")}       ${LOG_FILE}`);
-    console.log(`  ${dim("stop")}      codex-proxy stop`);
-    return;
-  }
-
-  // Foreground
-  startProxy();
-}
-
-// ── stop ────────────────────────────────────────────────────────
-async function cmdStop(): Promise<void> {
-  const pid = readPid();
-  if (!pid || !isRunning(pid)) {
-    console.log(dim("Proxy is not running."));
-    removePid();
-    return;
-  }
-
-  process.kill(pid, "SIGTERM");
-  for (let i = 0; i < 30; i++) {
-    if (!isRunning(pid)) break;
-    await sleep(100);
-  }
-  removePid();
-  console.log(green("✓") + ` Proxy stopped (PID ${pid})`);
-}
-
-// ── status ──────────────────────────────────────────────────────
-async function cmdStatus(): Promise<void> {
-  const pid = readPid();
-  const running = pid !== null && isRunning(pid);
-
-  if (!running) {
-    console.log(`  ${bold("Proxy")}  ${dim("stopped")}`);
-    if (pid) removePid();
-  } else {
-    console.log(`  ${bold("Proxy")}  ${green("running")} ${dim(`(PID ${pid})`)}`);
-
-    try {
-      const settings = getSettings();
-      const res = await fetch(`http://localhost:${settings.port}/_status`);
-      const data = (await res.json()) as { accounts: any[] };
-      console.log();
-      printAccountTable(data.accounts);
-    } catch {
-      console.log(dim("  Could not reach proxy for live status."));
-    }
-  }
-
-  if (!running) {
-    const accounts = getAccounts();
-    if (accounts.length === 0) {
-      console.log(
-        `\n  No accounts. Run ${cyan("codex-proxy login")} to add one.`
-      );
-    } else {
-      console.log(`\n  ${bold("Accounts")}  ${accounts.length} configured`);
-      for (const a of accounts) {
-        console.log(`    ${a.name}  ${dim(maskToken(a.token))}`);
-      }
-    }
-  }
-}
-
-// ── login ───────────────────────────────────────────────────────
-function cmdLogin(): Promise<void> {
-  return loginFlow(positional[0]);
-}
-
-// ── logout ──────────────────────────────────────────────────────
-function cmdLogout(): void {
-  const name = positional[0];
-  if (!name) {
-    console.log(red("Usage: codex-proxy logout <account-name>"));
-    return;
-  }
-  if (removeAccount(name)) {
-    console.log(green("✓") + ` Removed "${name}"`);
-  } else {
-    console.log(red(`Account "${name}" not found.`));
-  }
-}
-
-// ── accounts ────────────────────────────────────────────────────
-function cmdAccounts(): void {
-  const accounts = getAccounts();
-  if (accounts.length === 0) {
-    console.log(dim("No accounts. Run codex-proxy login to add one."));
-    return;
-  }
-  console.log();
-  for (const a of accounts) {
-    const ago = timeAgo(new Date(a.addedAt));
-    console.log(`  ${bold(a.name.padEnd(16))} ${dim(maskToken(a.token))}  ${dim(ago)}`);
-  }
-  console.log();
-}
-
-// ── config ──────────────────────────────────────────────────────
-function cmdConfig(): void {
-  const s = getSettings();
-  console.log();
-  console.log(`  ${dim("port")}       ${s.port}`);
-  console.log(`  ${dim("upstream")}   ${s.upstream}`);
-  console.log(`  ${dim("cooldown")}   ${s.cooldownMinutes}m`);
-  console.log();
-  console.log(
-    dim(`  Edit: codex-proxy config --port 5000`)
-  );
-
-  // Handle inline config changes
-  const port = getFlag("-p", "--port") ?? getFlag("--port", "--port");
-  const upstream = getFlag("-u", "--upstream") ?? getFlag("--upstream", "--upstream");
-  const cooldown = getFlag("-c", "--cooldown") ?? getFlag("--cooldown", "--cooldown");
-
-  const changes: Partial<{ port: number; upstream: string; cooldownMinutes: number }> = {};
-  if (port) changes.port = parseInt(port);
-  if (upstream) changes.upstream = upstream;
-  if (cooldown) changes.cooldownMinutes = parseInt(cooldown);
-
-  if (Object.keys(changes).length > 0) {
-    updateSettings(changes);
-    console.log(green("\n  ✓ Updated"));
-  }
-}
-
-// ── help ────────────────────────────────────────────────────────
-function cmdHelp(): void {
-  console.log(`
-  ${bold("codex-proxy")} ${dim(`v${VERSION}`)} — OpenAI API proxy with account rotation
-
-  ${bold("Usage")}
-    codex-proxy <command> [options]
-
-  ${bold("Commands")}
-    ${cyan("login")}  [name]         Add an account via browser
-    ${cyan("logout")} <name>         Remove an account
-    ${cyan("accounts")}               List all connected accounts
-    ${cyan("start")}                  Start the proxy server
-    ${cyan("stop")}                   Stop the proxy server
-    ${cyan("status")}                 Show proxy and account status
-    ${cyan("config")}                 Show or update configuration
-
-  ${bold("Options")}  ${dim("(for start)")}
-    -p, --port <n>           Port number ${dim("(default: 4000)")}
-    -u, --upstream <url>     Upstream API URL ${dim("(default: https://api.openai.com)")}
-    -d, --daemon             Run in background
-
-  ${bold("Quick start")}
-    ${dim("$")} codex-proxy login
-    ${dim("$")} codex-proxy login work
-    ${dim("$")} codex-proxy start
-
-  ${bold("Configure your tool")}
-    Point your OpenAI-compatible tool to ${cyan("http://localhost:4000/v1")}
-`);
-}
-
-// ── Helpers ─────────────────────────────────────────────────────
-function maskToken(token: string): string {
-  if (token.length <= 8) return "••••••••";
-  return token.slice(0, 4) + "••••" + token.slice(-4);
-}
-
-function timeAgo(date: Date): string {
-  const sec = Math.floor((Date.now() - date.getTime()) / 1000);
-  if (sec < 60) return "just now";
-  if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
-  if (sec < 86400) return `${Math.floor(sec / 3600)}h ago`;
-  return `${Math.floor(sec / 86400)}d ago`;
-}
-
-function printAccountTable(accounts: any[]): void {
-  for (const a of accounts) {
-    const indicator = a.status === "ready" ? green("●") : yellow("◑");
-    const status =
-      a.status === "ready"
-        ? a.active
-          ? green("active")
-          : dim("standby")
-        : yellow(`cooldown ${a.cooldownRemaining}`);
-    const stats = dim(
-      `${String(a.totalRequests).padStart(4)} req  ${String(a.errors).padStart(2)} err`
-    );
-    console.log(`  ${indicator} ${bold(a.name.padEnd(16))} ${status.padEnd(30)} ${stats}`);
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-main().catch((err) => {
-  console.error(red(err.message));
-  process.exit(1);
-});

package/src/config.ts

@@ -1,113 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-
-// ── Paths ───────────────────────────────────────────────────────
-export const DATA_DIR = join(homedir(), ".codex-proxy");
-const ACCOUNTS_FILE = join(DATA_DIR, "accounts.json");
-const SETTINGS_FILE = join(DATA_DIR, "settings.json");
-export const PID_FILE = join(DATA_DIR, "proxy.pid");
-export const LOG_FILE = join(DATA_DIR, "proxy.log");
-
-// ── Types ───────────────────────────────────────────────────────
-export interface Account {
-  name: string;
-  token: string;
-  refreshToken?: string;
-  accountId?: string;
-  addedAt: string;
-  lastRefresh?: string;
-}
-
-export interface Settings {
-  port: number;
-  upstream: string;
-  cooldownMinutes: number;
-}
-
-const DEFAULTS: Settings = {
-  port: 4000,
-  upstream: "https://api.openai.com",
-  cooldownMinutes: 60,
-};
-
-// ── Helpers ─────────────────────────────────────────────────────
-export function ensureDataDir(): void {
-  mkdirSync(DATA_DIR, { recursive: true });
-}
-
-function readJson<T>(path: string, fallback: T): T {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return fallback;
-  }
-}
-
-function writeJson(path: string, data: unknown): void {
-  ensureDataDir();
-  writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
-}
-
-// ── Accounts ────────────────────────────────────────────────────
-export function getAccounts(): Account[] {
-  return readJson<{ accounts: Account[] }>(ACCOUNTS_FILE, { accounts: [] })
-    .accounts;
-}
-
-export function addAccount(account: Account): void {
-  const accounts = getAccounts();
-  const idx = accounts.findIndex((a) => a.name === account.name);
-  if (idx >= 0) accounts[idx] = account;
-  else accounts.push(account);
-  writeJson(ACCOUNTS_FILE, { accounts });
-}
-
-export function removeAccount(name: string): boolean {
-  const accounts = getAccounts();
-  const filtered = accounts.filter((a) => a.name !== name);
-  if (filtered.length === accounts.length) return false;
-  writeJson(ACCOUNTS_FILE, { accounts: filtered });
-  return true;
-}
-
-// ── Settings ────────────────────────────────────────────────────
-export function getSettings(): Settings {
-  return {
-    ...DEFAULTS,
-    ...readJson<Partial<Settings>>(SETTINGS_FILE, {}),
-  };
-}
-
-export function updateSettings(partial: Partial<Settings>): void {
-  writeJson(SETTINGS_FILE, { ...getSettings(), ...partial });
-}
-
-// ── PID ─────────────────────────────────────────────────────────
-export function readPid(): number | null {
-  try {
-    return parseInt(readFileSync(PID_FILE, "utf-8").trim());
-  } catch {
-    return null;
-  }
-}
-
-export function writePid(pid: number): void {
-  ensureDataDir();
-  writeFileSync(PID_FILE, String(pid));
-}
-
-export function removePid(): void {
-  try {
-    unlinkSync(PID_FILE);
-  } catch {}
-}
-
-export function isRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}