codex-rotating-proxy 0.1.2 → 0.1.4

package/README.md

@@ -40,7 +40,7 @@ Then point your tool to `http://localhost:4000/v1`.
 
 ## Requirements
 
-Node.js 22.6+
+Node.js >= 18
 
 ## How login works
 
@@ -140,6 +140,13 @@ The built-in `openai` provider ignores `baseURL` overrides for Codex models. Ins
 
 You can add any OpenAI model to the `models` map — the proxy forwards whatever model the client requests.
 
+After adding the config, start opencode and connect the provider:
+
+1. Run `/connect` in opencode
+2. Search for your custom provider name (e.g. "Rotating OpenAI")
+3. Enter any dummy API key (e.g. `unused`) — the proxy handles auth
+4. Select the model you configured (e.g. `gpt-5.3-codex`)
+
 Start both:
 
 ```bash

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
+import { openSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
-import { getAccounts, getSettings, updateSettings, removeAccount, readPid, isRunning, removePid, ensureDataDir, LOG_FILE, } from "./config.js";
+import { getAccounts, getSettings, updateSettings, removeAccount, readPid, isRunning, removePid, ensureDataDir, rotateLogIfNeeded, LOG_FILE, } from "./config.js";
 import { loginFlow } from "./login.js";
 import { startProxy } from "./server.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const VERSION = "0.1.0";
+const VERSION = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version;
 // ── Parse args ──────────────────────────────────────────────────
 const args = process.argv.slice(2);
 const command = args[0];
@@ -79,6 +80,7 @@ function cmdStart() {
         updateSettings({ upstream });
     const isDaemon = flags.has("-d") || flags.has("--daemon");
     if (isDaemon) {
+        rotateLogIfNeeded();
         const logFd = openSync(LOG_FILE, "a");
         const child = spawn(process.execPath, [join(__dirname, "server.js")], {
             detached: true,
@@ -153,11 +155,29 @@ function cmdLogin() {
     return loginFlow(positional[0]);
 }
 // ── logout ──────────────────────────────────────────────────────
-function cmdLogout() {
-    const name = positional[0];
+async function cmdLogout() {
+    let name = positional[0];
     if (!name) {
-        console.log(red("Usage: codex-proxy logout <account-name>"));
-        return;
+        const accounts = getAccounts();
+        if (accounts.length === 0) {
+            console.log(dim("No accounts to remove."));
+            return;
+        }
+        console.log(`\n  ${bold("Select an account to remove:")}\n`);
+        for (let i = 0; i < accounts.length; i++) {
+            console.log(`  ${cyan(String(i + 1))}  ${accounts[i].name}  ${dim(maskToken(accounts[i].token))}`);
+        }
+        console.log();
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => {
+            rl.question("  Enter number: ", (a) => { rl.close(); resolve(a.trim()); });
+        });
+        const idx = parseInt(answer) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= accounts.length) {
+            console.log(red("Invalid selection."));
+            return;
+        }
+        name = accounts[idx].name;
     }
     if (removeAccount(name)) {
         console.log(green("✓") + ` Removed "${name}"`);

package/dist/config.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, renameSync, statSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 // ── Paths ───────────────────────────────────────────────────────
@@ -24,9 +24,11 @@ function readJson(path, fallback) {
         return fallback;
     }
 }
-function writeJson(path, data) {
+function writeJson(path, data, sensitive = false) {
     ensureDataDir();
     writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+    if (sensitive)
+        chmodSync(path, 0o600);
 }
 // ── Accounts ────────────────────────────────────────────────────
 export function getAccounts() {
@@ -40,14 +42,14 @@ export function addAccount(account) {
         accounts[idx] = account;
     else
         accounts.push(account);
-    writeJson(ACCOUNTS_FILE, { accounts });
+    writeJson(ACCOUNTS_FILE, { accounts }, true);
 }
 export function removeAccount(name) {
     const accounts = getAccounts();
     const filtered = accounts.filter((a) => a.name !== name);
     if (filtered.length === accounts.length)
         return false;
-    writeJson(ACCOUNTS_FILE, { accounts: filtered });
+    writeJson(ACCOUNTS_FILE, { accounts: filtered }, true);
     return true;
 }
 // ── Settings ────────────────────────────────────────────────────
@@ -88,3 +90,18 @@ export function isRunning(pid) {
         return false;
     }
 }
+const MAX_LOG_BYTES = 10 * 1024 * 1024; // 10 MB
+export function rotateLogIfNeeded() {
+    try {
+        const stats = statSync(LOG_FILE);
+        if (stats.size > MAX_LOG_BYTES) {
+            const rotated = LOG_FILE + ".1";
+            try {
+                unlinkSync(rotated);
+            }
+            catch { }
+            renameSync(LOG_FILE, rotated);
+        }
+    }
+    catch { }
+}

package/dist/login.js

@@ -51,17 +51,18 @@ export async function loginFlow(accountName) {
                     client_id: CLIENT_ID,
                     code_verifier: verifier,
                 });
-                // Step 2: exchange id_token for an OpenAI API key
-                const apiKey = await exchangeForApiKey(tokens.id_token);
+                // Use access_token directly (JWT bearer) — NOT an sk-proj-* API key.
+                // Codex models like gpt-5.3-codex require the JWT access token,
+                // not an exchanged API key.
                 // Parse JWT for display info + account ID
                 const claims = parseJwt(tokens.id_token);
                 const email = claims.email ?? "unknown";
                 const authClaims = (claims["https://api.openai.com/auth"] ?? {});
                 const accountId = authClaims.chatgpt_account_id;
-                const name = accountName || email.split("@")[0];
+                const name = accountName || (email.includes("@") ? email.split("@")[0] : email) || "account";
                 addAccount({
                     name,
-                    token: apiKey,
+                    token: tokens.access_token,
                     refreshToken: tokens.refresh_token,
                     accountId,
                     addedAt: new Date().toISOString(),
@@ -115,14 +116,13 @@ export async function refreshAccount(account) {
             refresh_token: account.refreshToken,
             scope: REFRESH_SCOPES,
         });
-        const apiKey = await exchangeForApiKey(tokens.id_token);
         addAccount({
             ...account,
-            token: apiKey,
+            token: tokens.access_token,
             refreshToken: tokens.refresh_token,
             lastRefresh: new Date().toISOString(),
         });
-        return apiKey;
+        return tokens.access_token;
     }
     catch {
         return null;
@@ -141,16 +141,6 @@ async function tokenRequest(params) {
     }
     return res.json();
 }
-async function exchangeForApiKey(idToken) {
-    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) {
     const payload = token.split(".")[1];
     return JSON.parse(Buffer.from(payload, "base64url").toString());

package/dist/pool.js

@@ -89,13 +89,19 @@ export class AccountPool {
             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"
+                ? formatCooldown(Math.max(0, s.cooldownUntil - now))
                 : null,
             totalRequests: s.totalRequests,
             errors: s.errors,
         }));
     }
 }
+function formatCooldown(ms) {
+    const sec = Math.ceil(ms / 1000);
+    if (sec < 60)
+        return `${sec}s`;
+    return `${Math.ceil(sec / 60)}m`;
+}
 // ── Logging ─────────────────────────────────────────────────────
 const C = {
     red: "\x1b[31m",

package/dist/server.js

@@ -6,6 +6,7 @@ import { refreshAccount } from "./login.js";
 import { AccountPool, log } from "./pool.js";
 import { chatToResponsesRequest, responsesToChatResponse, createStreamTranslator } from "./translate.js";
 const ROTATE_ON = new Set([429, 402]);
+const FETCH_TIMEOUT_MS = 120_000; // 2 minute timeout for upstream requests
 const STRIP_REQ = new Set([
     "host", "authorization", "connection", "content-length",
     "user-agent", "originator",
@@ -43,6 +44,8 @@ function buildUserAgent() {
     return `codex_cli_rs/0.1.0 (${os} ${ver}; ${arch()}) ${terminal}`;
 }
 const CODEX_USER_AGENT = buildUserAgent();
+// Dedup concurrent token refreshes per account
+const refreshInFlight = new Map();
 function codexHeaders(account) {
     const h = {
         "user-agent": CODEX_USER_AGENT,
@@ -83,6 +86,7 @@ export function startProxy() {
         // ── Detect chat completions → responses translation ─────
         const isChatCompletions = url.pathname === "/v1/chat/completions" && req.method === "POST";
         let targetPath = url.pathname;
+        let targetBase = upstream;
         let parsedBody = null;
         let isStreaming = false;
         if (isChatCompletions && body) {
@@ -90,9 +94,12 @@ export function startProxy() {
                 parsedBody = JSON.parse(body.toString("utf-8"));
                 isStreaming = !!parsedBody.stream;
                 const translated = chatToResponsesRequest(parsedBody);
+                log("cyan", `↔ translating chat/completions → responses (stream=${isStreaming})`);
+                log("cyan", `  request: ${JSON.stringify(translated).slice(0, 200)}`);
                 body = Buffer.from(JSON.stringify(translated));
-                targetPath = "/v1/responses";
-                log("cyan", `↔ translating chat/completions → responses`);
+                // Codex models (gpt-5.x-codex) use ChatGPT backend, not api.openai.com
+                targetBase = "https://chatgpt.com/backend-api";
+                targetPath = "/codex/responses";
             }
             catch (err) {
                 log("red", `✗ failed to parse/translate body: ${err}`);
@@ -111,7 +118,7 @@ export function startProxy() {
             const entry = pool.getNext();
             if (!entry)
                 break;
-            const target = `${upstream}${targetPath}${url.search}`;
+            const target = `${targetBase}${targetPath}${url.search}`;
             log("cyan", `→ ${req.method} ${targetPath} via ${entry.name}`);
             // Inner loop: try once, and if 401 + refreshable, refresh and retry
             let currentToken = entry.account.token;
@@ -127,12 +134,19 @@ export function startProxy() {
                             ...(body ? { "content-length": String(body.byteLength) } : {}),
                         },
                         body,
+                        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
                     });
                     // ── 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);
+                        let refreshPromise = refreshInFlight.get(entry.name);
+                        if (!refreshPromise) {
+                            refreshPromise = refreshAccount(entry.account);
+                            refreshInFlight.set(entry.name, refreshPromise);
+                            refreshPromise.finally(() => refreshInFlight.delete(entry.name));
+                        }
+                        const newToken = await refreshPromise;
                         if (newToken) {
                             currentToken = newToken;
                             entry.account.token = newToken;
@@ -153,7 +167,7 @@ export function startProxy() {
                     }
                     if (fetchRes.status === 403) {
                         const text = await fetchRes.text();
-                        if (/quota|limit|exceeded|rate/i.test(text)) {
+                        if (/rate.limit|quota.exceeded|usage.limit|too.many.requests|capacity/i.test(text)) {
                             log("red", `✗ ${entry.name} 403 quota — rotating`);
                             pool.markCooldown(entry.name);
                             break;
@@ -167,6 +181,10 @@ export function startProxy() {
                     if (isChatCompletions && parsedBody) {
                         if (isStreaming) {
                             // Streaming: translate Responses SSE → Chat Completions SSE
+                            if (!fetchRes.body) {
+                                json(res, 502, { error: { message: "No response body from upstream", type: "proxy_error" } });
+                                return;
+                            }
                             res.writeHead(200, {
                                 "content-type": "text/event-stream",
                                 "cache-control": "no-cache",
@@ -176,12 +194,16 @@ export function startProxy() {
                             const reader = fetchRes.body.getReader();
                             const decoder = new TextDecoder();
                             let buffer = "";
+                            let emittedCount = 0;
                             try {
                                 while (true) {
                                     const { done, value } = await reader.read();
                                     if (done)
                                         break;
-                                    buffer += decoder.decode(value, { stream: true });
+                                    const raw = decoder.decode(value, { stream: true });
+                                    if (emittedCount === 0)
+                                        log("cyan", `  upstream first chunk: ${raw.slice(0, 300).replace(/\n/g, "\\n")}`);
+                                    buffer += raw;
                                     const lines = buffer.split("\n");
                                     buffer = lines.pop() ?? "";
                                     for (const line of lines) {
@@ -189,35 +211,51 @@ export function startProxy() {
                                         if (!trimmed)
                                             continue;
                                         const translated = translator.feed(trimmed);
-                                        for (const out of translated)
+                                        for (const out of translated) {
+                                            if (emittedCount < 3)
+                                                log("cyan", `  emit[${emittedCount}]: ${out.slice(0, 200).replace(/\n/g, "\\n")}`);
                                             res.write(out);
+                                            emittedCount++;
+                                        }
                                     }
                                 }
                                 // Process remaining buffer
                                 if (buffer.trim()) {
                                     const translated = translator.feed(buffer.trim());
-                                    for (const out of translated)
+                                    for (const out of translated) {
                                         res.write(out);
+                                        emittedCount++;
+                                    }
                                 }
                                 const flushed = translator.flush();
-                                for (const out of flushed)
+                                for (const out of flushed) {
                                     res.write(out);
+                                    emittedCount++;
+                                }
                             }
-                            catch { }
+                            catch (err) {
+                                log("red", `  stream error: ${err}`);
+                                try {
+                                    res.write(`data: ${JSON.stringify({ error: { message: "Stream interrupted", type: "proxy_error" } })}\n\n`);
+                                }
+                                catch { }
+                            }
+                            log("cyan", `  stream done, emitted ${emittedCount} chunks`);
                             res.end();
                         }
                         else {
                             // Non-streaming: buffer full response and translate
                             const text = await fetchRes.text();
+                            log("cyan", `  upstream response: ${text.slice(0, 300)}`);
                             try {
                                 const respBody = JSON.parse(text);
                                 const translated = responsesToChatResponse(respBody, parsedBody.model);
+                                log("cyan", `  translated: ${JSON.stringify(translated).slice(0, 300)}`);
                                 json(res, 200, translated);
                             }
                             catch {
-                                // Can't parse — forward raw
-                                res.writeHead(fetchRes.status, { "content-type": "application/json" });
-                                res.end(text);
+                                log("red", `  failed to parse upstream response as JSON`);
+                                json(res, 502, { error: { message: "Invalid JSON response from upstream", type: "proxy_error" } });
                             }
                         }
                         return;
@@ -239,7 +277,9 @@ export function startProxy() {
                                 res.write(value);
                             }
                         }
-                        catch { }
+                        catch (err) {
+                            log("red", `  pass-through stream error: ${err}`);
+                        }
                         res.end();
                     }
                     else {

package/dist/translate.js

@@ -54,10 +54,7 @@ export function chatToResponsesRequest(body) {
         out.temperature = body.temperature;
     if (body.top_p !== undefined)
         out.top_p = body.top_p;
-    if (body.max_completion_tokens !== undefined)
-        out.max_output_tokens = body.max_completion_tokens;
-    else if (body.max_tokens !== undefined)
-        out.max_output_tokens = body.max_tokens;
+    // Note: ChatGPT backend doesn't support max_output_tokens, skip it
     if (body.stop !== undefined)
         out.stop = body.stop;
     if (body.frequency_penalty !== undefined)
@@ -68,8 +65,7 @@ export function chatToResponsesRequest(body) {
         out.user = body.user;
     if (body.parallel_tool_calls !== undefined)
         out.parallel_tool_calls = body.parallel_tool_calls;
-    if (body.store !== undefined)
-        out.store = body.store;
+    out.store = false; // ChatGPT backend requires store=false
     if (body.metadata !== undefined)
         out.metadata = body.metadata;
     // reasoning_effort
@@ -155,6 +151,7 @@ export function responsesToChatResponse(resp, model) {
 export function createStreamTranslator(model) {
     const id = `chatcmpl-${Date.now()}`;
     let sentRole = false;
+    let sentDone = false;
     let toolCallIndex = -1;
     const toolCallIds = new Map(); // item_id → index
     function chunk(delta, finishReason = null) {
@@ -239,9 +236,40 @@ export function createStreamTranslator(model) {
                     results.push(usageChunk(resp.usage));
                 results.push("data: [DONE]\n\n");
             }
+            else if (type === "error") {
+                // Forward API errors as Chat Completions error format
+                const err = event.error ?? {};
+                results.push(`data: ${JSON.stringify({
+                    error: {
+                        message: err.message ?? "Unknown error",
+                        type: err.type ?? "api_error",
+                        code: err.code ?? null,
+                    },
+                })}\n\n`);
+                results.push("data: [DONE]\n\n");
+            }
+            else if (type === "response.failed") {
+                const resp = event.response;
+                const err = resp?.error ?? {};
+                if (!sentDone) {
+                    results.push(`data: ${JSON.stringify({
+                        error: {
+                            message: err.message ?? "Response failed",
+                            type: "api_error",
+                            code: err.code ?? null,
+                        },
+                    })}\n\n`);
+                    results.push("data: [DONE]\n\n");
+                }
+            }
+            if (results.some(r => r.includes("[DONE]")))
+                sentDone = true;
             return results;
         },
         flush() {
+            // If stream ended without a proper termination, send [DONE]
+            if (!sentDone)
+                return ["data: [DONE]\n\n"];
             return [];
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-rotating-proxy",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenAI API proxy that rotates between multiple accounts when rate limits hit",
   "type": "module",
   "bin": {
@@ -22,6 +22,10 @@
     "chatgpt",
     "codex"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uvlad23/codex-rotating-proxy.git"
+  },
   "license": "MIT",
   "engines": {
     "node": ">=18.0.0"