@askalf/dario 3.38.6 → 4.0.1

package/dist/cli.js

@@ -31,7 +31,28 @@ import { parseOutboundProxy, installOutboundProxyWrapper } from './outbound-prox
 // `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';
+/**
+ * Default command when invoked with no args.
+ *
+ * v3.x: `dario` started the proxy (default = 'proxy').
+ * v4.0: `dario` opens the interactive TUI (default = 'tui').
+ *
+ * Migration: scripts that ran bare `dario` to launch the proxy need
+ * to switch to `dario proxy`. The TUI itself surfaces a "proxy
+ * unreachable" hint with the exact command if it doesn't see one
+ * running, so users discovering the change get pointed to the fix.
+ *
+ * `--no-tui` opt-out runs help instead (escape hatch for users who
+ * want the v3-style behavior without explicitly typing `proxy`, e.g.
+ * inside CI scripts that grep `dario` output).
+ */
+const DEFAULT_COMMAND = args.includes('--no-tui') ? 'help' : 'tui';
+// --no-tui is a meta-flag (controls DEFAULT_COMMAND above) not a command
+// itself, so when it appears as args[0] we still resolve to the default.
+// All other args pass through unchanged — `dario proxy`, `dario --help`,
+// `dario --version` etc. still dispatch as expected.
+const positionalArgs = args.filter((a) => a !== '--no-tui');
+const command = positionalArgs[0] ?? DEFAULT_COMMAND;
 async function login() {
     console.log('');
     console.log('  dario — Claude Login');
@@ -190,18 +211,33 @@ async function logout() {
     }
 }
 async function proxy() {
+    // v4: load ~/.dario/config.json once at startup so file-stored values
+    // serve as defaults below where no CLI flag / env var supplies one.
+    // Precedence per M1: defaults < file < env < CLI. Missing-file is
+    // treated as "no file values" — the existing CLI/env paths see no
+    // change. Invalid file is logged but doesn't abort; we still start
+    // with whatever the env+flags provide.
+    const { loadConfig } = await import('./config-file.js');
+    const fileResult = loadConfig();
+    const fileCfg = fileResult.config;
+    if (fileResult.source === 'invalid') {
+        console.warn(`[dario] config file present but invalid (${fileResult.error}) — using defaults + env + flags only.`);
+    }
     const portArg = args.find(a => a.startsWith('--port='));
-    const port = portArg ? parseInt(portArg.split('=')[1]) : 3456;
+    // Precedence: --port flag > DARIO_PORT env > config file > built-in default 3456
+    const portFromCli = portArg ? parseInt(portArg.split('=')[1], 10) : undefined;
+    const portFromEnv = process.env['DARIO_PORT'] ? parseInt(process.env['DARIO_PORT'], 10) : undefined;
+    const port = portFromCli ?? portFromEnv ?? fileCfg.port ?? 3456;
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error('[dario] Invalid port. Must be 1-65535.');
         process.exit(1);
     }
-    // Bind address — accepts --host=<addr>; falls through to DARIO_HOST env
-    // var or the default of 127.0.0.1 inside startProxy. The sanity check
-    // here only rejects obviously bad shapes; real address validation
-    // happens when the OS tries to bind.
+    // Bind address — --host > DARIO_HOST > config file > startProxy's
+    // built-in 127.0.0.1 default. The regex sanity-check rejects
+    // obviously bad shapes; real address validation happens at bind time.
     const hostArg = args.find(a => a.startsWith('--host='));
-    const host = hostArg ? hostArg.split('=')[1] : undefined;
+    const host = hostArg ? hostArg.split('=')[1]
+        : (process.env['DARIO_HOST'] || fileCfg.host || undefined);
     if (host !== undefined && !/^[a-zA-Z0-9._:-]+$/.test(host)) {
         console.error('[dario] Invalid --host. Must be an IP address or hostname.');
         process.exit(1);
@@ -247,34 +283,33 @@ async function proxy() {
     const model = modelArg ? modelArg.split('=')[1] : undefined;
     // --pace-min=MS / --pace-jitter=MS (v3.24, direction #6 — behavioral
     // smoothing). Inter-request gap floor + optional uniform-random jitter.
-    // Defaults preserve v3.23 behavior (500ms floor, no jitter). The pure
-    // calc lives in src/pacing.ts; the flags just feed it.
-    const pacingMinMs = parsePositiveIntFlag('--pace-min=');
-    const pacingJitterMs = parsePositiveIntFlag('--pace-jitter=');
+    // v4: ~/.dario/config.json's `pacing.{minMs,jitterMs}` is the fallback
+    // when no CLI flag is set, so the TUI's Config tab can persist edits.
+    // The pure calc lives in src/pacing.ts; flags+config just feed it.
+    const pacingMinMs = parsePositiveIntFlag('--pace-min=') ?? fileCfg.pacing?.minMs;
+    const pacingJitterMs = parsePositiveIntFlag('--pace-jitter=') ?? fileCfg.pacing?.jitterMs;
     // --think-time-* / --session-start-* — behavioral smoothing extension.
-    // Closes the temporal axis the wire-fidelity work doesn't touch:
-    // response-length-correlated read time between requests, and per-
-    // session opening latency. All defaults 0 = off (opt-in).
-    const thinkTimeBaseMs = parsePositiveIntFlag('--think-time-base=');
-    const thinkTimePerTokenMs = parsePositiveIntFlag('--think-time-per-token=');
-    const thinkTimeJitterMs = parsePositiveIntFlag('--think-time-jitter=');
-    const thinkTimeMaxMs = parsePositiveIntFlag('--think-time-max=');
-    const sessionStartMinMs = parsePositiveIntFlag('--session-start-min=');
-    const sessionStartJitterMs = parsePositiveIntFlag('--session-start-jitter=');
+    // Same v4 precedence (flag > file > built-in default).
+    const thinkTimeBaseMs = parsePositiveIntFlag('--think-time-base=') ?? fileCfg.thinkTime?.baseMs;
+    const thinkTimePerTokenMs = parsePositiveIntFlag('--think-time-per-token=') ?? fileCfg.thinkTime?.perTokenMs;
+    const thinkTimeJitterMs = parsePositiveIntFlag('--think-time-jitter=') ?? fileCfg.thinkTime?.jitterMs;
+    const thinkTimeMaxMs = parsePositiveIntFlag('--think-time-max=') ?? fileCfg.thinkTime?.maxMs;
+    const sessionStartMinMs = parsePositiveIntFlag('--session-start-min=') ?? fileCfg.sessionStart?.minMs;
+    const sessionStartJitterMs = parsePositiveIntFlag('--session-start-jitter=') ?? fileCfg.sessionStart?.jitterMs;
     // --stealth flips all three pacing layers (pace, think, session-start)
-    // into their behavioral-stealth presets so the request inter-arrival
-    // distribution matches real interactive CC. One knob instead of six.
-    // Per-knob explicit flags / env vars still win, so operators can
-    // toggle stealth on and then tune individual axes.
+    // into their behavioral-stealth presets. Same v4 precedence (flag >
+    // env > file > false). Per-knob flags above still win even when
+    // stealth is on, so operators can flip on then tune individual axes.
     const stealth = args.includes('--stealth')
         || parseBooleanEnv(process.env['DARIO_STEALTH'])
+        || fileCfg.stealth
         || undefined;
     // --drain-on-close (v3.25, direction #5). When set, a client
     // disconnect no longer aborts the upstream SSE — dario keeps
     // draining the stream to EOF so Anthropic sees the CC-shaped
     // read-to-completion pattern. Costs tokens (the response is fully
     // generated even if nobody reads it), so it's opt-in.
-    const drainOnClose = args.includes('--drain-on-close') || undefined;
+    const drainOnClose = args.includes('--drain-on-close') || fileCfg.drainOnClose || undefined;
     // --session-* knobs (v3.28, direction #1). Control the single-account
     // session-id lifecycle: idle threshold, jitter on that threshold, hard
     // max-age, and whether to give each upstream client its own session.
@@ -1711,6 +1746,56 @@ async function usage() {
     }
     console.log('');
 }
+/**
+ * `dario tui` (or `dario` with no args) — opens the interactive
+ * terminal UI. v4 entry point.
+ *
+ * The TUI is a viewer/configurator; it expects a `dario proxy`
+ * already running locally for live analytics. When no proxy is
+ * reachable, each tab degrades gracefully — Status shows
+ * "unreachable" with the start-command hint, Analytics + Hits show
+ * the same. Accounts + Backends + Config don't need the proxy at
+ * all (they read disk directly).
+ *
+ * Bails out early if stdin isn't a TTY — the TUI can't function in
+ * a pipe / redirect. The error message points at `dario proxy` (the
+ * non-interactive entry) for that case.
+ *
+ * --port=<n>     target a non-default proxy port (default 3456)
+ * --api-key=KEY  authenticate against a DARIO_API_KEY-protected proxy
+ */
+async function tui() {
+    if (!process.stdin.isTTY) {
+        console.error('[dario] TUI requires an interactive terminal.');
+        console.error('  Pipe / redirect detected on stdin.');
+        console.error('  Run `dario proxy` for the non-interactive proxy server,');
+        console.error('  or `dario --no-tui` to print help instead.');
+        process.exit(1);
+    }
+    const portArg = args.find((a) => a.startsWith('--port='));
+    const port = portArg ? parseInt(portArg.split('=')[1], 10) : 3456;
+    const apiKeyArg = args.find((a) => a.startsWith('--api-key='));
+    const apiKey = apiKeyArg
+        ? apiKeyArg.split('=')[1]
+        : (process.env['DARIO_API_KEY'] || undefined);
+    const { startTuiApp } = await import('./tui/tui-app.js');
+    await startTuiApp({
+        version: pkgVersion(),
+        proxyUrl: `http://127.0.0.1:${port}`,
+        apiKey,
+    });
+}
+function pkgVersion() {
+    try {
+        // Read from the same package.json the rest of the CLI uses.
+        const pkgUrl = new URL('../package.json', import.meta.url);
+        const fs = require('node:fs');
+        return JSON.parse(fs.readFileSync(pkgUrl, 'utf-8')).version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 // Main
 const commands = {
     login,
@@ -1727,6 +1812,7 @@ const commands = {
     config,
     upgrade,
     usage,
+    tui,
     help,
     version,
     '--help': help,

package/dist/config-file.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Config file foundation — v4.
+ *
+ * Persists user-tunable settings to `~/.dario/config.json` so the TUI
+ * can read + write them without having to manage shell scripts. Establishes
+ * the precedence chain that every effective value passes through:
+ *
+ *   defaults  <  config.json  <  env var  <  CLI flag
+ *
+ * Existing CLI flags + env vars continue to work unchanged. The config
+ * file is purely additive — a missing file resolves to defaults, exactly
+ * as v3 already behaved (since v3 had no config file).
+ *
+ * Atomic write: write to `config.json.tmp`, fsync, rename. Same primitive
+ * shape `atomicWriteJson` in src/live-fingerprint.ts uses for the
+ * captured CC template.
+ *
+ * Unknown keys in the loaded file are preserved (forward-compat for
+ * future schema versions); validation is best-effort, not strict — a
+ * corrupt or partial file falls back to defaults rather than aborting
+ * the process.
+ */
+/**
+ * Bumped on any incompatible shape change. v4.0.0 ships schema v1. A
+ * future shape change would either add a new optional field (no bump)
+ * or rename / restructure (bump to v2 with a migration in `loadConfig`).
+ */
+export declare const CONFIG_SCHEMA_VERSION = 1;
+/**
+ * Default `~/.dario/config.json` location. Override in tests via
+ * `loadConfig(path)` / `saveConfig(path, …)`.
+ */
+export declare const DEFAULT_CONFIG_PATH: string;
+/**
+ * Every user-tunable setting. Grouped into sub-objects when the knobs
+ * cluster naturally (pacing, thinkTime, session, queue) so the TUI's
+ * Config tab can render each cluster as a folder without extra glue.
+ *
+ * Optional everywhere — a partially-populated config file is valid; the
+ * proxy fills in defaults for whatever's absent.
+ */
+export interface DarioConfig {
+    /** Schema version of this file. Required for forward-compat. */
+    version: number;
+    port?: number;
+    host?: string;
+    model?: string | null;
+    passthrough?: boolean;
+    preserveTools?: boolean;
+    hybridTools?: boolean;
+    mergeTools?: boolean;
+    noAutoDetect?: boolean;
+    strictTls?: boolean;
+    strictTemplate?: boolean;
+    noLiveCapture?: boolean;
+    drainOnClose?: boolean;
+    stealth?: boolean;
+    pacing?: {
+        minMs?: number;
+        jitterMs?: number;
+    };
+    thinkTime?: {
+        baseMs?: number;
+        perTokenMs?: number;
+        jitterMs?: number;
+        maxMs?: number;
+    };
+    sessionStart?: {
+        minMs?: number;
+        jitterMs?: number;
+    };
+    session?: {
+        idleRotateMs?: number;
+        rotateJitterMs?: number;
+        maxAgeMs?: number | null;
+        perClient?: boolean;
+    };
+    queue?: {
+        maxConcurrent?: number | null;
+        maxQueued?: number | null;
+        timeoutMs?: number | null;
+    };
+    effort?: string | null;
+    maxTokens?: number | 'client' | null;
+    passthroughBetas?: string[];
+    systemPrompt?: string | null;
+    preserveOrchestrationTags?: boolean;
+    logFile?: string | null;
+}
+/**
+ * Defaults match the v3.x CLI flag defaults exactly. Any value not
+ * specified in config.json resolves to its corresponding default here.
+ * Updates to a flag default MUST land here too so they stay in sync.
+ */
+export declare function defaultConfig(): DarioConfig;
+/**
+ * Load the config file at `path` (default ~/.dario/config.json).
+ *
+ * Returns `{ config, source }` where `source` describes the load outcome
+ * for the caller's UI:
+ *
+ *   - 'file'    — successfully loaded
+ *   - 'missing' — file doesn't exist; defaults returned (not an error)
+ *   - 'invalid' — file exists but parse / shape check failed; defaults
+ *                 returned. The TUI surfaces this so the user knows
+ *                 their saved settings were ignored.
+ *
+ * The loaded shape is type-checked field-by-field: unknown keys pass
+ * through (forward-compat), known keys with wrong types are dropped.
+ * Strict validation would force a config migration on every shape
+ * tweak; loose-but-typed lets the file evolve without breaking older
+ * dario installs that haven't been restarted.
+ */
+export declare function loadConfig(path?: string): {
+    config: DarioConfig;
+    source: 'file' | 'missing' | 'invalid';
+    error?: string;
+};
+/**
+ * Atomically write `config` to `path`. Writes to `<path>.tmp`, then
+ * renames into place — guarantees a reader never observes a half-written
+ * file. Creates parent directories if missing.
+ *
+ * Throws on permission / disk failures (caller handles + surfaces to
+ * the TUI's status line). Does NOT throw on a no-op rewrite of the
+ * same content; that's a cheap idempotent path.
+ */
+export declare function saveConfig(path: string | undefined, config: DarioConfig): void;
+/**
+ * Deep-merge `over` into `base`, preferring `over` values where defined.
+ * Nested objects are merged recursively; arrays and primitives are
+ * replaced wholesale (no array-element merge — that'd be surprising).
+ *
+ * `undefined` in `over` is treated as "absent" and falls through to
+ * the `base` value. `null` is a real value and overrides.
+ */
+export declare function mergeOver<T extends object>(base: T, over: Partial<T>): T;
+/**
+ * Resolve the effective config: load file, layer env vars on top, layer
+ * CLI flags on top.
+ *
+ *   defaults  <  config.json  <  env  <  cli
+ *
+ * `cliOverrides` and `envOverrides` are partial — only the keys the
+ * caller actually wants to override should be set. `undefined` keys
+ * are skipped, so the existing flag parsers in cli.ts can pass through
+ * their normalized output without filtering nulls.
+ */
+export declare function resolveConfig(opts: {
+    path?: string;
+    envOverrides?: Partial<DarioConfig>;
+    cliOverrides?: Partial<DarioConfig>;
+}): {
+    config: DarioConfig;
+    source: 'file' | 'missing' | 'invalid';
+    error?: string;
+};

package/dist/config-file.js

@@ -0,0 +1,326 @@
+/**
+ * Config file foundation — v4.
+ *
+ * Persists user-tunable settings to `~/.dario/config.json` so the TUI
+ * can read + write them without having to manage shell scripts. Establishes
+ * the precedence chain that every effective value passes through:
+ *
+ *   defaults  <  config.json  <  env var  <  CLI flag
+ *
+ * Existing CLI flags + env vars continue to work unchanged. The config
+ * file is purely additive — a missing file resolves to defaults, exactly
+ * as v3 already behaved (since v3 had no config file).
+ *
+ * Atomic write: write to `config.json.tmp`, fsync, rename. Same primitive
+ * shape `atomicWriteJson` in src/live-fingerprint.ts uses for the
+ * captured CC template.
+ *
+ * Unknown keys in the loaded file are preserved (forward-compat for
+ * future schema versions); validation is best-effort, not strict — a
+ * corrupt or partial file falls back to defaults rather than aborting
+ * the process.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/**
+ * Bumped on any incompatible shape change. v4.0.0 ships schema v1. A
+ * future shape change would either add a new optional field (no bump)
+ * or rename / restructure (bump to v2 with a migration in `loadConfig`).
+ */
+export const CONFIG_SCHEMA_VERSION = 1;
+/**
+ * Default `~/.dario/config.json` location. Override in tests via
+ * `loadConfig(path)` / `saveConfig(path, …)`.
+ */
+export const DEFAULT_CONFIG_PATH = join(homedir(), '.dario', 'config.json');
+/**
+ * Defaults match the v3.x CLI flag defaults exactly. Any value not
+ * specified in config.json resolves to its corresponding default here.
+ * Updates to a flag default MUST land here too so they stay in sync.
+ */
+export function defaultConfig() {
+    return {
+        version: CONFIG_SCHEMA_VERSION,
+        port: 3456,
+        host: '127.0.0.1',
+        model: null,
+        passthrough: false,
+        preserveTools: false,
+        hybridTools: false,
+        mergeTools: false,
+        noAutoDetect: false,
+        strictTls: false,
+        strictTemplate: false,
+        noLiveCapture: false,
+        drainOnClose: false,
+        stealth: false,
+        pacing: { minMs: 500, jitterMs: 0 },
+        thinkTime: { baseMs: 0, perTokenMs: 0, jitterMs: 0, maxMs: 30_000 },
+        sessionStart: { minMs: 0, jitterMs: 0 },
+        session: {
+            idleRotateMs: 900_000,
+            rotateJitterMs: 0,
+            maxAgeMs: null,
+            perClient: false,
+        },
+        queue: { maxConcurrent: null, maxQueued: null, timeoutMs: null },
+        effort: null,
+        maxTokens: null,
+        passthroughBetas: [],
+        systemPrompt: null,
+        preserveOrchestrationTags: false,
+        logFile: null,
+    };
+}
+/**
+ * Load the config file at `path` (default ~/.dario/config.json).
+ *
+ * Returns `{ config, source }` where `source` describes the load outcome
+ * for the caller's UI:
+ *
+ *   - 'file'    — successfully loaded
+ *   - 'missing' — file doesn't exist; defaults returned (not an error)
+ *   - 'invalid' — file exists but parse / shape check failed; defaults
+ *                 returned. The TUI surfaces this so the user knows
+ *                 their saved settings were ignored.
+ *
+ * The loaded shape is type-checked field-by-field: unknown keys pass
+ * through (forward-compat), known keys with wrong types are dropped.
+ * Strict validation would force a config migration on every shape
+ * tweak; loose-but-typed lets the file evolve without breaking older
+ * dario installs that haven't been restarted.
+ */
+export function loadConfig(path = DEFAULT_CONFIG_PATH) {
+    if (!existsSync(path)) {
+        return { config: defaultConfig(), source: 'missing' };
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf-8');
+    }
+    catch (err) {
+        return {
+            config: defaultConfig(),
+            source: 'invalid',
+            error: `read failed: ${err.message}`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return {
+            config: defaultConfig(),
+            source: 'invalid',
+            error: `JSON parse failed: ${err.message}`,
+        };
+    }
+    if (!isPlainObject(parsed)) {
+        return {
+            config: defaultConfig(),
+            source: 'invalid',
+            error: `top-level value is not an object (got ${Array.isArray(parsed) ? 'array' : typeof parsed})`,
+        };
+    }
+    // Future schema bumps: dispatch on parsed.version here and run the
+    // appropriate migration. For now we accept any version field but
+    // pass the rest through field-by-field validation.
+    const typed = sanitize(parsed);
+    // Merge over defaults so callers always get a fully-populated shape.
+    return {
+        config: mergeOver(defaultConfig(), typed),
+        source: 'file',
+    };
+}
+/**
+ * Atomically write `config` to `path`. Writes to `<path>.tmp`, then
+ * renames into place — guarantees a reader never observes a half-written
+ * file. Creates parent directories if missing.
+ *
+ * Throws on permission / disk failures (caller handles + surfaces to
+ * the TUI's status line). Does NOT throw on a no-op rewrite of the
+ * same content; that's a cheap idempotent path.
+ */
+export function saveConfig(path = DEFAULT_CONFIG_PATH, config) {
+    const parent = dirname(path);
+    if (!existsSync(parent)) {
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+    }
+    const json = JSON.stringify({ ...config, version: CONFIG_SCHEMA_VERSION }, null, 2) + '\n';
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        writeFileSync(tmp, json, { mode: 0o600 });
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        // Best-effort cleanup of the temp file so we don't leave debris.
+        try {
+            unlinkSync(tmp);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * Deep-merge `over` into `base`, preferring `over` values where defined.
+ * Nested objects are merged recursively; arrays and primitives are
+ * replaced wholesale (no array-element merge — that'd be surprising).
+ *
+ * `undefined` in `over` is treated as "absent" and falls through to
+ * the `base` value. `null` is a real value and overrides.
+ */
+export function mergeOver(base, over) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(over)) {
+        if (v === undefined)
+            continue;
+        if (isPlainObject(v) && isPlainObject(out[k])) {
+            // Recurse into nested object groups (pacing, thinkTime, …) so a
+            // partial override on one sub-field doesn't wipe siblings.
+            out[k] = mergeOver(out[k], v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+/**
+ * Resolve the effective config: load file, layer env vars on top, layer
+ * CLI flags on top.
+ *
+ *   defaults  <  config.json  <  env  <  cli
+ *
+ * `cliOverrides` and `envOverrides` are partial — only the keys the
+ * caller actually wants to override should be set. `undefined` keys
+ * are skipped, so the existing flag parsers in cli.ts can pass through
+ * their normalized output without filtering nulls.
+ */
+export function resolveConfig(opts) {
+    const fromFile = loadConfig(opts.path);
+    const withEnv = mergeOver(fromFile.config, opts.envOverrides ?? {});
+    const withCli = mergeOver(withEnv, opts.cliOverrides ?? {});
+    return { ...fromFile, config: withCli };
+}
+// ── internals ────────────────────────────────────────────────────────
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/**
+ * Field-by-field type-check. Drops keys whose values don't match the
+ * expected type — better to silently fall back to a default than to
+ * abort startup on a stray manually-edited typo. Unknown top-level
+ * keys pass through unchanged (forward-compat for future fields).
+ */
+function sanitize(parsed) {
+    const out = { version: CONFIG_SCHEMA_VERSION };
+    const pickNumber = (k) => typeof parsed[k] === 'number' && Number.isFinite(parsed[k]) ? parsed[k] : undefined;
+    const pickBool = (k) => typeof parsed[k] === 'boolean' ? parsed[k] : undefined;
+    const pickString = (k) => typeof parsed[k] === 'string' ? parsed[k] : undefined;
+    const pickStringOrNull = (k) => {
+        if (parsed[k] === null)
+            return null;
+        if (typeof parsed[k] === 'string')
+            return parsed[k];
+        return undefined;
+    };
+    const pickNumberOrNull = (k) => {
+        if (parsed[k] === null)
+            return null;
+        if (typeof parsed[k] === 'number' && Number.isFinite(parsed[k]))
+            return parsed[k];
+        return undefined;
+    };
+    if (typeof parsed.version === 'number')
+        out.version = parsed.version;
+    if (pickNumber('port') !== undefined)
+        out.port = pickNumber('port');
+    if (pickString('host') !== undefined)
+        out.host = pickString('host');
+    const model = pickStringOrNull('model');
+    if (model !== undefined)
+        out.model = model;
+    for (const k of ['passthrough', 'preserveTools', 'hybridTools', 'mergeTools',
+        'noAutoDetect', 'strictTls', 'strictTemplate', 'noLiveCapture',
+        'drainOnClose', 'stealth', 'preserveOrchestrationTags']) {
+        const v = pickBool(k);
+        // Each `k` is a literal boolean-typed field on DarioConfig (verified
+        // by the `as const` tuple type above), so the assignment is sound
+        // — we route through `unknown` because TS can't narrow the union
+        // of literal keys to a single typed assignment at compile time.
+        if (v !== undefined)
+            out[k] = v;
+    }
+    // Nested groups — sanitize each, drop if not an object
+    if (isPlainObject(parsed.pacing)) {
+        out.pacing = {};
+        if (typeof parsed.pacing.minMs === 'number')
+            out.pacing.minMs = parsed.pacing.minMs;
+        if (typeof parsed.pacing.jitterMs === 'number')
+            out.pacing.jitterMs = parsed.pacing.jitterMs;
+    }
+    if (isPlainObject(parsed.thinkTime)) {
+        out.thinkTime = {};
+        for (const k of ['baseMs', 'perTokenMs', 'jitterMs', 'maxMs']) {
+            if (typeof parsed.thinkTime[k] === 'number') {
+                out.thinkTime[k] = parsed.thinkTime[k];
+            }
+        }
+    }
+    if (isPlainObject(parsed.sessionStart)) {
+        out.sessionStart = {};
+        if (typeof parsed.sessionStart.minMs === 'number')
+            out.sessionStart.minMs = parsed.sessionStart.minMs;
+        if (typeof parsed.sessionStart.jitterMs === 'number')
+            out.sessionStart.jitterMs = parsed.sessionStart.jitterMs;
+    }
+    if (isPlainObject(parsed.session)) {
+        out.session = {};
+        if (typeof parsed.session.idleRotateMs === 'number')
+            out.session.idleRotateMs = parsed.session.idleRotateMs;
+        if (typeof parsed.session.rotateJitterMs === 'number')
+            out.session.rotateJitterMs = parsed.session.rotateJitterMs;
+        if (parsed.session.maxAgeMs === null || typeof parsed.session.maxAgeMs === 'number') {
+            out.session.maxAgeMs = parsed.session.maxAgeMs;
+        }
+        if (typeof parsed.session.perClient === 'boolean')
+            out.session.perClient = parsed.session.perClient;
+    }
+    if (isPlainObject(parsed.queue)) {
+        out.queue = {};
+        for (const k of ['maxConcurrent', 'maxQueued', 'timeoutMs']) {
+            const v = parsed.queue[k];
+            if (v === null || (typeof v === 'number' && Number.isFinite(v))) {
+                out.queue[k] = v;
+            }
+        }
+    }
+    const effort = pickStringOrNull('effort');
+    if (effort !== undefined)
+        out.effort = effort;
+    // maxTokens is special — it's a number, the string 'client', or null
+    if (parsed.maxTokens === null)
+        out.maxTokens = null;
+    else if (parsed.maxTokens === 'client')
+        out.maxTokens = 'client';
+    else {
+        const n = pickNumber('maxTokens');
+        if (n !== undefined)
+            out.maxTokens = n;
+    }
+    if (Array.isArray(parsed.passthroughBetas)) {
+        out.passthroughBetas = parsed.passthroughBetas
+            .filter((x) => typeof x === 'string');
+    }
+    const sysPrompt = pickStringOrNull('systemPrompt');
+    if (sysPrompt !== undefined)
+        out.systemPrompt = sysPrompt;
+    const logFile = pickStringOrNull('logFile');
+    if (logFile !== undefined)
+        out.logFile = logFile;
+    // Silence unused-warning helper.
+    void pickNumberOrNull;
+    return out;
+}

package/dist/live-fingerprint.d.ts

@@ -282,7 +282,7 @@ export declare function _resetInstalledVersionProbeForTest(): void;
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.142";
+    readonly maxTested: "2.1.143";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,