codex-claude-proxy 1.0.0

package/src/cli/accounts.js

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline/promises';
+import { stdin, stdout } from 'process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { spawn } from 'child_process';
+import net from 'net';
+import { homedir } from 'os';
+import { join } from 'path';
+import crypto from 'crypto';
+
+const CONFIG_DIR = join(homedir(), '.codex-claude-proxy');
+const ACCOUNTS_FILE = join(CONFIG_DIR, 'accounts.json');
+const DEFAULT_PORT = 8081;
+
+const OAUTH_CONFIG = {
+    clientId: 'app_EMoamEEZ73f0CkXaXp7hrann',
+    authUrl: 'https://auth.openai.com/oauth/authorize',
+    tokenUrl: 'https://auth.openai.com/oauth/token',
+    scopes: ['openid', 'profile', 'email', 'offline_access'],
+    callbackPort: 1455,
+    callbackPath: '/auth/callback'
+};
+
+function loadAccounts() {
+    try {
+        if (existsSync(ACCOUNTS_FILE)) {
+            const data = readFileSync(ACCOUNTS_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    } catch (error) {
+        console.error('Error loading accounts:', error.message);
+    }
+    return { accounts: [], activeAccount: null, version: 1 };
+}
+
+function saveAccounts(data) {
+    try {
+        const dir = dirname(ACCOUNTS_FILE);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(ACCOUNTS_FILE, JSON.stringify(data, null, 2));
+        console.log(`\n✓ Saved ${data.accounts.length} account(s) to ${ACCOUNTS_FILE}`);
+    } catch (error) {
+        console.error('Error saving accounts:', error.message);
+        throw error;
+    }
+}
+
+function displayAccounts(data) {
+    if (!data.accounts || data.accounts.length === 0) {
+        console.log('\nNo accounts configured.');
+        return;
+    }
+
+    console.log(`\n${data.accounts.length} account(s) saved:`);
+    data.accounts.forEach((acc, i) => {
+        const active = acc.email === data.activeAccount ? ' (ACTIVE)' : '';
+        console.log(`  ${i + 1}. ${acc.email}${active}`);
+    });
+}
+
+function generatePKCE() {
+    const verifier = crypto.randomBytes(32).toString('base64url');
+    const challenge = crypto
+        .createHash('sha256')
+        .update(verifier)
+        .digest('base64url');
+    return { verifier, challenge };
+}
+
+function generateState() {
+    return crypto.randomBytes(16).toString('hex');
+}
+
+function getAuthorizationUrl(verifier, state, port) {
+    const challenge = crypto
+        .createHash('sha256')
+        .update(verifier)
+        .digest('base64url');
+    
+    const redirectUri = `http://localhost:${port}${OAUTH_CONFIG.callbackPath}`;
+    
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: OAUTH_CONFIG.clientId,
+        redirect_uri: redirectUri,
+        scope: OAUTH_CONFIG.scopes.join(' '),
+        code_challenge: challenge,
+        code_challenge_method: 'S256',
+        state: state,
+        prompt: 'login',
+        max_age: '0'
+    });
+    
+    return `${OAUTH_CONFIG.authUrl}?${params.toString()}`;
+}
+
+function decodeJWT(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) return null;
+        const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+        return JSON.parse(payload);
+    } catch (e) {
+        return null;
+    }
+}
+
+function extractAccountInfo(accessToken) {
+    const payload = decodeJWT(accessToken);
+    if (!payload) return null;
+    
+    const authInfo = payload['https://api.openai.com/auth'] || {};
+    const profileInfo = payload['https://api.openai.com/profile'] || {};
+    
+    return {
+        accountId: authInfo.chatgpt_account_id || null,
+        planType: authInfo.chatgpt_plan_type || 'free',
+        userId: authInfo.chatgpt_user_id || payload.sub || null,
+        email: profileInfo.email || payload.email || null,
+        expiresAt: payload.exp ? payload.exp * 1000 : null
+    };
+}
+
+async function exchangeCodeForTokens(code, verifier, port) {
+    const redirectUri = `http://localhost:${port}${OAUTH_CONFIG.callbackPath}`;
+    
+    const response = await fetch(OAUTH_CONFIG.tokenUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams({
+            grant_type: 'authorization_code',
+            code: code,
+            redirect_uri: redirectUri,
+            client_id: OAUTH_CONFIG.clientId,
+            code_verifier: verifier
+        })
+    });
+    
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Token exchange failed: ${response.status} - ${error}`);
+    }
+    
+    const tokens = await response.json();
+    
+    return {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        idToken: tokens.id_token,
+        expiresIn: tokens.expires_in
+    };
+}
+
+function extractCodeFromInput(input) {
+    if (!input || typeof input !== 'string') {
+        throw new Error('No input provided');
+    }
+
+    const trimmed = input.trim();
+
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+        try {
+            const url = new URL(trimmed);
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+
+            if (error) {
+                throw new Error(`OAuth error: ${error}`);
+            }
+
+            if (!code) {
+                throw new Error('No authorization code found in URL');
+            }
+
+            return { code };
+        } catch (e) {
+            if (e.message.includes('OAuth error') || e.message.includes('No authorization code')) {
+                throw e;
+            }
+            throw new Error('Invalid URL format');
+        }
+    }
+
+    if (trimmed.length < 10) {
+        throw new Error('Input is too short to be a valid authorization code');
+    }
+
+    return { code: trimmed };
+}
+
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    let args;
+
+    if (platform === 'darwin') {
+        command = 'open';
+        args = [url];
+    } else if (platform === 'win32') {
+        command = 'cmd';
+        args = ['/c', 'start', '', url.replace(/&/g, '^&')];
+    } else {
+        command = 'xdg-open';
+        args = [url];
+    }
+
+    const child = spawn(command, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {
+        console.log('\n⚠ Could not open browser automatically.');
+        console.log('Please open this URL manually:', url);
+    });
+    child.unref();
+}
+
+function isServerRunning(port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        socket.setTimeout(1000);
+
+        socket.on('connect', () => {
+            socket.destroy();
+            resolve(true);
+        });
+
+        socket.on('timeout', () => {
+            socket.destroy();
+            resolve(false);
+        });
+
+        socket.on('error', () => {
+            socket.destroy();
+            resolve(false);
+        });
+
+        socket.connect(port, 'localhost');
+    });
+}
+
+async function ensureServerStopped(port) {
+    const isRunning = await isServerRunning(port);
+    if (isRunning) {
+        console.error(`
+\x1b[31mError: Proxy server is currently running on port ${port}.\x1b[0m
+
+Please stop the server (Ctrl+C) before adding or managing accounts.
+This ensures that your account changes are loaded correctly.
+`);
+        process.exit(1);
+    }
+}
+
+function createRL() {
+    return createInterface({ input: stdin, output: stdout });
+}
+
+async function addAccountManual(rl) {
+    console.log('\n=== Add ChatGPT Account (No-Browser Mode) ===\n');
+    
+    const { verifier } = generatePKCE();
+    const state = generateState();
+    const url = getAuthorizationUrl(verifier, state, OAUTH_CONFIG.callbackPort);
+
+    console.log('Copy the following URL and open it in a browser on another device:\n');
+    console.log(`   ${url}\n`);
+    console.log('After signing in, you will be redirected to a localhost URL.');
+    console.log('Copy the ENTIRE redirect URL or just the authorization code.\n');
+
+    const input = await rl.question('Paste the callback URL or authorization code: ');
+
+    try {
+        const { code } = extractCodeFromInput(input);
+
+        console.log('\nExchanging authorization code for tokens...');
+        const tokens = await exchangeCodeForTokens(code, verifier, OAUTH_CONFIG.callbackPort);
+        const accountInfo = extractAccountInfo(tokens.accessToken);
+
+        const data = loadAccounts();
+        
+        const existingIndex = data.accounts.findIndex(a => a.email === accountInfo?.email);
+        const newAccount = {
+            email: accountInfo?.email || 'unknown',
+            accountId: accountInfo?.accountId,
+            planType: accountInfo?.planType || 'free',
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken,
+            idToken: tokens.idToken,
+            expiresAt: accountInfo?.expiresAt || (Date.now() + tokens.expiresIn * 1000),
+            addedAt: new Date().toISOString(),
+            lastUsed: null
+        };
+
+        if (existingIndex >= 0) {
+            data.accounts[existingIndex] = newAccount;
+            console.log(`\n⚠ Account ${newAccount.email} already exists. Updating tokens.`);
+        } else {
+            data.accounts.push(newAccount);
+            if (!data.activeAccount) {
+                data.activeAccount = newAccount.email;
+            }
+        }
+
+        saveAccounts(data);
+        console.log(`\n✓ Successfully authenticated: ${newAccount.email}`);
+        
+    } catch (error) {
+        console.error(`\n✗ Authentication failed: ${error.message}`);
+    }
+}
+
+async function addAccountBrowser() {
+    console.log('\n=== Add ChatGPT Account ===\n');
+
+    const { verifier } = generatePKCE();
+    const state = generateState();
+    const url = getAuthorizationUrl(verifier, state, OAUTH_CONFIG.callbackPort);
+
+    console.log('Opening browser for ChatGPT sign-in...');
+    console.log('(If browser does not open, copy this URL manually)\n');
+    console.log(`   ${url}\n`);
+
+    openBrowser(url);
+    
+    console.log('After authorization, complete the flow via:');
+    console.log(`  curl -X POST http://localhost:${DEFAULT_PORT}/accounts/add/manual \\`);
+    console.log(`    -H "Content-Type: application/json" \\`);
+    console.log(`    -d '{"code":"<auth_code>","verifier":"${verifier}"}'`);
+}
+
+async function listAccounts() {
+    const data = loadAccounts();
+    displayAccounts(data);
+    if (data.accounts.length > 0) {
+        console.log(`\nConfig file: ${ACCOUNTS_FILE}`);
+    }
+}
+
+async function clearAccounts(rl) {
+    const data = loadAccounts();
+
+    if (!data.accounts || data.accounts.length === 0) {
+        console.log('No accounts to clear.');
+        return;
+    }
+
+    displayAccounts(data);
+
+    const confirm = await rl.question('\nAre you sure you want to remove all accounts? [y/N]: ');
+    if (confirm.toLowerCase() === 'y') {
+        data.accounts = [];
+        data.activeAccount = null;
+        saveAccounts(data);
+        console.log('All accounts removed.');
+    } else {
+        console.log('Cancelled.');
+    }
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || 'help';
+    const noBrowser = args.includes('--no-browser');
+    const port = parseInt(args.find(a => a.startsWith('--port='))?.split('=')[1]) || DEFAULT_PORT;
+
+    console.log('╔════════════════════════════════════════╗');
+    console.log('║   Codex Proxy Account Manager         ║');
+    console.log('║   Use --no-browser for headless mode   ║');
+    console.log('╚════════════════════════════════════════╝');
+
+    const rl = createRL();
+
+    try {
+        switch (command) {
+            case 'add':
+                if (noBrowser) {
+                    await addAccountManual(rl);
+                } else {
+                    await ensureServerStopped(port);
+                    await addAccountBrowser();
+                }
+                break;
+            case 'list':
+                await listAccounts();
+                break;
+            case 'clear':
+                await ensureServerStopped(port);
+                await clearAccounts(rl);
+                break;
+            case 'help':
+            default:
+                console.log('\nUsage:');
+                console.log('  node src/cli/accounts.js add           Add account (opens browser)');
+                console.log('  node src/cli/accounts.js add --no-browser  Add account (manual code)');
+                console.log('  node src/cli/accounts.js list         List all accounts');
+                console.log('  node src/cli/accounts.js clear        Remove all accounts');
+                console.log('  node src/cli/accounts.js help         Show this help');
+                console.log('\nOptions:');
+                console.log('  --no-browser    Manual authorization code input (for headless servers)');
+                console.log('  --port=<port>   Server port (default: 8081)');
+                break;
+        }
+    } finally {
+        rl.close();
+        process.exit(0);
+    }
+}
+
+main().catch(console.error);

package/src/cli/index.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * codex-claude-proxy CLI
+ *
+ * Antigravity-style UX:
+ *   codex-claude-proxy start
+ *   codex-claude-proxy accounts <subcommand>
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function printHelp() {
+  console.log(`\nCodex Claude Proxy\n\nUsage:\n  codex-claude-proxy start [--port <port>]\n  codex-claude-proxy accounts <add|list|...> [args]\n\nNotes:\n  - \'start\' runs the proxy server\n  - \'accounts\' delegates to the accounts CLI\n`);
+}
+
+function runNodeScript(scriptPath, args) {
+  const child = spawn(process.execPath, [scriptPath, ...args], {
+    stdio: 'inherit',
+    env: process.env
+  });
+  child.on('exit', (code) => process.exit(code ?? 0));
+}
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+
+if (!cmd || cmd === '-h' || cmd === '--help' || cmd === 'help') {
+  printHelp();
+  process.exit(0);
+}
+
+if (cmd === 'start') {
+  // Pass through args like --port to the server via env or args.
+  // Current server reads PORT from env, so we translate --port into PORT.
+  const args = argv.slice(1);
+
+  const portFlagIndex = args.findIndex((a) => a === '--port' || a === '-p');
+  if (portFlagIndex !== -1) {
+    const portValue = args[portFlagIndex + 1];
+    if (!portValue || String(Number(portValue)) !== portValue) {
+      console.error('Invalid port. Usage: codex-claude-proxy start --port <port>');
+      process.exit(1);
+    }
+    process.env.PORT = portValue;
+    args.splice(portFlagIndex, 2);
+  }
+
+  const serverEntrypoint = join(__dirname, '..', 'index.js');
+  runNodeScript(serverEntrypoint, args);
+  process.exit(0);
+}
+
+if (cmd === 'accounts') {
+  const accountsEntrypoint = join(__dirname, 'accounts.js');
+  runNodeScript(accountsEntrypoint, argv.slice(1));
+  process.exit(0);
+}
+
+console.error(`Unknown command: ${cmd}`);
+printHelp();
+process.exit(1);

package/src/direct-api.js

@@ -0,0 +1,123 @@
+/**
+ * Direct API Client
+ * Makes direct HTTP calls to ChatGPT's backend API
+ */
+
+import { convertAnthropicToResponsesAPI, convertOutputToAnthropic, generateMessageId } from './format-converter.js';
+import { streamResponsesAPI, parseResponsesAPIResponse } from './response-streamer.js';
+
+const API_URL = 'https://chatgpt.com/backend-api/codex/responses';
+
+/**
+ * Send a streaming request to ChatGPT API
+ */
+export async function* sendMessageStream(anthropicRequest, accessToken, accountId) {
+    const request = convertAnthropicToResponsesAPI(anthropicRequest);
+    
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        },
+        body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        
+        if (response.status === 401) {
+            throw new Error('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.');
+        }
+        
+        if (response.status === 429) {
+            throw new Error(`RATE_LIMITED: ${errorText}`);
+        }
+        
+        if (response.status === 403) {
+            if (errorText.includes('challenge') || errorText.includes('cloudflare')) {
+                throw new Error('CLOUDFLARE_BLOCKED: Request blocked by Cloudflare.');
+            }
+            throw new Error(`FORBIDDEN: ${errorText}`);
+        }
+        
+        if (response.status === 400) {
+            throw new Error(`INVALID_REQUEST: ${errorText}`);
+        }
+        
+        throw new Error(`API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    yield* streamResponsesAPI(response, anthropicRequest.model);
+}
+
+/**
+ * Send a non-streaming request to ChatGPT API
+ */
+export async function sendMessage(anthropicRequest, accessToken, accountId) {
+    const request = convertAnthropicToResponsesAPI({
+        ...anthropicRequest,
+        stream: false
+    });
+    
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        },
+        body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        
+        if (response.status === 401) {
+            throw new Error('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.');
+        }
+        
+        throw new Error(`API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    const apiResponse = await parseResponsesAPIResponse(response);
+    
+    if (!apiResponse) {
+        return {
+            id: generateMessageId(),
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'text', text: '' }],
+            model: anthropicRequest.model,
+            stop_reason: 'end_turn',
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+        };
+    }
+
+    const content = convertOutputToAnthropic(apiResponse.output);
+    const stopReason = content.some(c => c.type === 'tool_use') ? 'tool_use' : 'end_turn';
+
+    return {
+        id: generateMessageId(),
+        type: 'message',
+        role: 'assistant',
+        content: content,
+        model: anthropicRequest.model,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: apiResponse.usage?.input_tokens || 0,
+            output_tokens: apiResponse.usage?.output_tokens || 0,
+            cache_read_input_tokens: apiResponse.usage?.cache_read_input_tokens || 0
+        }
+    };
+}
+
+export default {
+    sendMessageStream,
+    sendMessage
+};