@askalf/dario 3.31.14 → 3.31.15

package/dist/cli.js

@@ -12,34 +12,22 @@
 // ── Bun auto-relaunch ──
 // Bun's TLS fingerprint matches Claude Code's runtime (both use Bun/BoringSSL).
 // If Bun is installed and we're running on Node, relaunch under Bun for
-// network-level fingerprint fidelity.
-if (!('Bun' in globalThis) && !process.env.DARIO_NO_BUN) {
-    try {
-        const { execFileSync } = await import('node:child_process');
-        // Check if bun exists
-        execFileSync('bun', ['--version'], { stdio: 'ignore', timeout: 3000 });
-        // Relaunch under bun
-        const { spawn } = await import('node:child_process');
-        const child = spawn('bun', ['run', ...process.argv.slice(1)], {
-            stdio: 'inherit',
-            env: { ...process.env, DARIO_NO_BUN: '1' },
-        });
-        child.on('exit', (code) => process.exit(code ?? 0));
-        // Prevent this process from continuing
-        await new Promise(() => { });
-    }
-    catch {
-        // Bun not available, continue with Node
-    }
-}
+// network-level fingerprint fidelity. Moved below into the main-entry guard
+// at the bottom of the file so importing this module (e.g. from tests that
+// just want `parsePositiveIntEnv`) doesn't trigger a Bun relaunch or any
+// other startup side effect.
 import { unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
 import { startAutoOAuthFlow, startManualOAuthFlow, detectHeadlessEnvironment, getStatus, refreshTokens, loadCredentials } from './oauth.js';
 import { startProxy, sanitizeError } from './proxy.js';
 import { VALID_EFFORT_VALUES } from './cc-template.js';
 import { listAccountAliases, loadAllAccounts, addAccountViaOAuth, removeAccount, ensureLoginCredentialsInPool, MIGRATED_LOGIN_ALIAS } from './accounts.js';
 import { listBackends, saveBackend, removeBackend } from './openai-backend.js';
+// `args` / `command` at module scope — command handlers below close over
+// `args` to read their own flags. Reading argv is harmless on import; only
+// the handler dispatch at the bottom is gated behind the main-entry check.
 const args = process.argv.slice(2);
 const command = args[0] ?? 'proxy';
 async function login() {
@@ -1159,13 +1147,42 @@ const commands = {
     '--version': version,
     '-V': version,
 };
-const handler = commands[command];
-if (!handler) {
-    console.error(`Unknown command: ${command}`);
-    console.error('Run `dario help` for usage.');
-    process.exit(1);
+// Main-entry guard. Only run the Bun auto-relaunch and handler dispatch when
+// this module is the direct entry point — importing it (from tests or for
+// a library helper like `parsePositiveIntEnv`) must NOT start the proxy.
+// Before this guard, `import { parsePositiveIntEnv } from './cli.js'` would
+// fall through to `command = args[0] ?? 'proxy'` and fire `handler()`, which
+// tried to run `startProxy()` and failed the test with "Not authenticated".
+const isDirectEntry = typeof process.argv[1] === 'string' &&
+    import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isDirectEntry) {
+    // Bun auto-relaunch for TLS fingerprint fidelity. Only meaningful when
+    // dario is the direct entry — if we're imported, whoever imported us
+    // already chose their runtime.
+    if (!('Bun' in globalThis) && !process.env.DARIO_NO_BUN) {
+        try {
+            const { execFileSync, spawn } = await import('node:child_process');
+            execFileSync('bun', ['--version'], { stdio: 'ignore', timeout: 3000 });
+            const child = spawn('bun', ['run', ...process.argv.slice(1)], {
+                stdio: 'inherit',
+                env: { ...process.env, DARIO_NO_BUN: '1' },
+            });
+            child.on('exit', (code) => process.exit(code ?? 0));
+            // Prevent this process from continuing
+            await new Promise(() => { });
+        }
+        catch {
+            // Bun not available, continue with Node
+        }
+    }
+    const handler = commands[command];
+    if (!handler) {
+        console.error(`Unknown command: ${command}`);
+        console.error('Run `dario help` for usage.');
+        process.exit(1);
+    }
+    handler().catch(err => {
+        console.error('Fatal error:', sanitizeError(err));
+        process.exit(1);
+    });
 }
-handler().catch(err => {
-    console.error('Fatal error:', sanitizeError(err));
-    process.exit(1);
-});

package/dist/request-queue.d.ts

@@ -50,6 +50,16 @@ export interface RequestQueueOptions {
     maxConcurrent?: number;
     maxQueued?: number;
     queueTimeoutMs?: number;
+    /**
+     * Whether timeout timers are `unref`'d so they don't by themselves keep
+     * the Node event loop alive. Default `true` — appropriate for the proxy,
+     * where a leaked queue entry should never hang shutdown. Pass `false` in
+     * tests where the queue is the only pending work on the loop: an
+     * `unref`'d timer won't fire in that case (Node exits with "unsettled
+     * top-level await" before the 50ms timeout elapses), so the reject the
+     * test is waiting for never arrives.
+     */
+    unrefTimers?: boolean;
 }
 export declare const DEFAULT_MAX_CONCURRENT = 10;
 export declare const DEFAULT_MAX_QUEUED = 128;
@@ -58,6 +68,7 @@ export declare class RequestQueue {
     readonly maxConcurrent: number;
     readonly maxQueued: number;
     readonly queueTimeoutMs: number;
+    readonly unrefTimers: boolean;
     private active;
     private queue;
     constructor(opts?: RequestQueueOptions);

package/dist/request-queue.js

@@ -47,12 +47,14 @@ export class RequestQueue {
     maxConcurrent;
     maxQueued;
     queueTimeoutMs;
+    unrefTimers;
     active = 0;
     queue = [];
     constructor(opts = {}) {
         this.maxConcurrent = opts.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
         this.maxQueued = opts.maxQueued ?? DEFAULT_MAX_QUEUED;
         this.queueTimeoutMs = opts.queueTimeoutMs ?? DEFAULT_QUEUE_TIMEOUT_MS;
+        this.unrefTimers = opts.unrefTimers ?? true;
     }
     /**
      * Acquire a concurrency slot. Resolves when admitted; throws
@@ -80,7 +82,9 @@ export class RequestQueue {
             }, this.queueTimeoutMs);
             // Keep the timer from pinning the event loop open on shutdown. A queued
             // request waiting for a slot shouldn't by itself keep the process alive.
-            timeoutHandle.unref?.();
+            // Opt-out for tests — see `unrefTimers` comment in RequestQueueOptions.
+            if (this.unrefTimers)
+                timeoutHandle.unref?.();
             const entry = { resolve, reject, enqueuedAt, timeoutHandle };
             this.queue.push(entry);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.31.14",
+  "version": "3.31.15",
   "description": "A local LLM router. One endpoint, every provider — Claude subscriptions, OpenAI, OpenRouter, Groq, local LiteLLM, any OpenAI-compat endpoint — your tools don't need to change.",
   "type": "module",
   "bin": {