clauderipple 0.11.0 → 0.12.0

package/dist/router/src/admin.js

@@ -25,7 +25,9 @@ import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import http from "node:http";
-import { execFile, spawn } from "node:child_process";
+import { runCli, startCliDetached, parseUpdateCheck } from "./cli-control.js";
+import { AutoUpdater } from "./autoupdate.js";
+export { parseUpdateCheck } from "./cli-control.js";
 import { fileURLToPath } from "node:url";
 import { adminPort, headerValueProblem, homeDir, searchProviderFor, ssidProblem, validate } from "./config.js";
 export { adminPort } from "./config.js";
@@ -33,7 +35,7 @@ import { generatedAgents } from "./agents.js";
 import { isJudgeOnlyModel } from "./model-policy.js";
 import { ModSettingsInputError, readModSettings, validateSettings, validateSettingsSchema, writeModSettings } from "./mod-settings.js";
 import { billingOf, claudeChoices, fillLadder, ladderNeedsFill } from "../../mod/hooks/ladder.js";
-import { normalizeSettings } from "../../mod/hooks/settings.js";
+import { normalizeSettings, twoLevelRungs } from "../../mod/hooks/settings.js";
 import { chatPickerModels } from "./picker.js";
 import { PRESETS } from "./presets.js";
 import { resolveCompatibleCaps } from "./compat.js";
@@ -254,21 +256,6 @@ let chatgptLogin = { running: false };
 let claudeOAuth = null;
 /** The Google (Antigravity) sign-in in progress (or the last one), for GET /api/google-login. */
 let googleOAuth = null;
-/** When the GUI last started an update. It restarts this router, so a fresh process starts at 0. */
-let updateStartedAt = 0;
-const UPDATE_RUN_MS = 10 * 60 * 1000;
-/** The last line of `clauderipple update --check --json`, or null when it said something else. */
-export function parseUpdateCheck(output) {
-    try {
-        const check = JSON.parse(output.trim().split("\n").pop() ?? "");
-        if (typeof check.current !== "string" || typeof check.newer !== "boolean" || typeof check.kind !== "string")
-            return null;
-        return { current: check.current, latest: typeof check.latest === "string" ? check.latest : null, newer: check.newer, kind: check.kind };
-    }
-    catch {
-        return null;
-    }
-}
 /** Shared catalog for the GUI: model-specific values override provider defaults. */
 export function effortLevels(cfg) {
     const providers = {
@@ -554,13 +541,17 @@ function ladderChoices(options) {
  */
 async function withFilledLadder(deps, scores, settings) {
     const general = settings.rules.general;
-    if (![general, ...settings.modes].some(set => ladderNeedsFill(set.rungs)))
+    const sets = [settings, ...settings.modes];
+    const domains = sets.flatMap(set => Object.values(set.domainRules ?? {}));
+    if (![general, ...settings.modes, ...domains].some(set => ladderNeedsFill(set.rungs)))
         return settings;
     try {
         const choices = ladderChoices(await modOptions(deps, scores));
-        const { rungs } = fillLadder(general.rungs, settings.allow, choices, settings.allowKnown);
-        const modes = settings.modes.map(mode => ({ ...mode, rungs: fillLadder(mode.rungs, settings.allow, choices, settings.allowKnown).rungs }));
-        return { ...settings, rules: { general: { mode: "ladder", rungs } }, modes };
+        const fill = (rungs) => fillLadder(rungs, settings.allow, choices, settings.allowKnown).rungs;
+        // A domain ladder has two levels: the fold keeps each pair equal, before and after the fill.
+        const fillDomains = (rules) => Object.fromEntries(Object.entries(rules).map(([key, rule]) => [key, { mode: "ladder", rungs: twoLevelRungs(fill(twoLevelRungs(rule.rungs))) }]));
+        const modes = settings.modes.map(mode => ({ ...mode, rungs: fill(mode.rungs), ...(mode.domainRules ? { domainRules: fillDomains(mode.domainRules) } : {}) }));
+        return { ...settings, rules: { general: { mode: "ladder", rungs: fill(general.rungs) } }, ...(settings.domainRules ? { domainRules: fillDomains(settings.domainRules) } : {}), modes };
     }
     catch (error) {
         deps.log.warn(`admin: filling the worker ladder failed: ${error.message}`);
@@ -646,6 +637,7 @@ async function buildStatus(deps, opts = {}) {
             problems.push(`provider:${name}`);
     return {
         version: deps.version,
+        autoUpdate: deps.autoUpdater?.status() ?? { enabled: cfg.autoUpdate !== false, running: false },
         readiness: { ready: problems.length === 0, problems },
         // Which files this process is running, so the app can tell an old router from its own after
         // an update: a zip unpacked next to the previous install left the old one serving (2026-09-15).
@@ -693,50 +685,6 @@ function pickerTrust() {
     pickerTrustMemo = { at: now, value };
     return value;
 }
-/** The ClaudeRipple CLI and the Node that installed us (`<home>/paths.json`, written by `install`). */
-function cliInvocation() {
-    let node = process.execPath;
-    // Same walk either way; the extension says which layout this file was loaded from.
-    let cli = path.resolve(here, `../../cli/src/index${path.extname(fileURLToPath(import.meta.url))}`);
-    let runtimeEnv = {};
-    try {
-        const p = JSON.parse(fs.readFileSync(path.join(homeDir(), "paths.json"), "utf8"));
-        if (p.node)
-            node = p.node;
-        if (p.env)
-            runtimeEnv = p.env;
-        if (p.cli)
-            cli = p.cli;
-    }
-    catch {
-        /* not installed via the CLI: fall back to our own node + repo layout */
-    }
-    return { node, cli, env: { ...process.env, ...runtimeEnv, CLAUDERIPPLE_HOME: homeDir() } };
-}
-function runCli(args, timeout = 180_000) {
-    return new Promise((resolveP) => {
-        const { node, cli, env } = cliInvocation();
-        execFile(node, [cli, ...args], { env, timeout }, (err, stdout, stderr) => {
-            resolveP({ ok: !err, output: `${stdout}${stderr}${err ? `\n${err.message}` : ""}`.trim() });
-        });
-    });
-}
-/**
- * Start the CLI in its own process group, writing to `log`. An update ends by restarting this
- * router, and launchd stops a job by killing its whole process group — an ordinary child would die
- * with the router halfway through the install that restarted it.
- */
-function startCliDetached(args, log) {
-    const { node, cli, env } = cliInvocation();
-    fs.mkdirSync(path.dirname(log), { recursive: true });
-    const out = fs.openSync(log, "w");
-    try {
-        spawn(node, [cli, ...args], { env, detached: true, stdio: ["ignore", out, out], windowsHide: true }).unref();
-    }
-    finally {
-        fs.closeSync(out);
-    }
-}
 /**
  * Whether this provider can actually run a web search — measured capability, not an assumption from
  * the vendor name. The rule is the router's own (`Proxy.canRunServerTools`, mirrored here because
@@ -1270,15 +1218,21 @@ function measureCandidates(p, modelId, catalogWire) {
     const known = "preset" in p && p.preset
         ? PRESETS.find((entry) => entry.id === p.preset)?.fallbackModels?.find((m) => m.id === modelId)
         : undefined;
-    if (known?.wire)
+    // The Gemini wire is not one `capabilities.ts` speaks: it has its own endpoint shape and header,
+    // so a model the preset records on it is not tried on the other three (a request there would
+    // answer 404/protocol-error and read as a model the plan refuses). Its wire stays as declared.
+    if (known?.wire && known.wire !== "google")
         add({ wire: known.wire, url: known.url ?? ownUrl, ...(known.authHeader ? { authHeader: known.authHeader } : {}) });
     add(own);
     if (p.type === "openai-compatible" && p.preset) {
         // One plan can serve several wires on one catalog. The preset's fallback list is the only place
         // any of that mapping is written down, so it is what the remaining candidates are read from.
         const preset = PRESETS.find((entry) => entry.id === p.preset);
-        for (const model of preset?.fallbackModels ?? [])
+        for (const model of preset?.fallbackModels ?? []) {
+            if (model.wire === "google")
+                continue;
             add({ wire: model.wire ?? defaultWire, url: model.url ?? p.url, ...(model.authHeader ? { authHeader: model.authHeader } : {}) });
+        }
     }
     else if (p.type === "openai-compatible") {
         // No table to read: the two OpenAI wires this kind of provider could be serving.
@@ -1288,7 +1242,7 @@ function measureCandidates(p, modelId, catalogWire) {
     else if (p.type === "anthropic-compatible" && p.preset) {
         const preset = PRESETS.find((entry) => entry.id === p.preset);
         for (const model of preset?.fallbackModels ?? [])
-            if (model.wire)
+            if (model.wire && model.wire !== "google")
                 add({ wire: model.wire, url: model.url ?? p.url, ...(model.authHeader ? { authHeader: model.authHeader } : {}) });
     }
     if (!known?.wire && catalogWire) {
@@ -1671,6 +1625,13 @@ function serveStatic(urlPath, res) {
     });
 }
 export function startAdmin(deps) {
+    // Standalone admin users share the same coordinator, but only the router entry starts scheduling.
+    const updater = deps.autoUpdater ?? new AutoUpdater({
+        home: homeDir(), version: deps.version, enabled: () => deps.config().autoUpdate !== false,
+        activity: () => ({ inFlight: 0 }), log: deps.log,
+        runCli: deps.runCli ?? runCli, startCliDetached: deps.startCliDetached ?? startCliDetached,
+    });
+    deps = { ...deps, autoUpdater: updater };
     const scores = new ModelScoreCatalog({ home: homeDir(), warn: message => deps.log.warn(message), ...(deps.modelScoresFetch ? { fetch: deps.modelScoresFetch } : {}) });
     // Set again once the socket is bound (port 0 in tests); the Origin check below compares against it.
     let boundPort = adminPort(deps.config());
@@ -2485,12 +2446,13 @@ export function startAdmin(deps) {
                 // The CLI answers both: it knows how this copy was installed, which decides what an update is
                 // (the tray asks it the same way). A POST checks again rather than trusting the page.
                 const r = await (deps.runCli ?? runCli)(["update", "--check", "--json"], 30_000);
-                const check = parseUpdateCheck(r.output);
+                const check = r.ok ? parseUpdateCheck(r.output) : null;
                 if (!check) {
                     sendJson(res, 502, { error: "could not check for updates", output: r.output.slice(-2000) });
                     return;
                 }
-                const running = updateStartedAt > 0 && Date.now() - updateStartedAt < UPDATE_RUN_MS;
+                updater.observe(check);
+                const running = updater.running();
                 if (method === "GET") {
                     sendJson(res, 200, { ...check, running });
                     return;
@@ -2507,9 +2469,7 @@ export function startAdmin(deps) {
                     sendJson(res, 409, { error: "an update is already running", ...check, running });
                     return;
                 }
-                updateStartedAt = Date.now();
-                const log = path.join(homeDir(), "logs", "update.log");
-                (deps.startCliDetached ?? startCliDetached)(["update"], log);
+                const log = updater.install(check);
                 deps.log.info(`admin: update ${check.current} -> ${check.latest ?? "?"} started via GUI (output in ${log})`);
                 sendJson(res, 202, { started: true, ...check, log });
                 return;
@@ -2537,9 +2497,12 @@ export function startAdmin(deps) {
                 const abort = new AbortController();
                 res.on("close", () => { if (!res.writableFinished)
                     abort.abort(); });
+                // The CLI's own session, so the request log shows which session generated the image.
+                const session = req.headers["x-claude-code-session-id"];
+                const meta = typeof session === "string" && /^[\w-]{1,128}$/.test(session) ? { session } : undefined;
                 const started = Date.now();
                 try {
-                    const image = await deps.image(parsed, abort.signal);
+                    const image = await deps.image(parsed, abort.signal, meta);
                     deps.log.info(`admin: image ${image.size ?? "?"} ${image.quality ?? "?"} ${image.format}, ${parsed.images?.length ?? 0} reference(s), ${image.data.length} bytes in ${Date.now() - started} ms`);
                     res.writeHead(200, {
                         "content-type": `image/${image.format}`,
@@ -2602,8 +2565,10 @@ export function startAdmin(deps) {
                 const provider = query.get("provider") || undefined;
                 const session = query.get("session") || undefined;
                 const kindValue = query.get("kind");
-                const kind = kindValue === "messages" || kindValue === "count_tokens" || kindValue === "other" ? kindValue : undefined;
-                sendJson(res, 200, { requests: deps.requests.list(n, { ...(provider ? { provider } : {}), ...(kind ? { kind } : {}), ...(session ? { session } : {}) }) });
+                // A comma-separated list so one call can ask for several kinds; unknown entries are ignored
+                // and a list with nothing valid left means no filter.
+                const kinds = kindValue === null ? [] : kindValue.split(",").filter((k) => k === "messages" || k === "count_tokens" || k === "other" || k === "image");
+                sendJson(res, 200, { requests: deps.requests.list(n, { ...(provider ? { provider } : {}), ...(kinds.length ? { kind: kinds } : {}), ...(session ? { session } : {}) }) });
                 return;
             }
             if (pathname === "/api/requests/summary" && method === "GET") {

package/dist/router/src/autoupdate.js

@@ -0,0 +1,299 @@
+// The router, not the optional tray, owns update scheduling. All process/time boundaries are injected.
+import fs from "node:fs";
+import path from "node:path";
+import { writeJsonAtomic } from "./locked-file.js";
+import { parseUpdateCheck } from "./cli-control.js";
+const MINUTE = 60_000;
+export const UPDATE_TIMING = { first: 10 * MINUTE, interval: 12 * 60 * MINUTE, jitter: 30 * MINUTE, idle: 10 * MINUTE, poll: 5 * MINUTE, backoff: 24 * 60 * MINUTE };
+const realClock = {
+    now: Date.now, random: Math.random,
+    later(fn, ms) { const timer = setTimeout(fn, ms); timer.unref(); return () => clearTimeout(timer); },
+};
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        return true; // Permission errors cannot prove that an installer stopped.
+    }
+}
+function isAttempt(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const a = value;
+    return typeof a.from === "string" && typeof a.to === "string" && typeof a.at === "number" && Number.isFinite(a.at)
+        && (a.pid === undefined || (Number.isInteger(a.pid) && a.pid > 0));
+}
+function load(file) {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { failures: {} };
+        throw error;
+    }
+    if (!raw || typeof raw !== "object")
+        throw new Error("invalid update state");
+    const s = raw;
+    if (!s.failures || typeof s.failures !== "object" || Array.isArray(s.failures)
+        || Object.values(s.failures).some((t) => typeof t !== "number" || !Number.isFinite(t))
+        || (s.pending !== undefined && !isAttempt(s.pending)) || (s.completed !== undefined && !isAttempt(s.completed))
+        || [s.available, s.kind, s.lastError].some((v) => v !== undefined && typeof v !== "string"))
+        throw new Error("invalid update state");
+    return { ...s, failures: s.failures };
+}
+export class AutoUpdater {
+    deps;
+    clock;
+    file;
+    startedAt;
+    saved = { failures: {} };
+    blocked = false;
+    active = false;
+    cancel;
+    waiting;
+    childRunning = false;
+    constructor(deps) {
+        this.deps = deps;
+        this.clock = deps.clock ?? realClock;
+        this.startedAt = this.clock.now();
+        this.file = path.join(deps.home, "auto-update.json");
+        try {
+            this.saved = load(this.file);
+            const pending = this.saved.pending;
+            if (pending?.to === deps.version) {
+                this.saved.completed = { ...pending, at: this.clock.now() };
+                delete this.saved.pending;
+                delete this.saved.available;
+                delete this.saved.lastError;
+                delete this.saved.failures[pending.to];
+                this.persist();
+                this.info(`completed ${pending.from} -> ${pending.to}`);
+            }
+            else if (pending && !(pending.pid && (deps.alive ?? alive)(pending.pid))) {
+                this.fail(pending, "previous update did not start the recorded target version");
+            }
+        }
+        catch (error) {
+            this.blocked = true; // Never overwrite unreadable state or install without durable intent.
+            this.saved.lastError = String(error);
+            this.info(`disabled installs: ${error}`);
+        }
+    }
+    info(message) { this.deps.log.info(`auto-update: ${message}`); }
+    persist() {
+        try {
+            writeJsonAtomic(this.file, this.saved);
+        }
+        catch (error) {
+            this.blocked = true;
+            this.saved.lastError = String(error);
+            this.info(`cannot persist state; disabled installs: ${error}`);
+            throw error;
+        }
+    }
+    completedInstallerRunning() {
+        const completed = this.saved.completed;
+        if (!completed?.pid)
+            return false;
+        if ((this.deps.alive ?? alive)(completed.pid))
+            return true;
+        // The CLI may install the tray runtime AFTER the new router starts. Retire its PID once gone
+        // so a later, unrelated process reusing that PID cannot suppress updates indefinitely.
+        delete completed.pid;
+        try {
+            if (!this.blocked)
+                this.persist();
+        }
+        catch { /* persist logs and disables installs */ }
+        return false;
+    }
+    pendingRunning() {
+        const pending = this.saved.pending;
+        if (!pending)
+            return this.completedInstallerRunning();
+        if (this.childRunning || (pending.pid && (this.deps.alive ?? alive)(pending.pid)))
+            return true;
+        if (this.clock.now() - pending.at < UPDATE_TIMING.first)
+            return true;
+        this.fail(pending, "update did not restart the router at the target version");
+        return false;
+    }
+    status() {
+        const completed = this.saved.completed;
+        return {
+            enabled: this.deps.enabled(), running: !!this.saved.pending || this.completedInstallerRunning(),
+            ...(this.saved.kind ? { kind: this.saved.kind } : {}),
+            ...(this.saved.available ? { available: this.saved.available } : {}),
+            ...(completed ? { lastUpdatedFrom: completed.from, lastUpdatedTo: completed.to, lastUpdatedAt: completed.at } : {}),
+            ...(this.saved.lastError ? { lastError: this.saved.lastError } : {}),
+        };
+    }
+    observe(check) {
+        this.saved.kind = check.kind;
+        if (check.newer && check.latest)
+            this.saved.available = check.latest;
+        else
+            delete this.saved.available;
+        if (!this.blocked)
+            this.persist();
+    }
+    running() { return this.pendingRunning(); }
+    /** Shared by POST /api/update and the scheduler. Persists intent BEFORE launching anything. */
+    install(check) {
+        if (this.blocked)
+            throw new Error("update state is unreadable; refusing to install");
+        if (check.kind !== "script" && check.kind !== "npm")
+            throw new Error(`install kind ${check.kind} cannot auto-install`);
+        if (!check.newer || !check.latest || !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(check.latest))
+            throw new Error("no valid newer version to install");
+        if (this.pendingRunning())
+            throw new Error("an update is already running");
+        const attempt = { from: this.deps.version, to: check.latest, at: this.clock.now() };
+        const log = path.join(this.deps.home, "logs", "update.log");
+        this.saved.pending = attempt;
+        delete this.saved.lastError;
+        this.persist();
+        this.info(`install ${attempt.from} -> ${attempt.to}; output ${log}`);
+        let child;
+        try {
+            // Pin the version that was recorded, even if npm's latest tag changes while waiting for idle.
+            child = this.deps.startCliDetached(["update"], log, { CLAUDERIPPLE_PACKAGE: `clauderipple@${attempt.to}` });
+        }
+        catch (error) {
+            this.fail(attempt, String(error));
+            throw error;
+        }
+        if (child) {
+            this.childRunning = true;
+            void child.completion.then((result) => {
+                this.childRunning = false;
+                if (!result.ok)
+                    this.fail(attempt, result.output);
+                else
+                    this.info(`CLI finished ${attempt.to}; awaiting target router startup`);
+            }, (error) => {
+                this.childRunning = false;
+                this.fail(attempt, String(error));
+            }).catch((error) => {
+                this.blocked = true;
+                this.info(`cannot persist failure; disabled installs: ${error}`);
+            });
+            if (child.pid !== undefined) {
+                attempt.pid = child.pid;
+                try {
+                    this.persist();
+                }
+                catch (error) {
+                    // The installer is already alive: never clear its intent and allow a second launch.
+                    this.blocked = true;
+                    this.saved.lastError = String(error);
+                    this.info(`cannot persist installer PID; disabled installs: ${error}`);
+                }
+            }
+        }
+        return log;
+    }
+    fail(attempt, error) {
+        if (this.saved.pending?.at !== attempt.at || this.saved.pending.to !== attempt.to)
+            return;
+        this.saved.failures[attempt.to] = this.clock.now();
+        this.saved.lastError = error.slice(-2000);
+        delete this.saved.pending;
+        this.persist();
+        this.info(`failed ${attempt.to}; back off 24h: ${this.saved.lastError}`);
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.info("first check in 10 minutes");
+        this.schedule(UPDATE_TIMING.first);
+    }
+    stop() { this.active = false; this.cancel?.(); this.waiting = undefined; this.info("scheduler stopped"); }
+    schedule(ms) {
+        this.cancel?.();
+        if (this.active)
+            this.cancel = this.clock.later(() => { void this.tick(); }, ms);
+    }
+    nextCycle() {
+        this.waiting = undefined;
+        const ms = UPDATE_TIMING.interval + (this.clock.random() * 2 - 1) * UPDATE_TIMING.jitter;
+        this.info(`next check in ${Math.round(ms / MINUTE)} minutes`);
+        this.schedule(ms);
+    }
+    async tick() {
+        try {
+            if (this.pendingRunning()) {
+                this.info("installer still running; skip cycle");
+                this.nextCycle();
+                return;
+            }
+            if (!this.waiting) {
+                this.info("checking via CLI");
+                const result = await this.deps.runCli(["update", "--check", "--json"], 30_000);
+                if (!this.active)
+                    return;
+                const check = result.ok ? parseUpdateCheck(result.output) : null;
+                if (!check)
+                    throw new Error(`update check failed: ${result.output.slice(-1000)}`);
+                this.observe(check);
+                if (!check.newer || !check.latest) {
+                    this.info("no newer version");
+                    this.nextCycle();
+                    return;
+                }
+                this.waiting = { check, until: this.clock.now() + UPDATE_TIMING.backoff };
+            }
+            const { check, until } = this.waiting;
+            if (this.blocked || !this.deps.enabled()) {
+                this.info("automatic installation disabled");
+                this.nextCycle();
+                return;
+            }
+            if (check.kind !== "script" && check.kind !== "npm") {
+                this.info(`skip install kind ${check.kind}`);
+                this.nextCycle();
+                return;
+            }
+            const failedAt = this.saved.failures[check.latest];
+            if (failedAt !== undefined && this.clock.now() - failedAt < UPDATE_TIMING.backoff) {
+                this.info(`backoff ${check.latest}`);
+                this.nextCycle();
+                return;
+            }
+            if (this.clock.now() >= until) {
+                this.info("gave up waiting for idle after 24h");
+                this.nextCycle();
+                return;
+            }
+            const activity = this.deps.activity();
+            const last = Math.max(this.startedAt, activity.lastStartedAt ?? 0, activity.lastEndedAt ?? 0);
+            if (activity.inFlight !== 0 || this.clock.now() - last < UPDATE_TIMING.idle) {
+                this.info("waiting for zero in-flight requests and 10 minutes idle; recheck in 5 minutes");
+                this.schedule(UPDATE_TIMING.poll);
+                return;
+            }
+            this.install(check);
+            this.nextCycle();
+        }
+        catch (error) {
+            this.saved.lastError = String(error).slice(-2000);
+            this.info(`cycle failed: ${error}`);
+            try {
+                if (!this.blocked)
+                    this.persist();
+            }
+            catch (saveError) {
+                this.blocked = true;
+                this.info(`cannot persist state: ${saveError}`);
+            }
+            this.nextCycle();
+        }
+    }
+}

package/dist/router/src/bootstrap.js

@@ -7,7 +7,7 @@ import os from "node:os";
 import path from "node:path";
 import { agentAliases } from "./agents.js";
 import { isJudgeOnlyModel } from "./model-policy.js";
-import { chatPickerModels } from "./picker.js";
+import { chatPickerModels, providerModelWindow } from "./picker.js";
 export const BOOTSTRAP_PATH = "/api/claude_cli/bootstrap";
 /**
  * Model ids named in the user's agent definitions (~/.claude/agents/*.md frontmatter `model:`),
@@ -60,7 +60,8 @@ export function injectBootstrap(body, cfg, agentDirs) {
         const [base, effort] = id.split("@");
         const named = cfg.cli.extraModels.find((m) => m.model === base);
         // An "<model>@<effort>" entry is the same model with a different effort, so it has the same window.
-        return { model: id, name: `${named?.name ?? base}${effort ? ` · ${effort}` : ""}`, ...(named?.contextWindow ? { contextWindow: named.contextWindow } : {}) };
+        const window = named?.contextWindow ?? providerModelWindow({ ...cfg, aliases }, base ?? id);
+        return { model: id, name: `${named?.name ?? base}${effort ? ` · ${effort}` : ""}`, ...(window ? { contextWindow: window } : {}) };
     });
     const extra = chatPickerModels({ ...cfg, aliases, cli: { ...cfg.cli, extraModels: [...cfg.cli.extraModels, ...fromAgents] } });
     const win = cfg.cli.autoCompactWindow;

package/dist/router/src/cli-control.js

@@ -0,0 +1,65 @@
+// Process boundary shared by dashboard actions and the router-owned updater.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile, spawn } from "node:child_process";
+import { homeDir } from "./config.js";
+/** Only the final CLI output line is the machine-readable answer. */
+export function parseUpdateCheck(output) {
+    try {
+        const check = JSON.parse(output.trim().split("\n").pop() ?? "");
+        if (!check || typeof check.current !== "string" || typeof check.newer !== "boolean" || typeof check.kind !== "string")
+            return null;
+        return { current: check.current, latest: typeof check.latest === "string" ? check.latest : null, newer: check.newer, kind: check.kind };
+    }
+    catch {
+        return null; // An invalid external CLI response is reported by the caller.
+    }
+}
+/** paths.json is written by install; a checkout has no such file. */
+function cliInvocation() {
+    let node = process.execPath;
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    let cli = path.resolve(here, `../../cli/src/index${path.extname(fileURLToPath(import.meta.url))}`);
+    let runtimeEnv = {};
+    try {
+        const p = JSON.parse(fs.readFileSync(path.join(homeDir(), "paths.json"), "utf8"));
+        if (p.node)
+            node = p.node;
+        if (p.env)
+            runtimeEnv = p.env;
+        if (p.cli)
+            cli = p.cli;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return { node, cli, env: { ...process.env, ...runtimeEnv, CLAUDERIPPLE_HOME: homeDir() } };
+}
+export function runCli(args, timeout = 180_000) {
+    return new Promise((resolve) => {
+        const { node, cli, env } = cliInvocation();
+        execFile(node, [cli, ...args], { env, timeout }, (error, stdout, stderr) => {
+            resolve({ ok: !error, output: `${stdout}${stderr}${error ? `\n${error.message}` : ""}`.trim() });
+        });
+    });
+}
+/** Separate process group: launchd must not kill the installer when it drains this router. */
+export function startCliDetached(args, log, extraEnv = {}) {
+    const { node, cli, env } = cliInvocation();
+    fs.mkdirSync(path.dirname(log), { recursive: true });
+    const out = fs.openSync(log, "w");
+    try {
+        const child = spawn(node, [cli, ...args], { env: { ...env, ...extraEnv }, detached: true, stdio: ["ignore", out, out], windowsHide: true });
+        const completion = new Promise((resolve) => {
+            child.once("error", (error) => resolve({ ok: false, output: error.message }));
+            child.once("exit", (code, signal) => resolve({ ok: code === 0, output: `update exited ${code ?? signal}; see ${log}` }));
+        });
+        child.unref();
+        return { ...(child.pid === undefined ? {} : { pid: child.pid }), completion };
+    }
+    finally {
+        fs.closeSync(out);
+    }
+}