@chibitek/chibi 0.1.155 → 0.1.158

package/dist-server/server/app-installers.js

@@ -1,6 +1,6 @@
 // Download and install the two desktop apps the setup wizard offers, after
 // the person clicks: Ollama (free local AI) and Podman (a separate computer
-// for bots). macOS only; elsewhere the wizard links to the vendor's page.
+// for bots). Ollama installs on macOS, Windows and Linux; Podman on macOS.
 //
 // Every download is the vendor's own GitHub release asset, found through
 // GitHub's release API, and is checked three ways before anything runs:
@@ -12,16 +12,22 @@
 // ollama.com/download redirects to the same GitHub release asset.
 //
 // Ollama is unpacked with ditto, moved to /Applications (or ~/Applications
-// when /Applications is not writable), and opened. Podman's package needs an
+// when /Applications is not writable), and opened. On Windows its signed
+// OllamaSetup.exe (Authenticode signer O=Ollama Inc., the check Ollama's own
+// install.ps1 makes) runs silently into %LOCALAPPDATA%\Programs\Ollama, no
+// administrator needed. On Linux, where Ollama ships no signature, the
+// SHA-256 alone gates the tarball, unpacked into ~/.local (no sudo, no
+// service): ~/.local/bin/ollama, started as `ollama serve`. Podman's package needs an
 // administrator's approval, so Atomic opens it in Apple's Installer app,
 // which asks for it; nobody types a command.
 import { createHash } from "node:crypto";
-import { accessSync, constants, createWriteStream, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { execFileCommand } from "./procs.js";
+import { createZstdDecompress } from "node:zlib";
+import { execFileCommand, spawnCommand } from "./procs.js";
 export const APP_INSTALLERS = Object.freeze({
     ollama: { repo: "ollama/ollama", asset: () => "Ollama-darwin.zip", teamId: "3MU9H2V9Y9", kind: "zip-app", appName: "Ollama.app" },
     podman: {
@@ -58,7 +64,7 @@ export function runTool(command, args, timeoutMs = 120_000) {
 export async function latestReleaseAsset(spec, arch, fetchImpl = fetch, signal) {
     const name = spec.asset(arch);
     if (!name)
-        throw new AppInstallError("unsupported", `No ${spec.repo} installer is published for ${arch} Macs.`);
+        throw new AppInstallError("unsupported", `No ${spec.repo} installer is published for ${arch} computers.`);
     let response;
     try {
         response = await fetchImpl(`https://api.github.com/repos/${spec.repo}/releases/latest`, {
@@ -166,10 +172,104 @@ function writableDir(dir) {
         return false;
     }
 }
+/** Ollama's release asset on Windows and Linux. */
+export const OLLAMA_WINDOWS_ASSET = "OllamaSetup.exe";
+export const ollamaLinuxAsset = (arch) => (arch === "x64" ? "ollama-linux-amd64.tar.zst" : arch === "arm64" ? "ollama-linux-arm64.tar.zst" : null);
+/** Where Atomic's Ollama lives off macOS: the per-user Windows install, or
+ * the ~/.local unpack on Linux. */
+export function ollamaBinaryHere(platform = process.platform, env = process.env) {
+    if (platform === "win32")
+        return join(env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Programs", "Ollama", "ollama.exe");
+    if (platform === "linux")
+        return join(homedir(), ".local", "bin", "ollama");
+    return null;
+}
+/** The Windows installer is signed by Ollama Inc. (Authenticode, valid). */
+export async function verifyWindowsSignature(file, run = runTool) {
+    const script = `$s = Get-AuthenticodeSignature -LiteralPath '${file.replace(/'/g, "''")}'; "$($s.Status)|$($s.SignerCertificate.Subject)"`;
+    let stdout;
+    try {
+        ({ stdout } = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script]));
+    }
+    catch (error) {
+        throw new AppInstallError("verify", `Windows could not check the installer's signature: ${String(error)}`);
+    }
+    const [status, subject = ""] = stdout.trim().split("|");
+    if (status !== "Valid" || !/(^|, )O=Ollama Inc\.(,|$)/.test(subject)) {
+        throw new AppInstallError("verify", `The installer is not signed by Ollama Inc. (${status}: ${subject}).`);
+    }
+}
+async function installOllamaWindows(deps, run) {
+    const asset = await latestReleaseAsset({ ...APP_INSTALLERS.ollama, asset: () => OLLAMA_WINDOWS_ASSET }, deps.arch ?? process.arch, deps.fetch, deps.signal);
+    const work = mkdtempSync(join(tmpdir(), "atomic-ollama-"));
+    try {
+        const setup = join(work, asset.name);
+        await downloadAsset(asset, setup, deps);
+        deps.onProgress?.({ phase: "verifying" });
+        await verifyWindowsSignature(setup, run);
+        deps.onProgress?.({ phase: "installing" });
+        // Per-user install; the installer opens the Ollama app when it is done.
+        await run(setup, ["/VERYSILENT", "/NORESTART", "/SUPPRESSMSGBOXES"]).catch((error) => {
+            throw new AppInstallError("install", `The Ollama installer stopped: ${String(error)}`);
+        });
+        deps.onProgress?.({ phase: "starting" });
+        return { appPath: ollamaBinaryHere("win32"), version: asset.version };
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+async function installOllamaLinux(deps, run) {
+    const asset = await latestReleaseAsset({ ...APP_INSTALLERS.ollama, asset: ollamaLinuxAsset }, deps.arch ?? process.arch, deps.fetch, deps.signal);
+    const work = mkdtempSync(join(tmpdir(), "atomic-ollama-"));
+    try {
+        const packed = join(work, asset.name);
+        await downloadAsset(asset, packed, deps);
+        deps.onProgress?.({ phase: "installing" });
+        const tar = join(work, "ollama.tar");
+        await pipeline(createReadStream(packed), createZstdDecompress(), createWriteStream(tar), { signal: deps.signal });
+        rmSync(packed, { force: true });
+        const prefix = join(homedir(), ".local");
+        mkdirSync(prefix, { recursive: true });
+        await run("tar", ["-xf", tar, "-C", prefix]).catch((error) => {
+            throw new AppInstallError("install", `Could not unpack Ollama into ${prefix}: ${String(error)}`);
+        });
+        deps.onProgress?.({ phase: "starting" });
+        startOllamaApp("linux");
+        return { appPath: ollamaBinaryHere("linux"), version: asset.version };
+    }
+    catch (error) {
+        if (error instanceof AppInstallError)
+            throw error;
+        throw new AppInstallError(deps.signal?.aborted ? "cancelled" : "install", error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+/** Start the installed Ollama the way each OS runs it: the app on macOS and
+ * Windows (it starts its own server), `ollama serve` on Linux. Returns at
+ * once; callers wait for it to answer. */
+export function startOllamaApp(platform = process.platform, run = runTool) {
+    if (platform === "darwin") {
+        void run("/usr/bin/open", ["-a", "Ollama"]).catch(() => undefined);
+        return;
+    }
+    const binary = ollamaBinaryHere(platform);
+    const command = platform === "win32" && binary ? join(binary, "..", "ollama app.exe") : existsSync(binary ?? "") ? binary : "ollama";
+    const child = spawnCommand(command, platform === "win32" ? [] : ["serve"], { detached: true, stdio: "ignore", windowsHide: true });
+    child.on("error", () => undefined);
+    child.unref();
+}
 /** Download, verify, install and open Ollama. Resolves with where it went. */
 export async function installOllamaApp(deps = {}) {
-    if ((deps.platform ?? process.platform) !== "darwin")
-        throw new AppInstallError("unsupported", "Atomic installs Ollama for you on macOS only.");
+    const platform = deps.platform ?? process.platform;
+    if (platform === "win32" || platform === "linux") {
+        deps.onProgress?.({ phase: "finding" });
+        return (platform === "win32" ? installOllamaWindows : installOllamaLinux)(deps, deps.run ?? ((command, args) => runTool(command, args, 15 * 60_000)));
+    }
+    if (platform !== "darwin")
+        throw new AppInstallError("unsupported", `Atomic cannot install Ollama on ${platform}.`);
     const spec = APP_INSTALLERS.ollama;
     const run = deps.run ?? runTool;
     deps.onProgress?.({ phase: "finding" });

package/dist-server/server/avatar-subscription.js

@@ -0,0 +1,51 @@
+import { decodeGeneratedImage } from "./generated-image.js";
+import { avatarGenerationPrompt, AVATAR_IMAGE_TIMEOUT_MS } from "./avatar-image.js";
+/** Capability and current billing are both required. An authenticated text
+ * engine is not evidence that its subscription can generate images. */
+export async function avatarSubscription(instances) {
+    for (const instance of instances) {
+        if (!instance.enabled || !instance.generateImage)
+            continue;
+        try {
+            const status = await instance.snapshot();
+            if (status.state === "available" && status.authenticated === true &&
+                status.billing === "subscription" && status.account?.method !== "api-key")
+                return instance;
+        }
+        catch {
+            // A broken account must not conceal another eligible signed-in account.
+        }
+    }
+    return null;
+}
+/** Never turn a subscription failure into an unexpected API charge. */
+export async function generateSubscriptionAvatar(instance, bot, direction, timeoutMs = AVATAR_IMAGE_TIMEOUT_MS) {
+    if (!instance.generateImage || await avatarSubscription([instance]) !== instance) {
+        throw Object.assign(new Error("This image subscription is no longer available. Check its sign-in in Settings."), { status: 409 });
+    }
+    const controller = new AbortController();
+    let timer;
+    try {
+        const encoded = await Promise.race([
+            instance.generateImage(avatarGenerationPrompt(bot, direction), { signal: controller.signal }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error("timeout"));
+                }, timeoutMs);
+            }),
+        ]);
+        const image = decodeGeneratedImage(encoded);
+        if (image.mime === "image/gif")
+            throw new Error("unsupported avatar format");
+        return { bytes: image.bytes, mime: image.mime };
+    }
+    catch {
+        throw Object.assign(new Error(controller.signal.aborted
+            ? "Subscription avatar generation timed out. Try again."
+            : "Your subscription could not generate this avatar. Check its sign-in and usage allowance, then try again."), { status: 502 });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist-server/server/cli-help.js

@@ -0,0 +1,74 @@
+export const USAGE = `chibi — your team of AI bots, ready in a few steps
+
+  chibi                               set up once, then open your workspace
+  chibi setup [--data-dir DIR]
+  chibi start [the same options as serve]
+  chibi serve [--port 8799] [--data-dir DIR] [--label NAME]
+                    [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
+  chibi pair  [--label NAME] [--client] [--phone ios|android]
+                    [--public-url https://host]
+  chibi sessions [revoke ID]
+  chibi status
+  chibi login [--email you@example.com]
+  chibi logout
+  chibi command --bot ID|--group ID --thread ID --text "/goal status" [--port 8799]
+  chibi goal --bot ID --thread ID --text "--tokens 100000 objective"
+  chibi access list | add EMAIL [--chat-only] | remove EMAIL
+  chibi service install [--domain HOST | --tunnel | --tailscale] [--port N] [--data-dir DIR] | uninstall
+  chibi browser install [--with-deps] | status
+  chibi fleet init --domain HOST [--operator USER] | create NAME --admin EMAIL [--member EMAIL] [--brand FILE]
+                    [--anthropic-key-file FILE] [--cap USD] [--license-key KEY] [--memory 1G]
+                  | list | users NAME add|remove EMAIL [--chat-only] | suspend NAME | resume NAME
+                  | delete NAME --yes [--keep-data] | upgrade   (all take --dry-run)
+                  | agent [--socket PATH] [--group USER]   (root; installed by init --operator)
+
+setup   choose AI access and optional phone access; keep existing bots and chats
+start   same as chibi: use your saved settings and open the workspace
+serve   starts the server without prompts and prints a pairing link + QR code
+pair    mints a pairing code against a running server (--client: chat only)
+sessions lists paired devices; "sessions revoke ID" signs one out
+status  what the server says about itself
+login   signs this machine in to an Atomic account (an emailed code)
+        and reserves its public address for --tunnel
+logout  releases that address and signs out
+access  who may sign in with an emailed code at /pair: an address or
+        @domain; --chat-only gives chat and approvals without settings.
+        Takes effect at once, no restart.
+service keep the server running across reboots: writes a systemd unit
+        (Linux) or a launchd agent (macOS) for the same serve options and
+        prints the commands that install it. Install the package
+        permanently first (npm install -g @chibitek/chibi).
+browser install: the bots' browser engine (agent-browser, pinned) into the
+        data dir, and Chrome for Testing into the user's browser cache.
+        --with-deps also installs
+        the Linux libraries Chrome needs (run as root once). Then run
+        browser install as the user running serve, from that user's home.
+        status: what the current user and data directory have.
+fleet   many client workspaces on one Linux server, each its own account,
+        service, data folder, brand, sign-in list and keys at NAME.HOST
+        behind the system Caddy. Plans are printed unless run as root;
+        --dry-run always prints. Install the package permanently first.
+        init --operator USER also installs the fleet agent, a root service
+        on a Unix socket only USER may open, so the workspace running as
+        USER manages the others from Settings → Workspaces.
+
+--tailscale  serve over your tailnet: Tailscale terminates HTTPS and the
+             link uses this machine's MagicDNS name (needs Tailscale signed in
+             and HTTPS certificates enabled for the tailnet)
+--tunnel     serve at a public HTTPS address through a Cloudflare tunnel
+             from a hosted control plane (set OMB_CONTROL_PLANE_URL; Atomic
+             ships none). Run \`chibi login\` once on this machine first.
+--domain     serve at https://HOST on your own domain: a pinned Caddy is
+             downloaded once and run alongside the server, and gets the
+             certificate itself. Point the domain's DNS at this machine and
+             open ports 80 and 443.
+
+--no-open   do not open a browser window
+--no-pair   skip phone setup and do not print a pairing code
+--local     start locally this time, ignoring saved remote-access settings
+--quiet     skip the welcome banner (it never shows when output is piped;
+            NO_COLOR=1 shows it without color)
+
+Install once with \`npm install -g @chibitek/chibi\`, then type \`chibi\`.
+Or run without a global install: \`npx @chibitek/chibi\`. Node 24+ is required.
+`;

package/dist-server/server/cli.js

@@ -1,3 +1,5 @@
+import { USAGE } from "./cli-help.js";
+export { USAGE } from "./cli-help.js";
 // `chibi` on the command line: run the server anywhere and pair devices
 // to it. One implementation for three homes — `npx @chibitek/chibi` (the npm
 // package), `node dist-server/cli.js` (the container image) and
@@ -38,6 +40,7 @@ import { resolveLoopbackTrust } from "./request-auth.js";
 import { writeFileAtomic } from "./atomic.js";
 import { ensureCaddy, normalizeDomainOption, startCaddy } from "./caddy.js";
 import { runServiceCommand } from "./service-cli.js";
+import { reportBusyPort } from "./port-in-use.js";
 import { colorDepth, renderBanner, shouldShowBanner, terminalBackground } from "./cli-banner.js";
 import { runFleetCommand } from "./fleet-cli.js";
 import { startFleetAgent } from "./fleet-agent.js";
@@ -47,7 +50,7 @@ import { defaultSetupIo, SetupCancelled } from "./cli-prompts.js";
 import { normalizePhoneOrigin, phonePairingInstructions, runPhoneSetup } from "./cli-phone-setup.js";
 import { cleanupTunnelOrigin, createTunnelAccount, createTunnelOrigin, describeTunnelAccount, describeTunnelState, ensureCloudflared, FLEET_CREDENTIAL_ENV, fleetAccess, fleetCredential, guardianEntry, startTunnel, tunnelAccess, } from "./tunnel.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
-export const COMMANDS = ["setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "service", "browser", "fleet", "help", "--help", "-h"];
+export const COMMANDS = ["command", "goal", "setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "service", "browser", "fleet", "help", "--help", "-h"];
 export function parseArgs(argv, env = process.env) {
     const implicitStart = !argv.length || (argv[0].startsWith("--") && argv[0] !== "--help");
     const [command = "start", ...rest] = implicitStart ? ["start", ...argv] : argv;
@@ -76,7 +79,15 @@ export function parseArgs(argv, env = process.env) {
             return v;
         };
         try {
-            if (arg === "--port")
+            if ((options.command === "command" || options.command === "goal") && arg === "--bot")
+                options.botId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--group")
+                options.groupId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--thread")
+                options.threadId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--text")
+                options.commandText = value();
+            else if (arg === "--port")
                 options.port = Number(value());
             else if (arg === "--data-dir")
                 options.dataDir = resolve(value());
@@ -182,6 +193,8 @@ export function parseArgs(argv, env = process.env) {
         return { error: "--public-url must start with http:// or https://" };
     if (options.tailscale && options.tunnel)
         return { error: "choose one of --tailscale (your tailnet) and --tunnel (a public address)" };
+    if ((options.command === "command" || options.command === "goal") && (Boolean(options.botId) === Boolean(options.groupId) || !options.threadId || !options.commandText))
+        return { error: "command and goal require exactly one of --bot ID or --group ID, plus --thread ID --text TEXT" };
     if (options.command === "access" && !options.accessAction)
         return { error: "access needs one of: list, add EMAIL [--chat-only], remove EMAIL" };
     if (options.command === "service" && !options.serviceAction)
@@ -204,78 +217,6 @@ export function parseArgs(argv, env = process.env) {
     }
     return options;
 }
-export const USAGE = `chibi — your team of AI bots, ready in a few steps
-
-  chibi                               set up once, then open your workspace
-  chibi setup [--data-dir DIR]
-  chibi start [the same options as serve]
-  chibi serve [--port 8799] [--data-dir DIR] [--label NAME]
-                    [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
-  chibi pair  [--label NAME] [--client] [--phone ios|android]
-                    [--public-url https://host]
-  chibi sessions [revoke ID]
-  chibi status
-  chibi login [--email you@example.com]
-  chibi logout
-  chibi access list | add EMAIL [--chat-only] | remove EMAIL
-  chibi service install [--domain HOST | --tunnel | --tailscale] [--port N] [--data-dir DIR] | uninstall
-  chibi browser install [--with-deps] | status
-  chibi fleet init --domain HOST [--operator USER] | create NAME --admin EMAIL [--member EMAIL] [--brand FILE]
-                    [--anthropic-key-file FILE] [--cap USD] [--license-key KEY] [--memory 1G]
-                  | list | users NAME add|remove EMAIL [--chat-only] | suspend NAME | resume NAME
-                  | delete NAME --yes [--keep-data] | upgrade   (all take --dry-run)
-                  | agent [--socket PATH] [--group USER]   (root; installed by init --operator)
-
-setup   choose AI access and optional phone access; keep existing bots and chats
-start   same as chibi: use your saved settings and open the workspace
-serve   starts the server without prompts and prints a pairing link + QR code
-pair    mints a pairing code against a running server (--client: chat only)
-sessions lists paired devices; "sessions revoke ID" signs one out
-status  what the server says about itself
-login   signs this machine in to an Atomic account (an emailed code)
-        and reserves its public address for --tunnel
-logout  releases that address and signs out
-access  who may sign in with an emailed code at /pair: an address or
-        @domain; --chat-only gives chat and approvals without settings.
-        Takes effect at once, no restart.
-service keep the server running across reboots: writes a systemd unit
-        (Linux) or a launchd agent (macOS) for the same serve options and
-        prints the commands that install it. Install the package
-        permanently first (npm install -g @chibitek/chibi).
-browser install: the bots' browser engine (agent-browser, pinned) into the
-        data dir, and Chrome for Testing into the user's browser cache.
-        --with-deps also installs
-        the Linux libraries Chrome needs (run as root once). Then run
-        browser install as the user running serve, from that user's home.
-        status: what the current user and data directory have.
-fleet   many client workspaces on one Linux server, each its own account,
-        service, data folder, brand, sign-in list and keys at NAME.HOST
-        behind the system Caddy. Plans are printed unless run as root;
-        --dry-run always prints. Install the package permanently first.
-        init --operator USER also installs the fleet agent, a root service
-        on a Unix socket only USER may open, so the workspace running as
-        USER manages the others from Settings → Workspaces.
-
---tailscale  serve over your tailnet: Tailscale terminates HTTPS and the
-             link uses this machine's MagicDNS name (needs Tailscale signed in
-             and HTTPS certificates enabled for the tailnet)
---tunnel     serve at a public HTTPS address through a Cloudflare tunnel
-             from a hosted control plane (set OMB_CONTROL_PLANE_URL; Atomic
-             ships none). Run \`chibi login\` once on this machine first.
---domain     serve at https://HOST on your own domain: a pinned Caddy is
-             downloaded once and run alongside the server, and gets the
-             certificate itself. Point the domain's DNS at this machine and
-             open ports 80 and 443.
-
---no-open   do not open a browser window
---no-pair   skip phone setup and do not print a pairing code
---local     start locally this time, ignoring saved remote-access settings
---quiet     skip the welcome banner (it never shows when output is piped;
-            NO_COLOR=1 shows it without color)
-
-Install once with \`npm install -g @chibitek/chibi\`, then type \`chibi\`.
-Or run without a global install: \`npx @chibitek/chibi\`. Node 24+ is required.
-`;
 export function defaultIo() {
     return {
         log: (line) => console.log(line),
@@ -890,6 +831,8 @@ export async function runServe(options, log = console.log) {
         console.error(`something already answers on http://127.0.0.1:${options.port}; use \`chibi pair\` against it, or --port for a second server`);
         return 1;
     }
+    if (await reportBusyPort(options.port, options.dataDir === join(homedir(), ".atomic-app") ? "" : ` --data-dir ${options.dataDir}`))
+        return 1;
     let publicUrl = options.publicUrl;
     let tailscale = null;
     if (options.tailscale) {
@@ -1191,10 +1134,8 @@ export async function runOnboardingCommand(options, io = defaultIo(), startServe
             saveCliStartup(options.dataDir, startupPreferences(launch));
         }
         if (options.command === "setup") {
-            io.log("\nAll set. Start with: chibi (or npx @chibitek/chibi without a global install).");
-            if (options.dataDir !== join(homedir(), ".atomic-app") || options.port !== 8799) {
-                io.log(`Use the same --data-dir (${options.dataDir}) and --port (${options.port}) options when starting.`);
-            }
+            const flags = [options.dataDir !== join(homedir(), ".atomic-app") && ` --data-dir ${options.dataDir}`, options.port !== 8799 && ` --port ${options.port}`].filter(Boolean).join("");
+            io.log(`\nAll set. Start with: chibi${flags ? ` start${flags}` : ""} (or npx @chibitek/chibi without a global install).`);
             return 0;
         }
         if (saved)
@@ -1232,6 +1173,24 @@ export async function main(argv = process.argv.slice(2)) {
         console.log(`\n${welcomeBanner(options)}\n`);
     }
     switch (options.command) {
+        case "command":
+        case "goal": {
+            const text = options.command === "goal" ? `/goal ${options.commandText}` : options.commandText;
+            const roomGoal = options.groupId ? /^\/goal(?:\s+([\s\S]*))?$/.exec(text ?? "") : null;
+            if (roomGoal && (!roomGoal[1]?.trim() || (roomGoal[1].startsWith("--") || /^(status|pause|resume|stop|help)(?:\s|$)/.test(roomGoal[1])))) {
+                console.error("Room goals accept an objective. Personal goal controls and budgets require --bot.");
+                return 2;
+            }
+            const result = await api(options.port, `/api/${options.groupId ? "groups" : "bots"}/${encodeURIComponent(options.groupId ?? options.botId)}/messages`, {
+                method: "POST", body: JSON.stringify({ threadId: options.threadId, text: roomGoal ? roomGoal[1] : text, ...(roomGoal ? { mode: "goal" } : {}), sendId: randomBytes(16).toString("hex") }),
+            });
+            if (result.status >= 400) {
+                console.error(result.body.error ?? `Server returned ${result.status}`);
+                return 1;
+            }
+            console.log(options.json ? JSON.stringify(result.body) : result.body.goalSummary ?? JSON.stringify(result.body));
+            return 0;
+        }
         case "setup":
         case "start":
             return runOnboardingCommand(options);

package/dist-server/server/colima-docker.js

@@ -0,0 +1,136 @@
+// Colima is the only container engine Atomic starts or talks to for the
+// Local VM on macOS. Docker Desktop is never launched, and a docker context
+// it leaves behind (desktop-linux) must not decide where `docker` commands
+// go, so every docker invocation Atomic makes on a Mac is pinned to the
+// Colima profile's socket through DOCKER_HOST.
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const COLIMA_DEFAULT_PROFILE = "default";
+const readText = (path) => {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+};
+function homeOf(env) {
+    return env.HOME?.trim() || homedir();
+}
+/** The Colima profile Atomic uses: the one named by a `colima-<profile>`
+ * docker context (DOCKER_CONTEXT, then ~/.docker/config.json), else the
+ * default profile. Any other context, Docker Desktop's included, is ignored:
+ * it never redirects Atomic away from Colima. Reads a file only; never runs
+ * docker, since docker itself is what this pins. */
+export function colimaProfile(env = process.env, read = readText) {
+    let context = env.DOCKER_CONTEXT?.trim() ?? "";
+    if (!context) {
+        const configDir = env.DOCKER_CONFIG?.trim() || join(homeOf(env), ".docker");
+        try {
+            const parsed = JSON.parse(read(join(configDir, "config.json")) ?? "{}");
+            context = typeof parsed.currentContext === "string" ? parsed.currentContext.trim() : "";
+        }
+        catch {
+            context = "";
+        }
+    }
+    if (context.startsWith("colima-") && /^[A-Za-z0-9_.-]+$/.test(context.slice("colima-".length))) {
+        return context.slice("colima-".length);
+    }
+    return COLIMA_DEFAULT_PROFILE;
+}
+/** Colima's docker socket for a profile. COLIMA_HOME wins; otherwise
+ * ~/.colima, or ~/.config/colima when only that one holds the profile. */
+export function colimaDockerSocket(profile = COLIMA_DEFAULT_PROFILE, env = process.env, exists = existsSync) {
+    const explicit = env.COLIMA_HOME?.trim();
+    if (explicit)
+        return join(explicit, profile, "docker.sock");
+    const home = homeOf(env);
+    const legacy = join(home, ".colima");
+    const xdg = join(env.XDG_CONFIG_HOME?.trim() || join(home, ".config"), "colima");
+    const base = !exists(join(legacy, profile)) && exists(join(xdg, profile)) ? xdg : legacy;
+    return join(base, profile, "docker.sock");
+}
+export function colimaDockerHost(profile = COLIMA_DEFAULT_PROFILE, env = process.env, exists) {
+    return `unix://${colimaDockerSocket(profile, env, exists)}`;
+}
+/** The environment for one `docker` invocation. On macOS it always targets
+ * Colima: DOCKER_HOST is the Colima socket and DOCKER_CONTEXT is dropped (the
+ * CLI refuses both at once). Elsewhere the environment is returned as is. */
+export function dockerEnvForColima(env = process.env, platform = process.platform, options = {}) {
+    if (platform !== "darwin")
+        return env;
+    const profile = colimaProfile(env, options.read);
+    const pinned = { ...env, DOCKER_HOST: colimaDockerHost(profile, env, options.exists) };
+    delete pinned.DOCKER_CONTEXT;
+    return pinned;
+}
+const COLIMA_START_TIMEOUT_MS = 4 * 60_000;
+const COLIMA_STOP_TIMEOUT_MS = 60_000;
+/** Colima on the profile the docker CLI is pinned to. `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. */
+export function colimaStartPlan(env = process.env) {
+    const profile = colimaProfile(env);
+    const profileArgs = profile === COLIMA_DEFAULT_PROFILE ? [] : ["--profile", profile];
+    return {
+        label: "Colima",
+        profile,
+        start: { command: "colima", args: ["start", ...profileArgs], timeoutMs: COLIMA_START_TIMEOUT_MS },
+        stop: { command: "colima", args: ["stop", ...profileArgs], timeoutMs: COLIMA_STOP_TIMEOUT_MS },
+    };
+}
+/** Bring docker back on Colima: start and wait for `docker info`; if it
+ * does not answer, start again (retry); then restart the profile (`colima
+ * stop`, `colima start`); then give up with a clear error. Without a plan
+ * (Colima not installed) it says so on a Mac. Docker Desktop is never
+ * opened on any path. */
+export async function startColima(plan, before, deps) {
+    if (!plan) {
+        return {
+            status: before,
+            started: null,
+            error: deps.platform === "darwin"
+                ? "Docker is not answering and Colima is not installed. Atomic runs the Local VM on Colima only and never opens Docker Desktop: install Colima (brew install colima), then try again."
+                : null,
+        };
+    }
+    const sleep = deps.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+    const quietly = async (step) => {
+        // 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.
+        await deps.runner(step.command, step.args, step.timeoutMs).catch(() => undefined);
+    };
+    const waitUntilUp = async (ms) => {
+        const deadline = Date.now() + ms;
+        let status = await deps.status();
+        while (!status.daemonUp && Date.now() < deadline) {
+            await sleep(deps.pollMs ?? 2000);
+            status = await deps.status();
+        }
+        return status;
+    };
+    await quietly(plan.start);
+    let status = await waitUntilUp(deps.waitMs ?? 120_000);
+    if (!status.daemonUp) {
+        // A VM still booting often answers late.
+        await quietly(plan.start);
+        status = await waitUntilUp(deps.retryWaitMs ?? 30_000);
+    }
+    if (!status.daemonUp) {
+        // A profile that reads as running but whose socket is dead only comes
+        // back after a stop.
+        await quietly(plan.stop);
+        await quietly(plan.start);
+        status = await waitUntilUp(deps.waitMs ?? 120_000);
+    }
+    const profileFlag = plan.profile === COLIMA_DEFAULT_PROFILE ? "" : ` --profile ${plan.profile}`;
+    return {
+        status,
+        started: plan.label,
+        error: status.daemonUp
+            ? null
+            : `Colima (profile ${plan.profile}) did not answer after a start, a retry and a restart. Run \`colima status${profileFlag}\` to see why; Atomic does not fall back to Docker Desktop.`,
+    };
+}