@chibitek/chibi 0.1.157 → 0.1.158

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.js

@@ -40,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";
@@ -830,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) {
@@ -1131,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)

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.`,
+    };
+}