codex-rotating-proxy 0.1.0 → 0.1.2

package/dist/pool.js

@@ -0,0 +1,112 @@
+export class AccountPool {
+    states;
+    index = 0;
+    cooldownMs;
+    constructor(accounts, cooldownMinutes) {
+        this.cooldownMs = cooldownMinutes * 60_000;
+        this.states = accounts.map((account) => ({
+            account,
+            status: "ready",
+            cooldownUntil: 0,
+            totalRequests: 0,
+            errors: 0,
+        }));
+    }
+    get size() {
+        return this.states.length;
+    }
+    /** Sticky — stays on current account until it hits a limit, then rotates. */
+    getNext() {
+        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) {
+        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) {
+        // 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",
+                cooldownUntil: 0,
+                totalRequests: 0,
+                errors: 0,
+            };
+        });
+        if (this.index >= this.states.length)
+            this.index = 0;
+    }
+    updateToken(name, newToken) {
+        const state = this.states.find((s) => s.account.name === name);
+        if (state)
+            state.account.token = newToken;
+    }
+    getStatus() {
+        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 = {
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+};
+export function log(color, msg) {
+    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/dist/server.js

@@ -0,0 +1,303 @@
+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";
+import { chatToResponsesRequest, responsesToChatResponse, createStreamTranslator } from "./translate.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;
+        // ── Detect chat completions → responses translation ─────
+        const isChatCompletions = url.pathname === "/v1/chat/completions" && req.method === "POST";
+        let targetPath = url.pathname;
+        let parsedBody = null;
+        let isStreaming = false;
+        if (isChatCompletions && body) {
+            try {
+                parsedBody = JSON.parse(body.toString("utf-8"));
+                isStreaming = !!parsedBody.stream;
+                const translated = chatToResponsesRequest(parsedBody);
+                body = Buffer.from(JSON.stringify(translated));
+                targetPath = "/v1/responses";
+                log("cyan", `↔ translating chat/completions → responses`);
+            }
+            catch (err) {
+                log("red", `✗ failed to parse/translate body: ${err}`);
+                // fall through with original body
+            }
+        }
+        // ── 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}${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;
+            for (let retry = 0; retry < 2; retry++) {
+                try {
+                    const fetchRes = await fetch(target, {
+                        method: req.method,
+                        headers: {
+                            ...fwdHeaders,
+                            ...codexHeaders(entry.account),
+                            authorization: `Bearer ${currentToken}`,
+                            "accept-encoding": "identity",
+                            ...(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;
+                    }
+                    log("green", `✓ ${fetchRes.status}`);
+                    // ── Translate response if chat completions ─────────
+                    if (isChatCompletions && parsedBody) {
+                        if (isStreaming) {
+                            // Streaming: translate Responses SSE → Chat Completions SSE
+                            res.writeHead(200, {
+                                "content-type": "text/event-stream",
+                                "cache-control": "no-cache",
+                                "connection": "keep-alive",
+                            });
+                            const translator = createStreamTranslator(parsedBody.model);
+                            const reader = fetchRes.body.getReader();
+                            const decoder = new TextDecoder();
+                            let buffer = "";
+                            try {
+                                while (true) {
+                                    const { done, value } = await reader.read();
+                                    if (done)
+                                        break;
+                                    buffer += decoder.decode(value, { stream: true });
+                                    const lines = buffer.split("\n");
+                                    buffer = lines.pop() ?? "";
+                                    for (const line of lines) {
+                                        const trimmed = line.trim();
+                                        if (!trimmed)
+                                            continue;
+                                        const translated = translator.feed(trimmed);
+                                        for (const out of translated)
+                                            res.write(out);
+                                    }
+                                }
+                                // Process remaining buffer
+                                if (buffer.trim()) {
+                                    const translated = translator.feed(buffer.trim());
+                                    for (const out of translated)
+                                        res.write(out);
+                                }
+                                const flushed = translator.flush();
+                                for (const out of flushed)
+                                    res.write(out);
+                            }
+                            catch { }
+                            res.end();
+                        }
+                        else {
+                            // Non-streaming: buffer full response and translate
+                            const text = await fetchRes.text();
+                            try {
+                                const respBody = JSON.parse(text);
+                                const translated = responsesToChatResponse(respBody, parsedBody.model);
+                                json(res, 200, translated);
+                            }
+                            catch {
+                                // Can't parse — forward raw
+                                res.writeHead(fetchRes.status, { "content-type": "application/json" });
+                                res.end(text);
+                            }
+                        }
+                        return;
+                    }
+                    // ── Pass-through (non-translated) ─────────────────
+                    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/dist/translate.js

@@ -0,0 +1,248 @@
+// ── Chat Completions ↔ Responses API translation layer ─────────────
+// ── Request: Chat Completions → Responses ──────────────────────────
+export function chatToResponsesRequest(body) {
+    const out = { model: body.model };
+    // Extract system message → instructions
+    const messages = body.messages ?? [];
+    const systemMsgs = messages.filter((m) => m.role === "system");
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    if (systemMsgs.length > 0) {
+        out.instructions = systemMsgs
+            .map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content))
+            .join("\n");
+    }
+    // Convert messages → input
+    out.input = [];
+    for (const msg of nonSystem) {
+        if (msg.role === "user") {
+            out.input.push({ role: "user", content: convertInputContent(msg.content) });
+        }
+        else if (msg.role === "assistant") {
+            // Text part as a message item
+            if (msg.content) {
+                out.input.push({
+                    type: "message",
+                    role: "assistant",
+                    status: "completed",
+                    content: [{ type: "output_text", text: msg.content, annotations: [] }],
+                });
+            }
+            // Tool calls as separate function_call items
+            if (msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    out.input.push({
+                        type: "function_call",
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    });
+                }
+            }
+        }
+        else if (msg.role === "tool") {
+            out.input.push({
+                type: "function_call_output",
+                call_id: msg.tool_call_id,
+                output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            });
+        }
+    }
+    // Simple field mappings
+    if (body.stream !== undefined)
+        out.stream = body.stream;
+    if (body.temperature !== undefined)
+        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;
+    if (body.stop !== undefined)
+        out.stop = body.stop;
+    if (body.frequency_penalty !== undefined)
+        out.frequency_penalty = body.frequency_penalty;
+    if (body.presence_penalty !== undefined)
+        out.presence_penalty = body.presence_penalty;
+    if (body.user !== undefined)
+        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;
+    if (body.metadata !== undefined)
+        out.metadata = body.metadata;
+    // reasoning_effort
+    if (body.reasoning_effort !== undefined) {
+        out.reasoning = { effort: body.reasoning_effort };
+    }
+    // response_format → text.format
+    if (body.response_format) {
+        out.text = { format: body.response_format };
+    }
+    // tools: unwrap function wrapper
+    if (body.tools) {
+        out.tools = body.tools.map((t) => {
+            if (t.type === "function" && t.function) {
+                return { type: "function", ...t.function };
+            }
+            return t;
+        });
+    }
+    // tool_choice: translate object form
+    if (body.tool_choice !== undefined) {
+        if (typeof body.tool_choice === "object" && body.tool_choice.function) {
+            out.tool_choice = { type: "function", name: body.tool_choice.function.name };
+        }
+        else {
+            out.tool_choice = body.tool_choice;
+        }
+    }
+    return out;
+}
+function convertInputContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content;
+    return content.map((part) => {
+        if (part.type === "text")
+            return { type: "input_text", text: part.text };
+        if (part.type === "image_url")
+            return { type: "input_image", image_url: part.image_url.url ?? part.image_url };
+        return part;
+    });
+}
+// ── Response: Responses → Chat Completions (non-streaming) ─────────
+export function responsesToChatResponse(resp, model) {
+    const output = resp.output ?? [];
+    let textContent = "";
+    const toolCalls = [];
+    for (const item of output) {
+        if (item.type === "message" && item.content) {
+            for (const part of item.content) {
+                if (part.type === "output_text")
+                    textContent += part.text;
+            }
+        }
+        else if (item.type === "function_call") {
+            toolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments },
+            });
+        }
+    }
+    const finishReason = toolCalls.length > 0 ? "tool_calls" :
+        resp.status === "completed" ? "stop" :
+            resp.status === "incomplete" ? "length" : "stop";
+    const message = { role: "assistant", content: textContent || null };
+    if (toolCalls.length > 0)
+        message.tool_calls = toolCalls;
+    return {
+        id: resp.id?.replace(/^resp_/, "chatcmpl-") ?? "chatcmpl-proxy",
+        object: "chat.completion",
+        created: Math.floor(resp.created_at ?? Date.now() / 1000),
+        model: resp.model ?? model,
+        choices: [{ index: 0, message, finish_reason: finishReason, logprobs: null }],
+        usage: resp.usage ? {
+            prompt_tokens: resp.usage.input_tokens ?? 0,
+            completion_tokens: resp.usage.output_tokens ?? 0,
+            total_tokens: resp.usage.total_tokens ?? 0,
+        } : undefined,
+    };
+}
+export function createStreamTranslator(model) {
+    const id = `chatcmpl-${Date.now()}`;
+    let sentRole = false;
+    let toolCallIndex = -1;
+    const toolCallIds = new Map(); // item_id → index
+    function chunk(delta, finishReason = null) {
+        return `data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{ index: 0, delta, finish_reason: finishReason }],
+        })}\n\n`;
+    }
+    function usageChunk(usage) {
+        return `data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [],
+            usage: {
+                prompt_tokens: usage.input_tokens ?? 0,
+                completion_tokens: usage.output_tokens ?? 0,
+                total_tokens: usage.total_tokens ?? 0,
+            },
+        })}\n\n`;
+    }
+    return {
+        feed(line) {
+            if (!line.startsWith("data: "))
+                return [];
+            const jsonStr = line.slice(6).trim();
+            if (!jsonStr || jsonStr === "[DONE]")
+                return [];
+            let event;
+            try {
+                event = JSON.parse(jsonStr);
+            }
+            catch {
+                return [];
+            }
+            const results = [];
+            const type = event.type;
+            if (type === "response.output_item.added") {
+                // Role announcement on first message
+                if (event.item?.type === "message" && !sentRole) {
+                    sentRole = true;
+                    results.push(chunk({ role: "assistant", content: "" }));
+                }
+                // Function call start
+                if (event.item?.type === "function_call") {
+                    toolCallIndex++;
+                    toolCallIds.set(event.item.id, toolCallIndex);
+                    results.push(chunk({
+                        tool_calls: [{
+                                index: toolCallIndex,
+                                id: event.item.call_id,
+                                type: "function",
+                                function: { name: event.item.name, arguments: "" },
+                            }],
+                    }));
+                }
+            }
+            else if (type === "response.output_text.delta") {
+                if (!sentRole) {
+                    sentRole = true;
+                    results.push(chunk({ role: "assistant", content: "" }));
+                }
+                results.push(chunk({ content: event.delta }));
+            }
+            else if (type === "response.function_call_arguments.delta") {
+                const idx = toolCallIds.get(event.item_id) ?? 0;
+                results.push(chunk({
+                    tool_calls: [{ index: idx, function: { arguments: event.delta } }],
+                }));
+            }
+            else if (type === "response.completed") {
+                const resp = event.response;
+                const hasFnCalls = (resp?.output ?? []).some((o) => o.type === "function_call");
+                const finishReason = hasFnCalls ? "tool_calls" :
+                    resp?.status === "incomplete" ? "length" : "stop";
+                results.push(chunk({}, finishReason));
+                if (resp?.usage)
+                    results.push(usageChunk(resp.usage));
+                results.push("data: [DONE]\n\n");
+            }
+            return results;
+        },
+        flush() {
+            return [];
+        },
+    };
+}