@askalf/dario 3.31.20 → 3.32.0

package/dist/proxy.js

@@ -1,7 +1,7 @@
 import { createServer } from 'node:http';
 import { randomUUID, randomBytes, timingSafeEqual, createHash } from 'node:crypto';
 import { execSync } from 'node:child_process';
-import { readFileSync, readdirSync } from 'node:fs';
+import { readFileSync, readdirSync, createWriteStream } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { arch, platform } from 'node:process';
@@ -345,6 +345,21 @@ function translateStreamChunk(line) {
     return null;
 }
 const OPENAI_MODELS_LIST = { object: 'list', data: ['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5'].map(id => ({ id, object: 'model', created: 1700000000, owned_by: 'anthropic' })) };
+/**
+ * Append a JSON-ND line to the proxy log file. No-op when stream is
+ * null (logFile not configured). Errors are swallowed — log writes
+ * must never break the request path.
+ */
+export function writeLogLine(stream, entry) {
+    if (!stream)
+        return;
+    try {
+        stream.write(redactSecrets(JSON.stringify(entry)) + '\n');
+    }
+    catch {
+        // ignore — log mishaps must never affect requests
+    }
+}
 export function sanitizeError(err) {
     // Pattern set lives in src/redact.ts so OAuth call sites can run the
     // same redaction directly on response-body strings without importing
@@ -440,12 +455,74 @@ export async function startProxy(opts = {}) {
     // Set once on first sighting per family so the startup log stays
     // short even under heavy traffic. dario#40.
     const detectedClientsLogged = new Set();
+    // Per-(client, mapping-mode) keys for which we've already emitted a
+    // tool-substitution warn line. Same de-dup contract as
+    // detectedClientsLogged so mixed-traffic proxies don't spam.
+    const toolSubLogged = new Set();
     // Body-dump mode: set via --verbose=2 / -vv or DARIO_LOG_BODIES=1.
     // When on, every request emits a redacted JSON body to stderr so
     // operators can see exactly what dario forwards upstream. Default
     // -v stays quiet because bodies can carry file content and tool
     // output. Reported in dario#40 by @ringge.
     const verboseBodies = Boolean(opts.verboseBodies) || process.env.DARIO_LOG_BODIES === '1';
+    // Operator-declared beta passthrough set. Sourced from CLI flag or env;
+    // both are CSV strings of beta-flag names. Trimmed, deduped, empty
+    // entries dropped. Stays a Set for fast membership checks in the per-
+    // request beta build below.
+    const passthroughBetas = new Set([
+        ...(opts.passthroughBetas ?? []),
+        ...((process.env.DARIO_PASSTHROUGH_BETAS ?? '').split(',')),
+    ]
+        .map((b) => b.trim())
+        .filter((b) => b.length > 0));
+    if (passthroughBetas.size > 0) {
+        console.log(`  Beta passthrough: ${[...passthroughBetas].sort().join(', ')} (always forwarded; per-account rejection cache still applies)`);
+    }
+    // Tool-routing mode mutex. preserve / hybrid / merge each shape the
+    // outbound `tools` array differently; combining two would mean two
+    // different bodies. Refuse to start with a clear error rather than
+    // silently dropping a flag.
+    const toolModes = [
+        opts.preserveTools ? 'preserve-tools' : null,
+        opts.hybridTools ? 'hybrid-tools' : null,
+        opts.mergeTools ? 'merge-tools' : null,
+    ].filter((m) => m !== null);
+    if (toolModes.length > 1) {
+        console.error(`[dario] tool-routing flags are mutually exclusive — pick one: ${toolModes.join(', ')}.`);
+        process.exit(1);
+    }
+    if (opts.mergeTools) {
+        // Loud notice — this mode is experimental and operators need to
+        // verify their billing classification before relying on it. The
+        // wire-shape "tools[]" axis still has CC's array as a prefix, but
+        // the suffix is operator-supplied custom shapes. Anthropic's
+        // classifier may flip routing on the difference.
+        console.log('  Tool routing: merge (CC tools + client custom tools, deduped)');
+        console.log('  ⚠  EXPERIMENTAL: validate billing-bucket behavior on the first 1-2 requests with --verbose');
+    }
+    // Append-only structured request log. One JSON-ND line per completed
+    // request — secrets scrubbed via redactSecrets, no bodies. Off by
+    // default; opt in with `--log-file <path>` or DARIO_LOG_FILE. See the
+    // ProxyLogEntry interface for fields. Useful for backgrounded proxies
+    // where stdout is unobserved (`verbose` only helps in foreground).
+    // Errors during open are reported once and downgrade to no-op so a
+    // log mishap never blocks the proxy from booting.
+    const logFilePath = opts.logFile || process.env.DARIO_LOG_FILE || null;
+    let logFileStream = null;
+    if (logFilePath) {
+        try {
+            logFileStream = createWriteStream(logFilePath, { flags: 'a' });
+            logFileStream.on('error', (err) => {
+                console.error(`[dario] log-file write error: ${err.message} (logging disabled)`);
+                logFileStream = null;
+            });
+            console.log(`  Request log: ${logFilePath}`);
+        }
+        catch (err) {
+            console.error(`[dario] log-file open failed: ${err instanceof Error ? err.message : err} (continuing without)`);
+            logFileStream = null;
+        }
+    }
     // Multi-provider backends (v3.6.0+). Loaded once at startup; the CLI
     // `dario backend add openai --key=…` writes to ~/.dario/backends/.
     // Routing: a GPT-family model arriving on /v1/chat/completions is
@@ -707,6 +784,10 @@ export async function startProxy(opts = {}) {
                 // one-line reject log under -v so operators see auth misfires.
                 console.error(`[dario] #${requestCount} 401 rejected (DARIO_API_KEY mismatch): ${describeAuthReject(req.headers)}`);
             }
+            writeLogLine(logFileStream, {
+                ts: new Date().toISOString(), req: requestCount,
+                method: req.method ?? '', path: urlPath, status: 401, reject: 'auth',
+            });
             res.writeHead(401, JSON_HEADERS);
             res.end(ERR_UNAUTH);
             return;
@@ -790,6 +871,10 @@ export async function startProxy(opts = {}) {
         }
         catch (err) {
             if (err instanceof QueueFullError) {
+                writeLogLine(logFileStream, {
+                    ts: new Date().toISOString(), req: requestCount,
+                    method: req.method ?? '', path: urlPath, status: 429, reject: 'queue-full',
+                });
                 res.writeHead(429, JSON_HEADERS);
                 res.end(JSON.stringify({
                     type: 'error',
@@ -801,6 +886,10 @@ export async function startProxy(opts = {}) {
                 return;
             }
             if (err instanceof QueueTimeoutError) {
+                writeLogLine(logFileStream, {
+                    ts: new Date().toISOString(), req: requestCount,
+                    method: req.method ?? '', path: urlPath, status: 504, reject: 'queue-timeout',
+                });
                 res.writeHead(504, JSON_HEADERS);
                 res.end(JSON.stringify({
                     type: 'error',
@@ -817,6 +906,13 @@ export async function startProxy(opts = {}) {
         let upstreamTimeout = null;
         let onClientClose = null;
         let upstreamAbortReason = null;
+        // Hoisted so the catch can include them in the request log line. The
+        // body-parsing block below assigns these once the request is parsed;
+        // before that point they remain at their initial values, which is
+        // also exactly what we want to log on early-failure paths.
+        let requestModel = '';
+        let detectedClientForLog;
+        let preserveToolsEffective = Boolean(opts.preserveTools);
         try {
             // Pool mode: select an account by headroom. Single-account mode:
             // fall through to getAccessToken() exactly as before. Request-path
@@ -912,7 +1008,9 @@ export async function startProxy(opts = {}) {
             // Parse body once, apply OpenAI translation, model override, and sanitization
             let finalBody = body.length > 0 ? body : undefined;
             let ccToolMap = null;
-            let requestModel = '';
+            // requestModel / detectedClientForLog / preserveToolsEffective are
+            // declared at the outer try-scope above so the catch block can
+            // include them in the request log line.
             // Session stickiness key — hash of the first user message in this
             // conversation. Populated inside the template-replay block below
             // after the first user message is extracted for the build tag, then
@@ -1000,13 +1098,17 @@ export async function startProxy(opts = {}) {
                         const bodyIdentity = poolAccount
                             ? poolAccount.identity
                             : { deviceId: identity.deviceId, accountUuid: identity.accountUuid, sessionId: preBodySessionId };
-                        const { body: ccBody, toolMap, detectedClient } = buildCCRequest(r, billingTag, CACHE_EPHEMERAL, bodyIdentity, {
+                        const { body: ccBody, toolMap, detectedClient, unmappedTools } = buildCCRequest(r, billingTag, CACHE_EPHEMERAL, bodyIdentity, {
                             preserveTools: opts.preserveTools ?? false,
                             hybridTools: opts.hybridTools ?? false,
+                            mergeTools: opts.mergeTools ?? false,
                             noAutoDetect: opts.noAutoDetect ?? false,
                             effort: opts.effort,
                             maxTokens: opts.maxTokens,
                         });
+                        detectedClientForLog = detectedClient;
+                        preserveToolsEffective = Boolean(opts.preserveTools)
+                            || (Boolean(detectedClient) && !opts.hybridTools && !opts.mergeTools);
                         // Log the auto-preserve-tools switch once per text-tool
                         // client family. Skip when the operator already opted into
                         // --preserve-tools or --hybrid-tools — they know what they
@@ -1019,6 +1121,28 @@ export async function startProxy(opts = {}) {
                             detectedClientsLogged.add(detectedClient);
                             console.log(`[dario] detected ${detectedClient}-style text-tool protocol — auto-enabling preserve-tools for this client (pass --hybrid-tools to override, --preserve-tools to silence)`);
                         }
+                        // Surface tool substitution. When a non-CC client routes
+                        // tools we don't have in TOOL_MAP and neither auto-detect
+                        // nor an explicit flag flipped us into preserve-tools, the
+                        // unmapped tools get distributed onto CC fallback slots —
+                        // the model upstream sees "Glob"/"Read"/etc. and the
+                        // client's own tool surface is silently rewritten on the
+                        // response path. That rewrite is correct for
+                        // schema-compatible cases but invisible to operators who
+                        // didn't expect it. One-line warn the first time we see a
+                        // non-empty unmapped set per (client family, mapping mode)
+                        // — same de-dupe key shape as the auto-detect line so a
+                        // mixed-traffic proxy doesn't spam.
+                        const subKey = `${detectedClient ?? 'unknown'}:${preserveToolsEffective ? 'preserve' : 'remap'}`;
+                        if (unmappedTools.length > 0
+                            && !preserveToolsEffective
+                            && !toolSubLogged.has(subKey)) {
+                            toolSubLogged.add(subKey);
+                            const totalTools = (Array.isArray(r.tools) ? r.tools.length : 0);
+                            const sample = unmappedTools.slice(0, 5).join(', ');
+                            const more = unmappedTools.length > 5 ? `, +${unmappedTools.length - 5} more` : '';
+                            console.log(`[dario] tool substitution: ${unmappedTools.length}/${totalTools} client tool${unmappedTools.length === 1 ? '' : 's'} not in TOOL_MAP — remapped onto CC fallback slots (${sample}${more}). Pass --preserve-tools to forward your schemas verbatim instead.`);
+                        }
                         // Store tool map for response reverse-mapping
                         ccToolMap = toolMap;
                         // Replace request body entirely with CC template
@@ -1074,6 +1198,19 @@ export async function startProxy(opts = {}) {
                     if (filtered)
                         beta += ',' + filtered;
                 }
+                // Operator-pinned passthrough betas. Always forwarded — bypasses
+                // the billable-beta filter, bypasses the "not in client's
+                // request" gate. The per-account rejection cache below still
+                // applies, so a pinned flag the upstream 400's gets dropped on
+                // the retry rather than re-sent forever (the cache survives the
+                // operator's pin because the upstream's no is final until a
+                // tier change resets it).
+                if (passthroughBetas.size > 0) {
+                    const baseSet = new Set(beta.split(','));
+                    const toAdd = [...passthroughBetas].filter((b) => !baseSet.has(b));
+                    if (toAdd.length > 0)
+                        beta += ',' + toAdd.join(',');
+                }
                 // Strip any beta flags the upstream has previously rejected on this
                 // account so we don't re-pay the 400 round-trip (dario#42 afk-mode
                 // fallout: captured templates carry tier-gated flags whose availability
@@ -1596,6 +1733,20 @@ export async function startProxy(opts = {}) {
                         latencyMs: Date.now() - startTime, status: upstream.status, isStream: true, isOpenAI,
                     });
                 }
+                writeLogLine(logFileStream, {
+                    ts: new Date().toISOString(), req: requestCount,
+                    method: req.method ?? '', path: urlPath,
+                    model: requestModel || undefined,
+                    status: upstream.status, latency_ms: Date.now() - startTime,
+                    in_tokens: streamInputTokens, out_tokens: streamOutputTokens,
+                    cache_read: streamCacheReadTokens, cache_create: streamCacheCreateTokens,
+                    claim: poolAccount?.rateLimit.claim,
+                    bucket: poolAccount ? billingBucketFromClaim(poolAccount.rateLimit.claim) : undefined,
+                    account: poolAccount?.alias,
+                    client: detectedClientForLog,
+                    preserve_tools: preserveToolsEffective,
+                    stream: true,
+                });
             }
             else {
                 // Buffer and forward
@@ -1615,16 +1766,20 @@ export async function startProxy(opts = {}) {
                 else {
                     res.end(responseBody);
                 }
-                if (analytics && poolAccount) {
+                let bufferedUsage = null;
+                try {
+                    const parsed = JSON.parse(responseBody);
+                    bufferedUsage = Analytics.parseUsage(parsed);
+                }
+                catch { /* malformed body — log without usage */ }
+                if (analytics && poolAccount && bufferedUsage) {
                     try {
-                        const parsed = JSON.parse(responseBody);
-                        const usage = Analytics.parseUsage(parsed);
                         analytics.record({
                             timestamp: Date.now(), account: poolAccount.alias,
-                            model: usage.model || requestModel,
-                            inputTokens: usage.inputTokens, outputTokens: usage.outputTokens,
-                            cacheReadTokens: usage.cacheReadTokens, cacheCreateTokens: usage.cacheCreateTokens,
-                            thinkingTokens: usage.thinkingTokens,
+                            model: bufferedUsage.model || requestModel,
+                            inputTokens: bufferedUsage.inputTokens, outputTokens: bufferedUsage.outputTokens,
+                            cacheReadTokens: bufferedUsage.cacheReadTokens, cacheCreateTokens: bufferedUsage.cacheCreateTokens,
+                            thinkingTokens: bufferedUsage.thinkingTokens,
                             claim: poolAccount.rateLimit.claim, util5h: poolAccount.rateLimit.util5h,
                             util7d: poolAccount.rateLimit.util7d, overageUtil: poolAccount.rateLimit.overageUtil,
                             latencyMs: Date.now() - startTime, status: upstream.status, isStream: false, isOpenAI,
@@ -1632,6 +1787,20 @@ export async function startProxy(opts = {}) {
                     }
                     catch { /* don't let analytics errors break responses */ }
                 }
+                writeLogLine(logFileStream, {
+                    ts: new Date().toISOString(), req: requestCount,
+                    method: req.method ?? '', path: urlPath,
+                    model: bufferedUsage?.model || requestModel || undefined,
+                    status: upstream.status, latency_ms: Date.now() - startTime,
+                    in_tokens: bufferedUsage?.inputTokens, out_tokens: bufferedUsage?.outputTokens,
+                    cache_read: bufferedUsage?.cacheReadTokens, cache_create: bufferedUsage?.cacheCreateTokens,
+                    claim: poolAccount?.rateLimit.claim,
+                    bucket: poolAccount ? billingBucketFromClaim(poolAccount.rateLimit.claim) : undefined,
+                    account: poolAccount?.alias,
+                    client: detectedClientForLog,
+                    preserve_tools: preserveToolsEffective,
+                    stream: false,
+                });
                 if (verbose)
                     console.log(`[dario] #${requestCount} ${upstream.status}`);
             }
@@ -1639,9 +1808,17 @@ export async function startProxy(opts = {}) {
         catch (err) {
             // Differentiate the three failure modes so each gets the right
             // response (and so we don't spam logs when clients simply drop).
+            const errLogBase = {
+                ts: new Date().toISOString(), req: requestCount,
+                method: req.method ?? '', path: urlPath,
+                model: requestModel || undefined,
+                client: detectedClientForLog,
+                preserve_tools: preserveToolsEffective,
+            };
             if (upstreamAbortReason === 'client_closed') {
                 if (verbose)
                     console.log(`[dario] #${requestCount} aborted (client disconnected)`);
+                writeLogLine(logFileStream, { ...errLogBase, reject: 'client-closed' });
             }
             else if (upstreamAbortReason === 'timeout') {
                 console.error(`[dario] #${requestCount} upstream timeout after ${UPSTREAM_TIMEOUT_MS / 1000}s`);
@@ -1652,6 +1829,7 @@ export async function startProxy(opts = {}) {
                 else if (!res.writableEnded) {
                     res.end();
                 }
+                writeLogLine(logFileStream, { ...errLogBase, status: 504, error: 'upstream-timeout' });
             }
             else {
                 // Log full error server-side, return generic message to client
@@ -1663,6 +1841,7 @@ export async function startProxy(opts = {}) {
                 else if (!res.writableEnded) {
                     res.end();
                 }
+                writeLogLine(logFileStream, { ...errLogBase, status: 502, error: sanitizeError(err) });
             }
         }
         finally {
@@ -1823,6 +2002,8 @@ export async function startProxy(opts = {}) {
         console.log('\n[dario] Shutting down...');
         clearInterval(presenceInterval);
         clearInterval(refreshInterval);
+        if (logFileStream)
+            logFileStream.end();
         server.close(() => process.exit(0));
         // Force exit after 5s if connections don't close
         setTimeout(() => process.exit(0), 5000).unref();

package/dist/runtime-fingerprint.d.ts

@@ -75,3 +75,29 @@ export declare function classifyRuntimeFingerprint(runningUnderBun: boolean, ava
  * directly with synthetic inputs.
  */
 export declare function detectRuntimeFingerprint(): RuntimeFingerprint;
+/**
+ * One-shot Bun installer. Used by `dario doctor --bun-bootstrap` to
+ * close the gap between "Bun warn surfaced" and "Bun on PATH" without
+ * making the user copy-paste an install line. Picks the platform-correct
+ * upstream installer:
+ *
+ *   - Windows: `powershell -c "irm https://bun.sh/install.ps1 | iex"`
+ *   - macOS / Linux: `curl -fsSL https://bun.sh/install | bash`
+ *
+ * Streams installer output to the parent stdio so the user sees what's
+ * happening (the install can take 10-30 s on a slow link). Returns the
+ * exit code; non-zero is surfaced by the caller as a fail row.
+ *
+ * Pure delegation to the upstream Bun installer — dario does not vendor
+ * or self-host the binary. If the user wants a pinned version or doesn't
+ * want to run a curl-to-shell installer, the doctor warn line still
+ * points at https://bun.sh for manual install.
+ *
+ * Pinned to bun.sh (not bun.com) because PowerShell's `irm` doesn't
+ * follow the bun.com → bun.sh 308 redirect; piping the redirect HTML
+ * to `iex` then fails parse. bun.sh serves the install script directly.
+ */
+export declare function bunBootstrap(): Promise<{
+    exitCode: number;
+    runner: string;
+}>;

package/dist/runtime-fingerprint.js

@@ -115,3 +115,46 @@ export function detectRuntimeFingerprint() {
     const probed = probeBunVersion();
     return classifyRuntimeFingerprint(false, probed, process.env);
 }
+/**
+ * One-shot Bun installer. Used by `dario doctor --bun-bootstrap` to
+ * close the gap between "Bun warn surfaced" and "Bun on PATH" without
+ * making the user copy-paste an install line. Picks the platform-correct
+ * upstream installer:
+ *
+ *   - Windows: `powershell -c "irm https://bun.sh/install.ps1 | iex"`
+ *   - macOS / Linux: `curl -fsSL https://bun.sh/install | bash`
+ *
+ * Streams installer output to the parent stdio so the user sees what's
+ * happening (the install can take 10-30 s on a slow link). Returns the
+ * exit code; non-zero is surfaced by the caller as a fail row.
+ *
+ * Pure delegation to the upstream Bun installer — dario does not vendor
+ * or self-host the binary. If the user wants a pinned version or doesn't
+ * want to run a curl-to-shell installer, the doctor warn line still
+ * points at https://bun.sh for manual install.
+ *
+ * Pinned to bun.sh (not bun.com) because PowerShell's `irm` doesn't
+ * follow the bun.com → bun.sh 308 redirect; piping the redirect HTML
+ * to `iex` then fails parse. bun.sh serves the install script directly.
+ */
+export async function bunBootstrap() {
+    const { spawn } = await import('node:child_process');
+    const isWindows = process.platform === 'win32';
+    const runner = isWindows
+        ? 'powershell -NoProfile -ExecutionPolicy Bypass -c "irm https://bun.sh/install.ps1 | iex"'
+        : 'curl -fsSL https://bun.sh/install | bash';
+    return await new Promise((resolve) => {
+        // Single-shell invocation so the pipe stages execute the way the
+        // upstream installer expects. Avoids reimplementing the curl-pipe-bash
+        // sequencing in Node primitives.
+        const child = isWindows
+            ? spawn('powershell', [
+                '-NoProfile',
+                '-ExecutionPolicy', 'Bypass',
+                '-Command', 'irm https://bun.sh/install.ps1 | iex',
+            ], { stdio: 'inherit' })
+            : spawn('bash', ['-lc', 'curl -fsSL https://bun.sh/install | bash'], { stdio: 'inherit' });
+        child.on('error', () => resolve({ exitCode: 1, runner }));
+        child.on('exit', (code) => resolve({ exitCode: code ?? 1, runner }));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.31.20",
+  "version": "3.32.0",
   "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": {