codex-rotating-proxy 0.1.0 → 0.1.2

package/src/login.ts

@@ -1,261 +0,0 @@
-import { createServer } from "node:http";
-import { randomBytes, createHash } from "node:crypto";
-import { exec } from "node:child_process";
-import { addAccount, type Account } from "./config.ts";
-
-const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-const ISSUER = "https://auth.openai.com";
-const AUTHORIZE_URL = `${ISSUER}/oauth/authorize`;
-const TOKEN_URL = `${ISSUER}/oauth/token`;
-const SCOPES = "openid profile email offline_access";
-const REFRESH_SCOPES = "openid profile email";
-
-// ── PKCE ────────────────────────────────────────────────────────
-function generatePKCE(): { verifier: string; challenge: string } {
-  const verifier = randomBytes(64).toString("base64url");
-  const challenge = createHash("sha256").update(verifier).digest("base64url");
-  return { verifier, challenge };
-}
-
-// ── Login flow ──────────────────────────────────────────────────
-export async function loginFlow(accountName?: string): Promise<void> {
-  const { verifier, challenge } = generatePKCE();
-  const state = randomBytes(32).toString("base64url");
-
-  return new Promise<void>((resolve, reject) => {
-    let port: number = 1455;
-
-    const server = createServer(async (req, res) => {
-      const url = new URL(req.url ?? "/", `http://localhost:${port}`);
-
-      if (url.pathname !== "/auth/callback") {
-        res.writeHead(404);
-        res.end();
-        return;
-      }
-
-      const error = url.searchParams.get("error");
-      if (error) {
-        const desc = url.searchParams.get("error_description") ?? error;
-        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-        res.end(resultPage(false, desc));
-        finish(reject, server, new Error(desc));
-        return;
-      }
-
-      if (url.searchParams.get("state") !== state) {
-        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-        res.end(resultPage(false, "State mismatch — try again."));
-        finish(reject, server, new Error("state mismatch"));
-        return;
-      }
-
-      const code = url.searchParams.get("code")!;
-
-      try {
-        // Step 1: exchange authorization code for tokens
-        const tokens = await tokenRequest({
-          grant_type: "authorization_code",
-          code,
-          redirect_uri: `http://localhost:${port}/auth/callback`,
-          client_id: CLIENT_ID,
-          code_verifier: verifier,
-        });
-
-        // Step 2: exchange id_token for an OpenAI API key
-        const apiKey = await exchangeForApiKey(tokens.id_token);
-
-        // Parse JWT for display info + account ID
-        const claims = parseJwt(tokens.id_token);
-        const email = (claims.email as string) ?? "unknown";
-        const authClaims = (claims["https://api.openai.com/auth"] ?? {}) as Record<string, string>;
-        const accountId = authClaims.chatgpt_account_id;
-        const name = accountName || email.split("@")[0];
-
-        addAccount({
-          name,
-          token: apiKey,
-          refreshToken: tokens.refresh_token,
-          accountId,
-          addedAt: new Date().toISOString(),
-          lastRefresh: new Date().toISOString(),
-        });
-
-        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-        res.end(resultPage(true, `Connected as "${name}" (${email})`));
-
-        console.log(`\x1b[32m✓\x1b[0m Connected "${name}" (${email})`);
-        finish(resolve, server);
-      } catch (err: any) {
-        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-        res.end(resultPage(false, err.message));
-        finish(reject, server, err);
-      }
-    });
-
-    // Use port 1455 — same as official Codex CLI (registered redirect_uri)
-    server.listen(1455, () => {
-      port = 1455;
-
-      const params = new URLSearchParams({
-        response_type: "code",
-        client_id: CLIENT_ID,
-        redirect_uri: `http://localhost:${port}/auth/callback`,
-        scope: SCOPES,
-        code_challenge: challenge,
-        code_challenge_method: "S256",
-        state,
-      });
-
-      const authUrl = `${AUTHORIZE_URL}?${params}`;
-
-      console.log("  Opening browser to sign in with OpenAI...");
-      console.log(
-        `  If it doesn't open, visit:\n  \x1b[36m${authUrl}\x1b[0m\n`
-      );
-
-      openBrowser(authUrl);
-    });
-
-    server.on("error", (err: NodeJS.ErrnoException) => {
-      if (err.code === "EADDRINUSE") {
-        console.error(
-          "\x1b[31mPort 1455 is in use (maybe Codex CLI is running?).\x1b[0m"
-        );
-        console.error("Close it and try again.");
-      }
-      reject(err);
-    });
-  });
-}
-
-// ── Token refresh ───────────────────────────────────────────────
-export async function refreshAccount(
-  account: Account
-): Promise<string | null> {
-  if (!account.refreshToken) return null;
-
-  try {
-    const tokens = await tokenRequest({
-      client_id: CLIENT_ID,
-      grant_type: "refresh_token",
-      refresh_token: account.refreshToken,
-      scope: REFRESH_SCOPES,
-    });
-
-    const apiKey = await exchangeForApiKey(tokens.id_token);
-
-    addAccount({
-      ...account,
-      token: apiKey,
-      refreshToken: tokens.refresh_token,
-      lastRefresh: new Date().toISOString(),
-    });
-
-    return apiKey;
-  } catch {
-    return null;
-  }
-}
-
-// ── Helpers ─────────────────────────────────────────────────────
-async function tokenRequest(
-  params: Record<string, string>
-): Promise<{ id_token: string; access_token: string; refresh_token: string }> {
-  const res = await fetch(TOKEN_URL, {
-    method: "POST",
-    headers: { "content-type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams(params).toString(),
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Token request failed (${res.status}): ${text}`);
-  }
-
-  return res.json() as any;
-}
-
-async function exchangeForApiKey(idToken: string): Promise<string> {
-  const res = await tokenRequest({
-    grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
-    requested_token: "openai-api-key",
-    subject_token: idToken,
-    subject_token_type: "urn:ietf:params:oauth:token-type:id_token",
-    client_id: CLIENT_ID,
-  });
-
-  return res.access_token;
-}
-
-function parseJwt(token: string): Record<string, unknown> {
-  const payload = token.split(".")[1];
-  return JSON.parse(Buffer.from(payload, "base64url").toString());
-}
-
-function openBrowser(url: string): void {
-  const cmd =
-    process.platform === "darwin"
-      ? `open "${url}"`
-      : process.platform === "win32"
-        ? `start "" "${url}"`
-        : `xdg-open "${url}"`;
-  exec(cmd, () => {});
-}
-
-function finish(
-  cb: (value?: any) => void,
-  server: ReturnType<typeof createServer>,
-  err?: Error
-): void {
-  setTimeout(() => {
-    server.close();
-    if (err) cb(err);
-    else cb();
-  }, 500);
-}
-
-// ── Callback result page ────────────────────────────────────────
-function resultPage(success: boolean, message: string): string {
-  const icon = success ? "&#x2713;" : "&#x2717;";
-  const color = success ? "#3fb950" : "#f85149";
-  const title = success ? "Connected!" : "Something went wrong";
-  const sub = success
-    ? "You can close this tab and return to your terminal."
-    : "Check your terminal for details.";
-
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>codex-proxy</title>
-<style>
-  * { box-sizing: border-box; margin: 0; padding: 0; }
-  body {
-    background: #0d1117; color: #c9d1d9;
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
-    display: flex; justify-content: center; align-items: center;
-    min-height: 100vh; padding: 1rem;
-  }
-  .card {
-    background: #161b22; border: 1px solid #30363d;
-    border-radius: 12px; padding: 2.5rem;
-    max-width: 420px; width: 100%; text-align: center;
-  }
-  .icon { font-size: 3rem; color: ${color}; margin-bottom: 0.75rem; }
-  h1 { font-size: 1.4rem; margin-bottom: 0.5rem; color: ${color}; }
-  .msg { color: #c9d1d9; margin-bottom: 1rem; font-size: 0.95rem; }
-  .sub { color: #8b949e; font-size: 0.85rem; }
-</style>
-</head>
-<body>
-<div class="card">
-  <div class="icon">${icon}</div>
-  <h1>${title}</h1>
-  <p class="msg">${message}</p>
-  <p class="sub">${sub}</p>
-</div>
-</body>
-</html>`;
-}

package/src/pool.ts

@@ -1,136 +0,0 @@
-import type { Account } from "./config.ts";
-
-interface AccountState {
-  account: Account;
-  status: "ready" | "cooldown";
-  cooldownUntil: number;
-  totalRequests: number;
-  errors: number;
-}
-
-export class AccountPool {
-  private states: AccountState[];
-  private index = 0;
-  private cooldownMs: number;
-
-  constructor(accounts: Account[], cooldownMinutes: number) {
-    this.cooldownMs = cooldownMinutes * 60_000;
-    this.states = accounts.map((account) => ({
-      account,
-      status: "ready" as const,
-      cooldownUntil: 0,
-      totalRequests: 0,
-      errors: 0,
-    }));
-  }
-
-  get size(): number {
-    return this.states.length;
-  }
-
-  /** Sticky — stays on current account until it hits a limit, then rotates. */
-  getNext(): { account: Account; name: string } | null {
-    const now = Date.now();
-
-    for (const s of this.states) {
-      if (s.status === "cooldown" && now >= s.cooldownUntil) {
-        s.status = "ready";
-        log("green", `↩ ${s.account.name} back from cooldown`);
-      }
-    }
-
-    // Prefer current (sticky)
-    if (this.states[this.index]?.status === "ready") {
-      this.states[this.index].totalRequests++;
-      return {
-        account: this.states[this.index].account,
-        name: this.states[this.index].account.name,
-      };
-    }
-
-    // Find next ready
-    for (let i = 1; i < this.states.length; i++) {
-      const idx = (this.index + i) % this.states.length;
-      if (this.states[idx].status === "ready") {
-        this.index = idx;
-        this.states[idx].totalRequests++;
-        return {
-          account: this.states[idx].account,
-          name: this.states[idx].account.name,
-        };
-      }
-    }
-
-    return null;
-  }
-
-  markCooldown(name: string): void {
-    const state = this.states.find((s) => s.account.name === name);
-    if (!state) return;
-    state.status = "cooldown";
-    state.cooldownUntil = Date.now() + this.cooldownMs;
-    state.errors++;
-    const idx = this.states.indexOf(state);
-    this.index = (idx + 1) % this.states.length;
-    log(
-      "yellow",
-      `⏸ ${name} → cooldown for ${Math.round(this.cooldownMs / 60_000)}m`
-    );
-  }
-
-  reload(accounts: Account[]): void {
-    // Preserve state for existing accounts, add new ones
-    const oldMap = new Map(this.states.map((s) => [s.account.name, s]));
-    this.states = accounts.map((account) => {
-      const existing = oldMap.get(account.name);
-      if (existing) {
-        existing.account = account; // update token
-        return existing;
-      }
-      return {
-        account,
-        status: "ready" as const,
-        cooldownUntil: 0,
-        totalRequests: 0,
-        errors: 0,
-      };
-    });
-    if (this.index >= this.states.length) this.index = 0;
-  }
-
-  updateToken(name: string, newToken: string): void {
-    const state = this.states.find((s) => s.account.name === name);
-    if (state) state.account.token = newToken;
-  }
-
-  getStatus(): object[] {
-    const now = Date.now();
-    return this.states.map((s, i) => ({
-      name: s.account.name,
-      active: i === this.index && s.status === "ready",
-      status: s.status,
-      cooldownRemaining:
-        s.status === "cooldown"
-          ? Math.max(0, Math.ceil((s.cooldownUntil - now) / 60_000)) + "m"
-          : null,
-      totalRequests: s.totalRequests,
-      errors: s.errors,
-    }));
-  }
-}
-
-// ── Logging ─────────────────────────────────────────────────────
-const C: Record<string, string> = {
-  red: "\x1b[31m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  cyan: "\x1b[36m",
-  dim: "\x1b[2m",
-  reset: "\x1b[0m",
-};
-
-export function log(color: string, msg: string): void {
-  const c = C[color] ?? "";
-  const ts = new Date().toLocaleTimeString("en-US", { hour12: false });
-  console.log(`${C.dim}${ts}${C.reset} ${c}${msg}${C.reset}`);
-}

package/src/server.ts

@@ -1,247 +0,0 @@
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { execSync } from "node:child_process";
-import { type as osType, release, arch } from "node:os";
-import { getAccounts, getSettings, writePid, removePid, type Account } from "./config.ts";
-import { refreshAccount } from "./login.ts";
-import { AccountPool, log } from "./pool.ts";
-
-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: Record<string, string> = {
-  "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(): string {
-  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: Account): Record<string, string> {
-  const h: Record<string, string> = {
-    "user-agent": CODEX_USER_AGENT,
-    "originator": "codex_cli_rs",
-  };
-  if (account.accountId) {
-    h["chatgpt-account-id"] = account.accountId;
-  }
-  return h;
-}
-
-export function startProxy(): void {
-  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: IncomingMessage, res: ServerResponse) => {
-    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: Buffer[] = [];
-    for await (const chunk of req) chunks.push(chunk as Buffer);
-    let body = chunks.length > 0 ? Buffer.concat(chunks) : null;
-
-    // ── Forward headers ───────────────────────────────────────
-    const fwdHeaders: Record<string, string> = {};
-    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: Record<string, string> = {};
-          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 as ReadableStream<Uint8Array>).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: ServerResponse, status: number, data: unknown): void {
-  res.writeHead(status, { "content-type": "application/json" });
-  res.end(JSON.stringify(data, null, 2));
-}
-
-function forward(
-  res: ServerResponse,
-  status: number,
-  headers: Headers,
-  body: string
-): void {
-  const h: Record<string, string> = {};
-  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();
-}