@chibitek/chibi 0.1.155 → 0.1.158

package/dist-server/server/container-computer.js

@@ -6,13 +6,13 @@
 // `cua-driver mcp` inside the container; this module never reimplements clicks,
 // typing, screenshots, accessibility, or window discovery.
 import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { chmod, lstat, mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve, win32 } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { augmentedPath, resolveCliSpawn } from "./env-path.js";
+import { colimaStartPlan, dockerEnvForColima, startColima } from "./colima-docker.js";
 import { spawnOptionsFor } from "./spawn-command.js";
 import { DATA_DIR } from "./config.js";
 import { SPAWNED_PROXIES } from "./proxy-paths.js";
@@ -188,7 +188,11 @@ async function sh(cmd, args, timeout = 8000) {
         timeout,
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
-        env: { ...process.env, PATH: augmentedPath() },
+        // Every docker call on a Mac goes to Colima's socket, whatever docker
+        // context Docker Desktop may have left active.
+        env: cmd === "docker"
+            ? dockerEnvForColima({ ...process.env, PATH: augmentedPath() })
+            : { ...process.env, PATH: augmentedPath() },
     }));
     return { stdout };
 }
@@ -233,77 +237,36 @@ export async function containerRuntimeStatus(runner = sh, platform = process.pla
         daemonUp: healthyIndex >= 0,
     };
 }
-const COLIMA_START_TIMEOUT_MS = 4 * 60_000;
-const DESKTOP_LAUNCH_TIMEOUT_MS = 30_000;
-export async function containerRuntimeStartPlan(runner = sh, platform = process.platform, appExists = existsSync, env = process.env) {
-    if (platform === "darwin") {
-        const context = await runner("docker", ["context", "show"], 4000).then(({ stdout }) => stdout.trim()).catch(() => "");
-        const desktopApp = ["/Applications/Docker.app", join(env.HOME ?? "", "Applications", "Docker.app")].some((path) => appExists(path));
-        const desktop = { label: "Docker Desktop", command: "open", args: ["-a", "Docker"], timeoutMs: DESKTOP_LAUNCH_TIMEOUT_MS };
-        if (context === "desktop-linux" && desktopApp)
-            return desktop;
-        if (await installed("colima", runner, platform)) {
-            // `colima start` on a running profile is a no-op, so an instance the
-            // person started with their own flags is left exactly as it is.
-            const profile = context.startsWith("colima-") ? context.slice("colima-".length) : "";
-            return {
-                label: "Colima",
-                command: "colima",
-                args: ["start", ...(profile ? ["--profile", profile] : [])],
-                timeoutMs: COLIMA_START_TIMEOUT_MS,
-            };
-        }
-        return desktopApp ? desktop : null;
-    }
-    if (platform === "win32") {
-        const exe = win32.join(env.ProgramFiles ?? "C:\\Program Files", "Docker", "Docker", "Docker Desktop.exe");
-        // Start-Process returns at once; Docker Desktop keeps running on its own.
-        return appExists(exe)
-            ? {
-                label: "Docker Desktop",
-                command: "powershell.exe",
-                args: ["-NoProfile", "-NonInteractive", "-Command", `Start-Process -FilePath '${exe.replaceAll("'", "''")}'`],
-                timeoutMs: DESKTOP_LAUNCH_TIMEOUT_MS,
-            }
-            : null;
-    }
-    return null;
+/** How this machine's stopped Docker engine is started, or null when Atomic
+ * must not try: Colima on a Mac where it is installed, never Docker Desktop
+ * on any platform (colima-docker.ts). Linux needs root for the daemon and
+ * Windows runs the Local VM on Podman, so neither is started here. */
+export async function containerRuntimeStartPlan(runner = sh, platform = process.platform, env = process.env) {
+    return platform === "darwin" && await installed("colima", runner, platform) ? colimaStartPlan(env) : null;
 }
 let runtimeStartInFlight = null;
-/** Start the person's installed Docker engine when it is stopped, then wait,
- * bounded, until `docker info` answers. Never installs anything and never
- * touches Podman or Apple container. One start at a time: concurrent callers
- * (startup and a turn) share the same attempt. Callers decide whether the
- * person allowed it; this only does it. */
+let runtimeStartError = null;
+/** Why the last start left the Local VM without an engine; null once docker answers. */
+export const containerRuntimeError = () => runtimeStartError;
+/** Start the person's installed Colima when docker is not answering, with a
+ * retry and a restart, bounded (startColima). Never installs anything, never
+ * opens Docker Desktop, never touches Podman or Apple container. One start at
+ * a time: concurrent callers (startup and a turn) share the same attempt.
+ * Callers decide whether the person allowed it; this only does it. */
 export function ensureContainerRuntime(opts = {}) {
     if (runtimeStartInFlight)
         return runtimeStartInFlight;
     const attempt = (async () => {
         const runner = opts.runner ?? sh;
         const platform = opts.platform ?? process.platform;
-        const sleep = opts.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
         const before = await containerRuntimeStatus(runner, platform);
         if (before.daemonUp || before.runtime !== "docker")
-            return { status: before, started: null };
-        const plan = await containerRuntimeStartPlan(runner, platform, opts.appExists, opts.env);
-        if (!plan)
-            return { status: before, started: null };
-        try {
-            await runner(plan.command, plan.args, plan.timeoutMs);
-        }
-        catch {
-            // Colima can exit non-zero while its VM is still coming up, and the
-            // wait below is the real test; a launch that truly failed times out.
-        }
-        const deadline = Date.now() + (opts.waitMs ?? 120_000);
-        let status = await containerRuntimeStatus(runner, platform);
-        while (!status.daemonUp && Date.now() < deadline) {
-            await sleep(opts.pollMs ?? 2000);
-            status = await containerRuntimeStatus(runner, platform);
-        }
-        return { status, started: plan.label };
+            return { status: before, started: null, error: null };
+        const plan = await containerRuntimeStartPlan(runner, platform, opts.env);
+        return startColima(plan, before, { runner, platform, status: () => containerRuntimeStatus(runner, platform), ...opts });
     })();
     runtimeStartInFlight = attempt;
+    void attempt.then((outcome) => { runtimeStartError = outcome.status.daemonUp ? null : outcome.error; }, () => { });
     void attempt.finally(() => { if (runtimeStartInFlight === attempt)
         runtimeStartInFlight = null; }).catch(() => { });
     return attempt;
@@ -989,6 +952,11 @@ export function containerComputerMcp(runtime, control, target = SHARED_LOCAL_VM_
         // through `ps` for the life of the bridge.
         env: {
             ELECTRON_RUN_AS_NODE: "1",
+            // The bridge pins docker to Colima itself too (container-mcp.ts); this
+            // keeps a host that spawns it with a scrubbed environment on Colima.
+            ...(runtime === "docker" && process.platform === "darwin"
+                ? { DOCKER_HOST: dockerEnvForColima(process.env, "darwin").DOCKER_HOST ?? "" }
+                : {}),
             ...(control ? { OMB_CONTROL_URL: control.url, OMB_CONTROL_TOKEN: control.token } : {}),
             // Where the bridge remembers Cua Driver's tool list, and whether it
             // must stand in for Cua Driver until the first tool call (the VM is
@@ -1011,7 +979,7 @@ export function setupCommands(runtime, platform = process.platform, target = SHA
         : runtime === "podman" && platform !== "linux"
             ? "podman machine init; podman machine start"
             : runtime === "docker" && platform === "darwin"
-                ? "colima start || open -a Docker"
+                ? "colima start"
                 : runtime === "docker" && platform === "linux"
                     ? "sudo systemctl start docker"
                     : null;

package/dist-server/server/container-mcp.js

@@ -3,6 +3,8 @@
 // piping, drain-safe exit, and watchdog live in mcp-bridge.ts, shared with
 // the VPS entry point.
 import { cuaExecArgs } from "./container-computer.js";
+import { dockerEnvForColima } from "./colima-docker.js";
+import { augmentedPath } from "./env-path.js";
 import { runMcpBridge } from "./mcp-bridge.js";
 const [runtime, container, socket] = process.argv.slice(2);
 if (!runtime || !["docker", "podman", "container"].includes(runtime)) {
@@ -27,6 +29,9 @@ runMcpBridge({
     command: runtime,
     args: cuaExecArgs(["mcp", "--socket", socket], { container, interactive: true }),
     label: "Cua Driver",
+    // On a Mac, docker always talks to Colima's socket, never to whatever
+    // context Docker Desktop left active.
+    ...(runtime === "docker" ? { env: dockerEnvForColima({ ...process.env, PATH: augmentedPath() }) } : {}),
     // No liveness watchdog: the runtime CLI talks to a local daemon and fails
     // fast on its own — there is no silent WAN peer to wedge on.
     ...(controlUrl && controlToken ? { gate: { url: controlUrl, token: controlToken } } : {}),

package/dist-server/server/device-routing.js

@@ -0,0 +1,60 @@
+// Device routing for approval requests (docs/specs/remote-approval/spec.md).
+//
+// The server tracks which user endpoint is live — the desktop's event
+// stream or a paired phone's — and an approval request routes to the live
+// user device. A remote session (no live desktop stream) routes to the
+// phone automatically. It never broadcasts: the target is one device kind,
+// picked here, and every client learns it from the stream's hello frame.
+/** Where an approval goes. The desktop wins whenever it is live, so a
+ * person sitting at the Mac is never interrupted on the phone; a remote
+ * session routes to the phone; nothing live still answers "phone" with
+ * live: false, so the ask is queued for the one device that can travel to
+ * the person rather than broadcast. */
+export function pickApprovalRoute(liveness) {
+    if (liveness.desktop > 0)
+        return { device: "desktop", live: true };
+    if (liveness.phone > 0)
+        return { device: "phone", live: true };
+    return { device: "phone", live: false };
+}
+/** The server's count of live user streams by device kind. Written by the
+ * SSE route's add/remove, read when an approval is raised or a client
+ * asks. Counts, never identities: routing is about which kind of device is
+ * present, not who is watching. */
+export class DeviceRouteRegistry {
+    liveness = { desktop: 0, phone: 0 };
+    /** A stream opened. `kind` is the connection's auth kind: loopback is
+     * the desktop app on this machine; a paired session is a phone. */
+    streamOpened(kind) {
+        if (kind === "loopback")
+            this.liveness.desktop += 1;
+        else if (kind === "session")
+            this.liveness.phone += 1;
+    }
+    streamClosed(kind) {
+        if (kind === "loopback")
+            this.liveness.desktop = Math.max(0, this.liveness.desktop - 1);
+        else if (kind === "session")
+            this.liveness.phone = Math.max(0, this.liveness.phone - 1);
+    }
+    route() {
+        return pickApprovalRoute(this.liveness);
+    }
+    counts() {
+        return { ...this.liveness };
+    }
+}
+/** End one stream: drop it from the fan-out set, end the response, and
+ * tell approval routing the device went away. Every removal path goes
+ * through here so the routing counts cannot drift from the stream set. */
+export function removeStream(clients, registry, client) {
+    if (!clients.delete(client))
+        return;
+    registry.streamClosed(client.authKind);
+    try {
+        client.res.end();
+    }
+    catch {
+        /* already gone */
+    }
+}

package/dist-server/server/drivers/claude.js

@@ -1615,6 +1615,8 @@ export const ClaudeDriver = {
                 // A settled turn owns no retry budget. Retained CLI sessions may run
                 // many later turns on this thread, and each must start fresh.
                 retryState.delete(threadId);
+                if (t.authFailed)
+                    closeSession(threadId, "sign-in required");
                 emit({ ...base(threadId, t.turnId), type: "turn.completed", ok, stopReason, cost, ...(usage ? { usage } : {}) });
                 if (session.child.exitCode === null && !session.closing)
                     armIdle(threadId);
@@ -1772,11 +1774,7 @@ export const ClaudeDriver = {
                     case "assistant": {
                         const msg = o.message ?? {};
                         const text = firstText(msg.content);
-                        // An unauthenticated turn comes back as an api-error frame whose
-                        // only content is the CLI's own "run /login" instruction — a
-                        // command this app has no terminal to run, so relaying it as a
-                        // reply strands the user. Every other engine reports this as a
-                        // setup error; that is what routes them to the sign-in card.
+                        // CLI auth diagnostics enter the shared fallback path, never assistant text.
                         if (claudeAuthFailure(o, text)) {
                             if (session.turn)
                                 session.turn.authFailed = true;
@@ -1853,12 +1851,16 @@ export const ClaudeDriver = {
                         if (o.origin?.kind === "task-notification")
                             break;
                         {
-                            // result.usage is this invocation's total — one process per turn,
-                            // so it is the turn's figure. cache reads count as input: they
-                            // are billed (at the cache rate) and they fill the window — but
-                            // they are reported separately too, so the UI can show how much
-                            // of the figure was context re-read rather than new text.
+                            // Result usage includes input, output and cached context.
                             const t = session.turn;
+                            // Some CLI failures exist only on the result, with no assistant frame.
+                            const resultError = [o.result, ...(Array.isArray(o.errors) ? o.errors : [])]
+                                .filter((value) => typeof value === "string").join("\n");
+                            if (o.is_error === true && !t?.authFailed && claudeAuthFailure({ error: o.error ?? "api_error" }, resultError)) {
+                                if (t)
+                                    t.authFailed = true;
+                                emit({ ...base(threadId, currentTurnId()), type: "runtime.error", message: resultError, setup: true, failure: "auth_failed" });
+                            }
                             const usage = o.usage
                                 ? {
                                     input: (o.usage.input_tokens || 0) + (o.usage.cache_read_input_tokens || 0) + (o.usage.cache_creation_input_tokens || 0),
@@ -1870,7 +1872,7 @@ export const ClaudeDriver = {
                                 : undefined;
                             const earlier = t?.carried;
                             const result = {
-                                ok: o.is_error !== true,
+                                ok: o.is_error !== true && !t?.authFailed,
                                 stopReason: t?.authFailed ? "auth_required"
                                     : t?.refreshConflict && o.is_error === true ? "credential_refresh_conflict"
                                         : claudeResultStopReason(o),

package/dist-server/server/drivers/local-inject.js

@@ -213,9 +213,8 @@ function idsFromModelsPayload(payload) {
         const low = id.toLowerCase();
         if (low.includes("embed") || low.includes("bge-") || low.includes("nomic"))
             return [];
-        // An Ollama Cloud model is not this machine's: it bills a plan.
-        if (isOllamaCloudModel(record))
-            return [];
+        // Ollama Cloud tags a signed-in Ollama serves are listed too (Erick,
+        // 2026-10-24); the label says they bill a plan.
         return [id];
     });
 }
@@ -349,7 +348,7 @@ export async function probeLocalInjects(env = process.env, fetchImpl = fetch) {
                 id: encodeInjectId(host.id, model),
                 host: host.id,
                 model,
-                label: `${model} (${host.label})`,
+                label: isOllamaCloudModel(model) ? `${model} (${host.label}, plan-billed)` : `${model} (${host.label})`,
                 loaded: loaded.has(model),
                 ...(contextWindow ? { contextWindow } : {}),
             });

package/dist-server/server/engine-failover.js

@@ -1,16 +1,19 @@
 import { classifyEngineFailure, isCredentialDead, mayBeReplyFailure, replyEngineFailure, statedReset } from "./engine-failure.js";
-/** At most this many engines take part in one turn: the first and five
- * switches. Each engine is tried once per turn anyway; this only bounds a
- * long run of failures, which then stops rather than loops. */
-export const MAX_ENGINES_PER_TURN = 6;
-/** OpenRouter's rule for an error no pattern recognises: fail over while
- * nothing has reached the person yet (no text, no tool run), as a
- * provider_error. Once part of the answer or an action is out, the turn ends
- * as it did. */
+/** The two-try cap: at most this many engines take part in one turn, the
+ * first and one switch. Every failed attempt counts toward it, whatever the
+ * failure was (a usage limit, a sign-in, a stall, or an error no pattern
+ * recognises). When the second engine fails too, the turn stops with its
+ * one plain line rather than walking the rest of the ladder. */
+export const MAX_ENGINES_PER_TURN = 2;
+/** What the engine said when it ended a turn failed without any words. */
+export const NO_ANSWER_FAILURE = "The engine ended the turn without an answer.";
+/** Any failure counts: a failed end that no pattern recognises is a
+ * provider_error, whether or not part of the answer or a tool run already
+ * reached the person (the next engine continues from there, told what was
+ * said and which actions ran, as for a usage limit) and whether or not the
+ * engine said why. */
 function unrecognisedFailure(turn) {
-    if (turn.said || turn.tools || turn.partial || !turn.lastError)
-        return undefined;
-    return { kind: "provider_error", message: turn.lastError };
+    return { kind: "provider_error", message: turn.lastError ?? NO_ANSWER_FAILURE };
 }
 /** Ways a turn ends failed that are not the engine's fault: the person (or
  * the harness on their behalf) stopped it. Every other failed end moves the
@@ -196,7 +199,7 @@ export const ACCOUNTS_HINT = "Fix it in Settings > AI & accounts.";
  * engines passed over because they cannot work on the turn's "Works on"
  * place (`place`, "this computer"). When an account needs the person (a
  * sign-in, an expired key), the line says where to fix it. */
-export function restingLine(engines, formatTime, computer) {
+export function restingLine(engines, formatTime, computer, options = {}) {
     const seen = new Set();
     const listed = engines.filter((engine) => !seen.has(engine.label) && seen.add(engine.label));
     const parts = listed.map((engine) => (engine.keyExpired ? `${engine.label}'s API key has expired`
@@ -208,6 +211,13 @@ export function restingLine(engines, formatTime, computer) {
         .map((label) => `${label} can't control ${computer.place}`);
     if (cannot.length)
         return `No engine that can work on ${computer.place} is free, so this turn stopped: ${[...parts, ...cannot].join("; ")}.${hint}`;
+    // The two-try cap, not an empty ladder: say so, with what each engine hit.
+    if (options.capped) {
+        const count = MAX_ENGINES_PER_TURN === 2 ? "two" : String(MAX_ENGINES_PER_TURN);
+        return parts.length
+            ? `This turn stopped after ${count} engines failed: ${parts.join(", ")}.${hint}`
+            : `This turn stopped after ${count} engines failed.`;
+    }
     if (parts.length === 0)
         return "No engine is available for this turn, so it stopped.";
     if (parts.length === 1)

package/dist-server/server/engine-tiers.js

@@ -3,21 +3,11 @@
 // engine of its ladder that is ready. Everything here is pure except the
 // snapshot cache, so the server wires it to the live registry and the tests
 // drive it with plain candidates.
-import { BOT_TIERS, DEFAULT_TIER_CLASSES, MODEL_CLASSES, classBelow, isBotTier, toModelClass } from "../shared/engine-tiers.js";
+import { BOT_TIERS, DEFAULT_LADDERS, DEFAULT_TIER_CLASSES, MODEL_CLASSES, classBelow, isBotTier, toModelClass } from "../shared/engine-tiers.js";
 import { modelHost } from "../shared/engine-choices.js";
+export { DEFAULT_LADDERS };
 import { subscriptionProviderForDriver } from "../shared/subscription-bots.js";
 import { ATOMIC_ENGINE_INSTANCE, engineIntent, localModel, modelBilling, modelProvider, paidCandidate, perTokenModel } from "./harness-import/engine-policy.js";
-/** Hand-written ladders, used only when no model has a class yet (the
- * server always has the bundled baseline, so in practice the generated
- * ladders below apply). Pay-per-token engines need no rung: they form the
- * automatic last band of every ladder (resolveLadder). */
-export const DEFAULT_LADDERS = {
-    orchestrator: [{ engine: "claudeAgent" }, { engine: "atomic-engine" }, { engine: "codex" }],
-    engineering: [{ engine: "claudeAgent" }, { engine: "codex" }, { engine: "cursorAgent" }, { engine: "kimiAgent" }],
-    research: [{ engine: "grokAgent" }, { engine: "antigravityAgent" }, { engine: "kimiAgent" }],
-    writing: [{ engine: "antigravityAgent" }, { engine: "kimiAgent" }, { engine: "codex" }, { engine: "claudeAgent" }],
-    routine: [{ engine: "qwenAgent" }, { engine: "kimiAgent" }, { engine: "antigravityAgent" }],
-};
 /** Engines a tier tries first, whatever the class catalog order says: Chibi
  * runs on Claude (Erick, 2026-10-13: open-weight models broke its
  * orchestration). Its ladder starts with Claude's best model graded in its
@@ -379,7 +369,7 @@ export function resolveFailover(request) {
         const ids = candidate.models.options.map((option) => option.id);
         const multi = ids.some((id) => modelProvider(candidate, id) !== undefined);
         // (A local host's model, Ollama Cloud tags included, is not one of them:
-        // Ollama Cloud joins as its own engine, local models only by local rules.)
+        // it joins when a ladder names it, else by Ollama Cloud or local rules.)
         const models = multi ? ids.filter((id) => modelProvider(candidate, id) !== undefined && modelBilling(candidate, id) === "subscription")
             : candidate.models.default && modelBilling(candidate, candidate.models.default) === undefined ? [candidate.models.default] : [];
         for (const model of models) {
@@ -410,7 +400,8 @@ export function resolveFailover(request) {
                     return "tried";
                 if (!keys && (keyBased(candidate) || perTokenModel(candidate, model)))
                     return "key-later";
-                if (request.isLocal?.(candidate, model) && !(request.localAllowed && modelClass === "Añejo"))
+                // a ladder-named local model is a normal rung (Erick, 2026-10-24)
+                if (!named && request.isLocal?.(candidate, model) && !(request.localAllowed && modelClass === "Añejo"))
                     return "local";
                 const step = named ? ladder.indexOf(entry) : ladder.length;
                 return effective(candidate, model, named ? entry : undefined, step) === modelClass ? undefined : "class";