@chibitek/chibi 0.1.157 → 0.1.158

package/dist-server/server/connector-proxy.js

@@ -0,0 +1,249 @@
+// Harness-owned Composio MCP bridge.
+//
+// Provider CLIs only see this stdio server. Ordinary MCP traffic is relayed
+// to the configured Composio Session, but connection requests are converted
+// into first-class OpenMausBot chat cards. The agent never authors an auth
+// URL and credentials never pass through its transcript.
+//
+// stdout is the MCP transport. Never log there.
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+const UPSTREAM = process.env.OMB_CONNECTOR_UPSTREAM_URL ?? "";
+const HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
+const BOT_ID = process.env.OMB_BOT_ID ?? "";
+const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
+const TOKEN = process.env.OMB_CONNECTOR_TOKEN ?? process.env.OMB_COMMS_TOKEN ?? "";
+const MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+const INITIALIZE_RELAY_TIMEOUT_MS = 1_000;
+const RELAY_TIMEOUT_MS = 10 * 60_000;
+function parsedHeaders() {
+    try {
+        const value = JSON.parse(process.env.OMB_CONNECTOR_UPSTREAM_HEADERS ?? "{}");
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return {};
+        return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+const upstreamHeaders = parsedHeaders();
+let upstreamSessionId = "";
+const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+function textResult(id, text, isError = false) {
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) } };
+}
+function jsonRpcError(id, message) {
+    return { jsonrpc: "2.0", id, error: { code: -32000, message } };
+}
+function initializeResult(id, protocolVersion) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+            protocolVersion: typeof protocolVersion === "string" && protocolVersion ? protocolVersion : "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "openmausbot-connectors", version: "1" },
+        },
+    };
+}
+async function readBounded(response) {
+    const declared = Number(response.headers.get("content-length") ?? "0");
+    if (declared > MAX_RESPONSE_BYTES)
+        throw new Error("connector response exceeded 20 MB");
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) {
+            await reader.cancel();
+            throw new Error("connector response exceeded 20 MB");
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+function parseUpstream(text, id) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{"))
+        return JSON.parse(trimmed);
+    const frames = trimmed
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim())
+        .filter((line) => line && line !== "[DONE]")
+        .flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return frames.findLast((frame) => frame.id === id) ?? frames.at(-1) ?? null;
+}
+async function relay(message, timeoutMs = RELAY_TIMEOUT_MS) {
+    if (!UPSTREAM)
+        throw new Error("connected apps are unavailable");
+    const response = await fetch(UPSTREAM, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...upstreamHeaders,
+            ...(upstreamSessionId ? { "mcp-session-id": upstreamSessionId } : {}),
+        },
+        body: JSON.stringify(message),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const nextSession = response.headers.get("mcp-session-id");
+    if (nextSession)
+        upstreamSessionId = nextSession;
+    if (!response.ok)
+        throw new Error(`connector service returned HTTP ${response.status}`);
+    return parseUpstream(await readBounded(response), message.id);
+}
+function connectorAdds(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return [];
+    const toolkits = args.toolkits;
+    if (!Array.isArray(toolkits))
+        return [];
+    const seen = new Set();
+    const requests = [];
+    for (const item of toolkits) {
+        if (typeof item === "string") {
+            const slug = item.trim().toLowerCase();
+            const key = JSON.stringify([slug, ""]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                requests.push({ slug });
+            }
+            continue;
+        }
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const row = item;
+        const action = String(row.action ?? "add").toLowerCase();
+        if (!["add", "connect", "initiate"].includes(action))
+            continue;
+        const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
+        if (typeof slug !== "string")
+            continue;
+        const normalized = slug.trim().toLowerCase();
+        const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
+        const key = JSON.stringify([normalized, alias.toLowerCase()]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        requests.push({ slug: normalized, ...(alias ? { alias } : {}) });
+    }
+    return requests;
+}
+async function showConnectorCards(items) {
+    const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
+        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        throw new Error(String(body.error ?? `could not show connection card (HTTP ${response.status})`));
+    }
+}
+async function handle(message) {
+    const id = message.id;
+    const method = String(message.method ?? "");
+    // OpenCode (and other MCP clients) mark a stdio server failed unless
+    // initialize returns capabilities/serverInfo. Relaying that handshake to
+    // Composio can time out, return a newer protocolVersion, or throw when the
+    // upstream URL never reached the child env — all of which previously
+    // surfaced as a tools/call-shaped {content,isError} payload.
+    if (method === "notifications/initialized" || method === "initialized") {
+        if (UPSTREAM)
+            void relay(message).catch(() => { });
+        return;
+    }
+    if (method === "initialize") {
+        if (UPSTREAM) {
+            try {
+                // Capture the upstream session id when the service is healthy, but
+                // never let a stalled provider prevent the local MCP client from
+                // mounting the connector tools. The client sends initialized only
+                // after this bounded attempt and the local initialize response.
+                await relay(message, INITIALIZE_RELAY_TIMEOUT_MS);
+            }
+            catch {
+                // Best-effort session setup. The client still needs a valid result.
+            }
+        }
+        if (id !== undefined) {
+            const params = (message.params ?? {});
+            send(initializeResult(id, params.protocolVersion));
+        }
+        return;
+    }
+    if (method === "tools/call") {
+        const params = (message.params ?? {});
+        const name = String(params.name ?? "");
+        const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
+        if (requests.length) {
+            await showConnectorCards(requests);
+            const labels = requests.map((r) => (r.alias ? `${r.slug} (${r.alias})` : r.slug)).join(", ");
+            send(textResult(id, `Atomic showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`));
+            return;
+        }
+        if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {
+            send(textResult(id, "Atomic is handling connection completion and will continue the task automatically."));
+            return;
+        }
+    }
+    try {
+        const response = await relay(message);
+        if (response && id !== undefined)
+            send(response);
+    }
+    catch (error) {
+        if (id === undefined)
+            return;
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(id, messageText, true));
+        else
+            send(jsonRpcError(id, messageText));
+    }
+}
+const input = readline.createInterface({ input: process.stdin, terminal: false });
+input.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    let message;
+    try {
+        message = JSON.parse(trimmed);
+    }
+    catch {
+        return;
+    }
+    void handle(message).catch((error) => {
+        if (message.id === undefined)
+            return;
+        const method = String(message.method ?? "");
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(message.id, messageText, true));
+        else
+            send(jsonRpcError(message.id, messageText));
+    });
+});
+input.on("close", () => process.exit(0));

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/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)