@pikoloo/codex-proxy 1.0.7 → 1.1.0

package/public/js/app.js

@@ -10,7 +10,6 @@ document.addEventListener('alpine:init', () => {
         version: '1.0.7',
         connectionStatus: 'connecting',
         activeTab: initialTab(),
-        sidebarOpen: window.innerWidth >= 1024,
         loading: false,
         toast: null,
         currentTime: '',
@@ -49,10 +48,7 @@ document.addEventListener('alpine:init', () => {
         reasoningLevelOptions: [],
         modelMappingSaving: null,
         reasoningMappingSaving: null,
-        accountStrategy: 'sticky',
-        multiAccountRotationEnabled: false,
         haikuModelSaving: false,
-        strategySaving: false,
         configureClaudeOnStartup: false,
         claudeProxyConfiguring: false,
         claudeProxyStartupSaving: false,
@@ -73,32 +69,72 @@ document.addEventListener('alpine:init', () => {
         
         testPrompt: 'Say hello',
         testResponse: '',
+        testStatus: 'idle',
+        testError: '',
+        testMeta: null,
         testing: false,
 
         haikuTestPrompt: 'Say hello',
         haikuTestResponse: '',
+        haikuTestStatus: 'idle',
+        haikuTestError: '',
+        haikuTestMeta: null,
         haikuTesting: false,
 
         haikuModelLabel() {
             return this.modelOptionName(this.modelMappings?.haiku || 'gpt-5.4-mini');
         },
 
+        get testStatusText() {
+            const labels = {
+                idle: 'Ready',
+                running: 'Sending request',
+                success: 'Response received',
+                error: 'Request failed'
+            };
+            return labels[this.testStatus] || 'Ready';
+        },
+
+        get haikuTestStatusText() {
+            const labels = {
+                idle: 'Ready',
+                running: 'Sending Haiku request',
+                success: 'Response received',
+                error: 'Request failed'
+            };
+            return labels[this.haikuTestStatus] || 'Ready';
+        },
+
         async testHaikuChat() {
             if (!this.haikuTestPrompt.trim()) return;
+            const startedAt = Date.now();
             this.haikuTesting = true;
             this.haikuTestResponse = '';
-            const { ok, data } = await this.api('/v1/chat/completions', {
-                method: 'POST',
-                body: JSON.stringify({
-                    model: 'claude-haiku-4',
-                    messages: [{ role: 'user', content: this.haikuTestPrompt }]
-                })
-            });
-            this.haikuTesting = false;
-            if (ok && data.choices) {
-                this.haikuTestResponse = data.choices[0].message.content;
-            } else {
-                this.haikuTestResponse = data?.error?.message || 'Request failed';
+            this.haikuTestStatus = 'running';
+            this.haikuTestError = '';
+            this.haikuTestMeta = null;
+
+            try {
+                const { ok, data, error } = await this.api('/v1/chat/completions', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        model: 'claude-haiku-4',
+                        messages: [{ role: 'user', content: this.haikuTestPrompt }]
+                    })
+                });
+                const durationMs = Date.now() - startedAt;
+                this.haikuTestMeta = { durationMs, usage: data?.usage || null };
+
+                if (ok && data.choices) {
+                    this.haikuTestResponse = data.choices[0].message.content;
+                    this.haikuTestStatus = 'success';
+                } else {
+                    this.haikuTestError = data?.error?.message || error || 'Request failed';
+                    this.haikuTestResponse = this.haikuTestError;
+                    this.haikuTestStatus = 'error';
+                }
+            } finally {
+                this.haikuTesting = false;
             }
         },
         
@@ -109,6 +145,7 @@ document.addEventListener('alpine:init', () => {
         logSearchQuery: '',
         logFilters: { INFO: true, SUCCESS: true, WARN: true, ERROR: true, DEBUG: false },
         logEventSource: null,
+        logStreamStatus: 'connecting',
 
         get filteredLogs() {
             const query = this.logSearchQuery.trim().toLowerCase();
@@ -119,6 +156,13 @@ document.addEventListener('alpine:init', () => {
             });
         },
 
+        get logLevelCounts() {
+            return this.logs.reduce((counts, log) => {
+                counts[log.level] = (counts[log.level] || 0) + 1;
+                return counts;
+            }, { INFO: 0, SUCCESS: 0, WARN: 0, ERROR: 0, DEBUG: 0 });
+        },
+
         get filteredAccounts() {
             if (!this.searchQuery) return this.accounts;
             const q = this.searchQuery.toLowerCase();
@@ -159,14 +203,9 @@ document.addEventListener('alpine:init', () => {
             this.startLogStream();
             this.loadModelMappingsSetting();
             this.loadHaikuModelSetting();
-            this.loadAccountStrategySetting();
             this.loadClaudeProxySetting();
             this.loadMetrics();
 
-            window.addEventListener('resize', () => {
-                this.sidebarOpen = window.innerWidth >= 1024;
-            });
-
             window.addEventListener('message', (event) => {
                 if (event.data && event.data.type === 'oauth-success') {
                     this.showToast(`Account ${event.data.email} added!`, 'success');
@@ -195,9 +234,6 @@ document.addEventListener('alpine:init', () => {
                 nextUrl.hash = '';
             }
             window.history.replaceState({}, '', nextUrl);
-            if (window.innerWidth < 1024) {
-                this.sidebarOpen = false;
-            }
         },
 
         async api(endpoint, options = {}) {
@@ -305,6 +341,15 @@ document.addEventListener('alpine:init', () => {
             return `${number}ms`;
         },
 
+        formatUsageSummary(usage) {
+            if (!usage) return '';
+            const input = Number(usage.prompt_tokens ?? usage.input_tokens) || 0;
+            const output = Number(usage.completion_tokens ?? usage.output_tokens) || 0;
+            const total = Number(usage.total_tokens ?? (input + output)) || 0;
+            if (total <= 0) return '';
+            return `${this.formatTokenCount(total)} tokens (${this.formatTokenCount(input)} in, ${this.formatTokenCount(output)} out)`;
+        },
+
         formatBytes(value) {
             const number = Number(value) || 0;
             if (number >= 1024 * 1024) return `${(number / (1024 * 1024)).toFixed(1)} MB`;
@@ -582,20 +627,34 @@ document.addEventListener('alpine:init', () => {
 
         async testChat() {
             if (!this.testPrompt.trim()) return;
+            const startedAt = Date.now();
             this.testing = true;
             this.testResponse = '';
-            const { ok, data } = await this.api('/v1/chat/completions', {
-                method: 'POST',
-                body: JSON.stringify({
-                    model: 'gpt-5.5',
-                    messages: [{ role: 'user', content: this.testPrompt }]
-                })
-            });
-            this.testing = false;
-            if (ok && data.choices) {
-                this.testResponse = data.choices[0].message.content;
-            } else {
-                this.testResponse = data?.error?.message || 'Request failed';
+            this.testStatus = 'running';
+            this.testError = '';
+            this.testMeta = null;
+
+            try {
+                const { ok, data, error } = await this.api('/v1/chat/completions', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        model: 'gpt-5.5',
+                        messages: [{ role: 'user', content: this.testPrompt }]
+                    })
+                });
+                const durationMs = Date.now() - startedAt;
+                this.testMeta = { durationMs, usage: data?.usage || null };
+
+                if (ok && data.choices) {
+                    this.testResponse = data.choices[0].message.content;
+                    this.testStatus = 'success';
+                } else {
+                    this.testError = data?.error?.message || error || 'Request failed';
+                    this.testResponse = this.testError;
+                    this.testStatus = 'error';
+                }
+            } finally {
+                this.testing = false;
             }
         },
 
@@ -725,31 +784,6 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
-        async loadAccountStrategySetting() {
-            const { ok, data } = await this.api('/settings/account-strategy');
-            if (ok && data?.accountStrategy) {
-                this.accountStrategy = data.accountStrategy;
-                this.multiAccountRotationEnabled = data.rotationEnabled === true;
-            }
-        },
-
-        async setAccountStrategy(strategy) {
-            if (!this.multiAccountRotationEnabled || this.strategySaving || this.accountStrategy === strategy) return;
-            this.strategySaving = true;
-            const { ok, data } = await this.api('/settings/account-strategy', {
-                method: 'POST',
-                body: JSON.stringify({ accountStrategy: strategy })
-            });
-            this.strategySaving = false;
-            if (ok && data?.accountStrategy) {
-                this.accountStrategy = data.accountStrategy;
-                this.multiAccountRotationEnabled = data.rotationEnabled === true;
-                this.showToast(`Account strategy set to ${data.accountStrategy === 'sticky' ? 'Sticky' : 'Round-Robin'}`, 'success');
-            } else {
-                this.showToast(data?.error || 'Failed to update strategy', 'error');
-            }
-        },
-
         async loadClaudeProxySetting() {
             const { ok, data } = await this.api('/settings/claude-proxy');
             if (ok && typeof data?.configureClaudeOnStartup === 'boolean') {
@@ -802,11 +836,16 @@ document.addEventListener('alpine:init', () => {
 
         startLogStream() {
             if (this.logEventSource) this.logEventSource.close();
-            
+
+            this.logStreamStatus = 'connecting';
             this.logEventSource = new EventSource('/api/logs/stream?history=true');
+            this.logEventSource.onopen = () => {
+                this.logStreamStatus = 'connected';
+            };
             this.logEventSource.onmessage = (event) => {
                 try {
                     const log = JSON.parse(event.data);
+                    this.logStreamStatus = 'connected';
                     this.logs.unshift(log);
                     
                     if (this.logs.length > 500) {
@@ -816,6 +855,8 @@ document.addEventListener('alpine:init', () => {
             };
             
             this.logEventSource.onerror = () => {
+                this.logStreamStatus = 'disconnected';
+                if (this.logEventSource) this.logEventSource.close();
                 setTimeout(() => this.startLogStream(), 3000);
             };
         },
@@ -833,6 +874,22 @@ document.addEventListener('alpine:init', () => {
             return message;
         },
 
+        formatLogTime(timestamp) {
+            if (!timestamp) return '--:--:--';
+            const date = new Date(timestamp);
+            if (Number.isNaN(date.getTime())) return '--:--:--';
+            return date.toLocaleTimeString([], { hour12: false });
+        },
+
+        logStreamStatusText() {
+            const labels = {
+                connecting: 'Connecting',
+                connected: 'Live',
+                disconnected: 'Reconnecting'
+            };
+            return labels[this.logStreamStatus] || 'Unknown';
+        },
+
         getLogDetails(message) {
             if (!message) return null;
             const details = {};

package/src/account-rotation/index.js

@@ -4,20 +4,20 @@ import {
     clearInvalid,
     isAllRateLimited,
     getMinWaitTimeMs,
-    clearExpiredLimits
+    clearExpiredLimits,
+    isAccountCoolingDown
 } from './rate-limits.js';
 
-import { createStrategy, STRATEGIES } from './strategies/index.js';
+const MAX_WAIT_BEFORE_ERROR_MS = 120000;
 
 export class AccountRotator {
-    constructor(accountManager, strategyName = 'sticky') {
+    constructor(accountManager) {
         this.accountManager = accountManager;
-        this.strategy = createStrategy(strategyName);
     }
 
-    selectAccount(modelId, options = {}) {
+    selectAccount(modelId) {
         const { accounts } = this.accountManager.listAccounts();
-        return this.strategy.selectAccount(accounts, modelId, options);
+        return selectAccount(accounts, modelId);
     }
 
     markRateLimited(email, resetMs, modelId) {
@@ -48,23 +48,11 @@ export class AccountRotator {
         return getMinWaitTimeMs(accounts, modelId);
     }
 
-    notifySuccess(account, modelId) {
-        if (this.strategy.notifySuccess) {
-            this.strategy.notifySuccess(account, modelId);
-        }
-    }
+    notifySuccess(account, modelId) {}
 
-    notifyRateLimit(account, modelId) {
-        if (this.strategy.notifyRateLimit) {
-            this.strategy.notifyRateLimit(account, modelId);
-        }
-    }
+    notifyRateLimit(account, modelId) {}
 
-    notifyFailure(account, modelId) {
-        if (this.strategy.notifyFailure) {
-            this.strategy.notifyFailure(account, modelId);
-        }
-    }
+    notifyFailure(account, modelId) {}
 
     clearExpiredLimits() {
         const { accounts } = this.accountManager.listAccounts();
@@ -72,18 +60,67 @@ export class AccountRotator {
         this.accountManager.save();
     }
 
-    getStrategyName() {
-        return this.strategy.name;
+}
+
+function selectAccount(accounts, modelId) {
+    if (!accounts || accounts.length === 0) {
+        return { account: null, index: 0, waitMs: 0 };
+    }
+
+    const activeIndex = accounts.findIndex((account) => account.isActive);
+    const startIndex = activeIndex >= 0 ? activeIndex : 0;
+
+    for (let offset = 0; offset < accounts.length; offset++) {
+        const index = (startIndex + offset) % accounts.length;
+        const account = accounts[index];
+
+        if (isAccountUsable(account, modelId)) {
+            account.lastUsed = Date.now();
+            return { account, index, waitMs: 0 };
+        }
     }
 
-    getStrategyLabel() {
-        return this.strategy.label;
+    const waitMs = getAccountWaitMs(accounts[startIndex], modelId);
+    if (waitMs > 0 && waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
+        return { account: null, index: startIndex, waitMs };
     }
+
+    return { account: null, index: startIndex, waitMs: 0 };
+}
+
+function isAccountUsable(account, modelId) {
+    if (!account) return false;
+    if (account.isInvalid) return false;
+    if (account.enabled === false) return false;
+    if (isAccountCoolingDown(account)) return false;
+
+    const waitMs = getModelRateLimitWaitMs(account, modelId);
+    return waitMs === 0;
+}
+
+function getAccountWaitMs(account, modelId) {
+    if (!account) return 0;
+    if (account.isInvalid) return 0;
+    if (account.enabled === false) return 0;
+    if (isAccountCoolingDown(account)) return 0;
+
+    return getModelRateLimitWaitMs(account, modelId);
+}
+
+function getModelRateLimitWaitMs(account, modelId) {
+    if (!modelId || !account?.modelRateLimits?.[modelId]) {
+        return 0;
+    }
+
+    const limit = account.modelRateLimits[modelId];
+    if (!limit?.isRateLimited || !limit.resetTime || limit.resetTime <= Date.now()) {
+        return 0;
+    }
+
+    return limit.resetTime - Date.now();
 }
 
 export {
-    createStrategy,
-    STRATEGIES,
     markRateLimited,
     markInvalid,
     clearInvalid,

package/src/index.js

@@ -14,7 +14,7 @@ startServer({ port: PORT, host: HOST });
 
 console.log(`
 ╔══════════════════════════════════════════════════════════════╗
-║                 Codex Claude Proxy v1.0.7                    ║
+║                 Codex Claude Proxy v1.1.0                    ║
 ║                   (Direct API Mode)                          ║
 ╠══════════════════════════════════════════════════════════════╣
 ║  Server:   http://${HOST}:${PORT}                          ║

package/src/routes/api-routes.js

@@ -21,8 +21,6 @@ import {
   handleGetKiloModels,
   handleGetModelMappings,
   handleSetModelMappings,
-  handleGetAccountStrategy,
-  handleSetAccountStrategy,
   handleGetClaudeProxySetting,
   handleSetClaudeProxySetting
 } from './settings-route.js';
@@ -77,8 +75,6 @@ export function registerApiRoutes(app, { port }) {
   app.get('/settings/kilo-models', handleGetKiloModels);
   app.get('/settings/model-mappings', handleGetModelMappings);
   app.post('/settings/model-mappings', handleSetModelMappings);
-  app.get('/settings/account-strategy', handleGetAccountStrategy);
-  app.post('/settings/account-strategy', handleSetAccountStrategy);
   app.get('/settings/claude-proxy', handleGetClaudeProxySetting);
   app.post('/settings/claude-proxy', handleSetClaudeProxySetting);
 

package/src/routes/chat-route.js

@@ -77,7 +77,7 @@ export async function handleChatCompletion(req, res) {
       : await sendMessage(anthropicRequest, creds.accessToken, creds.accountId);
 
     const duration = Date.now() - startTime;
-    logger.response(200, { model: upstreamModel, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: upstreamModel, usage: response.usage, duration });
     recordChatMetric({
       body,
       requestedModel,

package/src/routes/messages-route.js

@@ -5,8 +5,8 @@ import { sendAuthError, getCredentialsOrError, getCredentialsForAccount } from '
 import { initSSEResponse, pipeSSEStream, handleStreamError } from '../middleware/sse.js';
 import { logger } from '../utils/logger.js';
 import { AccountRotator } from '../account-rotation/index.js';
-import { listAccounts, getActiveAccount, save } from '../account-manager.js';
-import { getServerSettings, isMultiAccountRotationEnabled } from '../server-settings.js';
+import { listAccounts, save } from '../account-manager.js';
+import { isMultiAccountRotationEnabled } from '../server-settings.js';
 import { recordUsageEventSafe, tapUsageEventStream } from '../usage-metrics.js';
 
 const MAX_RETRIES = 5;
@@ -14,20 +14,14 @@ const MAX_WAIT_BEFORE_ERROR_MS = 120000;
 const SHORT_RATE_LIMIT_THRESHOLD_MS = 5000;
 
 let accountRotator = null;
-let currentStrategy = null;
 
 function getAccountRotator() {
-    const settings = getServerSettings();
-    const strategy = settings.accountStrategy || 'sticky';
-    
-    if (!accountRotator || currentStrategy !== strategy) {
+    if (!accountRotator) {
         accountRotator = new AccountRotator({
             listAccounts,
-            save,
-            getActiveAccount
-        }, strategy);
-        currentStrategy = strategy;
-        logger.info(`[Messages] Account strategy: ${strategy}`);
+            save
+        });
+        logger.info('[Messages] Account rotation enabled');
     }
     return accountRotator;
 }
@@ -246,7 +240,9 @@ export async function handleMessages(req, res) {
 async function _streamDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator) {
     initSSEResponse(res);
     const sourceStream = sendMessageStream(anthropicRequest, creds.accessToken, creds.accountId, rotator, creds.email);
+    let finalUsage = null;
     const stream = tapUsageEventStream(sourceStream, (usage) => {
+        finalUsage = usage;
         recordMessageMetric({
             body: anthropicRequest,
             endpoint: '/v1/messages',
@@ -261,13 +257,13 @@ async function _streamDirectWithRotation(res, anthropicRequest, creds, responseM
         });
     });
     await pipeSSEStream(res, stream);
-    logger.response(200, { model: anthropicRequest.model, duration: Date.now() - startTime });
+    logger.response(200, { model: anthropicRequest.model, usage: finalUsage, duration: Date.now() - startTime });
 }
 
 async function _sendDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator) {
     const response = await sendMessage(anthropicRequest, creds.accessToken, creds.accountId);
     const duration = Date.now() - startTime;
-    logger.response(200, { model: anthropicRequest.model, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: anthropicRequest.model, usage: response.usage, duration });
     recordMessageMetric({
         body: anthropicRequest,
         endpoint: '/v1/messages',
@@ -287,7 +283,9 @@ async function _sendDirectWithRotation(res, anthropicRequest, creds, responseMod
 async function _streamKilo(res, anthropicRequest, kiloTarget, responseModel, startTime) {
     initSSEResponse(res);
     const sourceStream = sendKiloMessageStream(anthropicRequest, kiloTarget);
+    let finalUsage = null;
     const stream = tapUsageEventStream(sourceStream, (usage) => {
+        finalUsage = usage;
         recordMessageMetric({
             body: anthropicRequest,
             endpoint: '/v1/messages',
@@ -302,13 +300,13 @@ async function _streamKilo(res, anthropicRequest, kiloTarget, responseModel, sta
         });
     });
     await pipeSSEStream(res, stream);
-    logger.response(200, { model: kiloTarget, duration: Date.now() - startTime });
+    logger.response(200, { model: kiloTarget, usage: finalUsage, duration: Date.now() - startTime });
 }
 
 async function _sendKilo(res, anthropicRequest, kiloTarget, responseModel, startTime) {
     const response = await sendKiloMessage(anthropicRequest, kiloTarget);
     const duration = Date.now() - startTime;
-    logger.response(200, { model: kiloTarget, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: kiloTarget, usage: response.usage, duration });
     recordMessageMetric({
         body: anthropicRequest,
         endpoint: '/v1/messages',

package/src/routes/settings-route.js

@@ -3,14 +3,12 @@
  * Handles server settings endpoints:
  *   GET  /settings/haiku-model
  *   POST /settings/haiku-model
- *   GET  /settings/account-strategy
- *   POST /settings/account-strategy
  *   GET  /settings/claude-proxy
  *   POST /settings/claude-proxy
  *   GET  /settings/kilo-models
  */
 
-import { getServerSettings, isMultiAccountRotationEnabled, setServerSettings } from '../server-settings.js';
+import { getServerSettings, setServerSettings } from '../server-settings.js';
 import { fetchFreeModels } from '../kilo-models.js';
 import {
   CLAUDE_MODEL_ALIASES,
@@ -23,7 +21,6 @@ import {
   normalizeReasoningMappings
 } from '../model-mapper.js';
 
-const VALID_STRATEGIES = ['sticky', 'round-robin'];
 const VALID_OPENAI_MODEL_IDS = new Set(OPENAI_MODEL_OPTIONS.map((model) => model.id));
 const VALID_REASONING_LEVEL_IDS = new Set(REASONING_LEVEL_OPTIONS.map((level) => level.id));
 
@@ -208,41 +205,6 @@ export function handleSetModelMappings(req, res) {
   res.json(modelMappingsPayload(nextSettings.modelMappings, nextSettings.reasoningMappings));
 }
 
-/**
- * GET /settings/account-strategy
- * Returns the current account selection strategy.
- */
-export function handleGetAccountStrategy(req, res) {
-  const settings = getServerSettings();
-  res.json({
-    success: true,
-    accountStrategy: settings.accountStrategy,
-    rotationEnabled: isMultiAccountRotationEnabled()
-  });
-}
-
-/**
- * POST /settings/account-strategy
- * Updates the account selection strategy.
- */
-export function handleSetAccountStrategy(req, res) {
-  const { accountStrategy } = req.body || {};
-
-  if (!VALID_STRATEGIES.includes(accountStrategy)) {
-    return res.status(400).json({
-      success: false,
-      error: `Invalid accountStrategy. Use one of: ${VALID_STRATEGIES.join(', ')}`
-    });
-  }
-
-  const settings = setServerSettings({ accountStrategy });
-  res.json({
-    success: true,
-    accountStrategy: settings.accountStrategy,
-    rotationEnabled: isMultiAccountRotationEnabled()
-  });
-}
-
 /**
  * GET /settings/claude-proxy
  * Returns Claude proxy configuration preferences.
@@ -282,8 +244,6 @@ export default {
   handleGetKiloModels,
   handleGetModelMappings,
   handleSetModelMappings,
-  handleGetAccountStrategy,
-  handleSetAccountStrategy,
   handleGetClaudeProxySetting,
   handleSetClaudeProxySetting
 };