@askalf/dario 5.5.84 → 5.5.85

package/dist/cli.js

@@ -1138,6 +1138,8 @@ async function codex() {
             await completeAddCodexAccount(alias, code, codeVerifier);
             console.log('');
             console.log(`  Added Codex account "${alias}".`);
+            console.log('  A proxy that is already running picks it up within ~30s —');
+            console.log('  no restart needed (dario#1138).');
             console.log('');
         }
         catch (err) {

package/dist/codex-accounts.d.ts

@@ -6,6 +6,9 @@ export interface CodexAccountCredentials {
     idToken?: string;
 }
 export declare function listCodexAccountAliases(): Promise<string[]>;
+export declare function hasAnyCodexAccount(nowMs?: number): Promise<boolean>;
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export declare function _resetCodexPresenceCacheForTest(): void;
 export declare function loadCodexAccount(alias: string): Promise<CodexAccountCredentials | null>;
 export declare function loadAllCodexAccounts(): Promise<CodexAccountCredentials[]>;
 export declare function saveCodexAccount(creds: CodexAccountCredentials): Promise<void>;

package/dist/codex-accounts.js

@@ -43,6 +43,35 @@ export async function listCodexAccountAliases() {
         return [];
     }
 }
+/**
+ * "Is the codex route available at all" — the routing question, asked per
+ * request rather than once at startup (dario#1138).
+ *
+ * The proxy used to resolve this a single time while booting, so an account
+ * stored by `dario codex add` against an ALREADY-RUNNING proxy stayed
+ * invisible until a restart: /v1/models advertised no gpt slugs and a listed
+ * slug fell through to the Claude path as an unknown model. `dario login`
+ * restarts the proxy by convention, `dario codex add` does not.
+ *
+ * Cheap enough to ask often — a readdir of a directory holding at most a
+ * handful of files — but an idle proxy still shouldn't hit the filesystem on
+ * every request, so the NEGATIVE answer is cached briefly. The positive one
+ * isn't cached: the caller goes on to read the credentials anyway, and a
+ * `codex remove` has to take effect immediately.
+ */
+const CODEX_PRESENCE_NEGATIVE_TTL_MS = 30_000;
+let codexAbsentUntil = 0;
+export async function hasAnyCodexAccount(nowMs = Date.now()) {
+    if (nowMs < codexAbsentUntil)
+        return false;
+    const present = (await listCodexAccountAliases()).length > 0;
+    codexAbsentUntil = present ? 0 : nowMs + CODEX_PRESENCE_NEGATIVE_TTL_MS;
+    return present;
+}
+/** Drop the negative cache so a test doesn't have to sleep out its TTL. */
+export function _resetCodexPresenceCacheForTest() {
+    codexAbsentUntil = 0;
+}
 export async function loadCodexAccount(alias) {
     const path = safeAliasPath(alias);
     if (!path)
@@ -66,6 +95,10 @@ export async function saveCodexAccount(creds) {
         throw new Error(`invalid codex account alias: ${creds.alias}`);
     await ensureDir();
     await durableWriteFile(path, JSON.stringify(creds, null, 2), 0o600);
+    // An account stored in THIS process (`dario codex add` in a running admin
+    // path, or a test) must not be hidden by a negative cache entry taken
+    // moments earlier.
+    codexAbsentUntil = 0;
 }
 export async function removeCodexAccount(alias) {
     const path = safeAliasPath(alias);

package/dist/proxy.js

@@ -21,7 +21,7 @@ import { handleAdminRequest } from './admin-api.js';
 import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { forwardToCodex, getCodexModelSlugs, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
-import { listCodexAccountAliases, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
+import { listCodexAccountAliases, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
 import { route as routeProvider } from './provider-adapter.js';
 import { RequestQueue, QueueFullError, QueueTimeoutError, DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_QUEUED, DEFAULT_QUEUE_TIMEOUT_MS } from './request-queue.js';
 import { redactSecrets } from './redact.js';
@@ -1222,12 +1222,16 @@ export async function startProxy(opts = {}) {
         console.log(`  OpenAI-compat backend: ${openaiBackend.name} → ${openaiBackend.baseUrl}`);
     }
     // Codex/ChatGPT-subscription accounts — the "altman" engine (dario#1009).
-    // Loaded once at startup the same way the openai-compat backend is; the
-    // credentials themselves are re-read per request (they rotate on refresh),
-    // this only answers "is the codex route available at all" for routing.
-    let hasCodexAccount = (await listCodexAccountAliases()).length > 0;
-    if (hasCodexAccount) {
-        console.log(`  Codex accounts: ${(await listCodexAccountAliases()).join(', ')} → ${CODEX_BACKEND_BASE_URL}`);
+    // This startup probe only decides what to PRINT and whether a Claude login
+    // is required to boot; routing re-asks hasAnyCodexAccount() per request
+    // (dario#1138), so an account stored by `dario codex add` against an
+    // already-running proxy is picked up without a restart — `dario login`
+    // restarts the proxy by convention, `dario codex add` does not. The
+    // credentials themselves are re-read per request too (they rotate on
+    // refresh).
+    const startupCodexAliases = await listCodexAccountAliases();
+    if (startupCodexAliases.length > 0) {
+        console.log(`  Codex accounts: ${startupCodexAliases.join(', ')} → ${CODEX_BACKEND_BASE_URL}`);
     }
     // Pool-exhausted fallback (strictly opt-in). When the Claude pool can't
     // serve — every seat rate-limited or in auth cool-down — OpenAI-shape
@@ -1421,7 +1425,7 @@ export async function startProxy(opts = {}) {
     // dead-but-refreshable token (a container restarted right after a normal
     // expiry, gap #1) is refreshed, then back-filled so the recovered login
     // becomes the pool-of-one it should be — rather than crash-looping on exit(1).
-    if (requiresClaudeLogin(pool.size, adminEnabled, !!upstreamApiKey, opts.noClaudeAuth ?? false, hasCodexAccount)) {
+    if (requiresClaudeLogin(pool.size, adminEnabled, !!upstreamApiKey, opts.noClaudeAuth ?? false, startupCodexAliases.length > 0)) {
         const single = await resolveSingleAccountStartupStatus();
         if (!single.authenticated) {
             console.error('[dario] Not authenticated. Run `dario login` first.');
@@ -2168,7 +2172,7 @@ export async function startProxy(opts = {}) {
             // models that account may actually use. Discovery is cached and never
             // throws, so /v1/models keeps its "always answers" property.
             let codexNames = [];
-            if (hasCodexAccount) {
+            if (await hasAnyCodexAccount()) {
                 const stored = await selectCodexAccount();
                 if (stored) {
                     const creds = await getFreshCodexAccount(stored).catch(() => stored);
@@ -2490,17 +2494,16 @@ export async function startProxy(opts = {}) {
                     // case is a map lookup, not a request.
                     let codexCreds = null;
                     let codexModels = [];
-                    if (hasCodexAccount && isOpenAI) {
+                    // Presence is re-asked here rather than read from a startup flag so
+                    // an account added while the proxy runs routes on the very next
+                    // request; the absent answer is cached ~30s, so an idle proxy with
+                    // no codex account is not stat-ing the filesystem per request.
+                    if (isOpenAI && await hasAnyCodexAccount()) {
                         const stored = await selectCodexAccount();
                         if (stored) {
                             codexCreds = await getFreshCodexAccount(stored);
                             codexModels = await getCodexModelSlugs(codexCreds);
                         }
-                        else {
-                            // Accounts disappeared since startup — re-arm the routing flag so
-                            // later requests skip the codex path entirely.
-                            hasCodexAccount = false;
-                        }
                     }
                     const decision = routeProvider({
                         isOpenAIPath: isOpenAI,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "5.5.84",
+  "version": "5.5.85",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {