@chibitek/chibi 0.1.157 → 0.1.160

package/dist-server/server/attachment-mimes.js

@@ -0,0 +1,58 @@
+/** Accepted upload mimes and the extensions stored on disk for them. */
+/** Mimes the endpoint accepts, mapped to the extension stored on disk.
+ * Sniffing is not attempted — a lie here only changes the filename. */
+export const IMAGE_MIMES = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+};
+/** Useful document and audio formats accepted by the upload endpoint.
+ * Generic archives, binaries, HTML, SVG, and executable/script mimes stay
+ * out. Office/OpenDocument packages are allowed because they are documents,
+ * despite using ZIP internally. The claimed mime determines the extension;
+ * an attacker-controlled filename never does. */
+export const FILE_MIMES = {
+    "audio/opus": ".opus",
+    "audio/ogg": ".ogg",
+    "audio/mpeg": ".mp3",
+    "audio/mp4": ".m4a",
+    "audio/x-m4a": ".m4a",
+    "audio/aac": ".aac",
+    "audio/wav": ".wav",
+    "audio/x-wav": ".wav",
+    "audio/wave": ".wav",
+    "audio/flac": ".flac",
+    "audio/x-flac": ".flac",
+    "audio/webm": ".webm",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "text/csv": ".csv",
+    "text/tab-separated-values": ".tsv",
+    "application/json": ".json",
+    "application/pdf": ".pdf",
+    "application/rtf": ".rtf",
+    "text/rtf": ".rtf",
+    "application/msword": ".doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.ms-powerpoint": ".ppt",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/vnd.oasis.opendocument.text": ".odt",
+    "application/vnd.oasis.opendocument.spreadsheet": ".ods",
+    "application/vnd.oasis.opendocument.presentation": ".odp",
+};
+export function extensionForMime(mime) {
+    if (!mime)
+        return null;
+    return IMAGE_MIMES[mime.split(";")[0].trim().toLowerCase()] ?? null;
+}
+export function normalizedMime(mime) {
+    const value = mime?.split(";")[0]?.trim().toLowerCase();
+    return value || null;
+}
+export function extensionForFileMime(mime) {
+    const value = normalizedMime(mime);
+    return value ? FILE_MIMES[value] ?? null : null;
+}

package/dist-server/server/attachments.js

@@ -2,10 +2,12 @@
 // ~/.openmausbot/attachments so every CLI engine can open them by path —
 // the app never ships image bytes through the prompt itself.
 import { createHash, randomUUID } from "node:crypto";
-import { createReadStream, linkSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createReadStream, linkSync, mkdirSync, readFileSync, readdirSync, statSync, statfsSync, unlinkSync, writeFileSync, } from "node:fs";
 import { link, open, unlink } from "node:fs/promises";
 import { join, extname } from "node:path";
 import { DATA_DIR } from "./config.js";
+import { FILE_MIMES, IMAGE_MIMES, extensionForFileMime, extensionForMime, normalizedMime } from "./attachment-mimes.js";
+export { extensionForFileMime, extensionForMime };
 export const ATTACHMENTS_DIR = join(DATA_DIR, "attachments");
 /** The spec's ceiling: a screenshot bigger than this is rejected before it
  * is ever buffered, matching the composer's existing size discipline. */
@@ -14,9 +16,14 @@ export const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
  * ceiling. This is a local inbox, not unbounded remote storage. */
 export const FILE_MAX_BYTES = 25 * 1024 * 1024;
 /** Attachments are durable because prompts refer to their paths. Never
- * silently evict them: once this ceiling is reached, a new upload gets an
- * explicit 507 and the person can decide what to remove. */
-export const ATTACHMENTS_MAX_BYTES = 512 * 1024 * 1024;
+ * silently evict them. There is no fixed quota by default: the store grows
+ * until the disk itself runs low (see ATTACHMENTS_DISK_RESERVE_BYTES), then a
+ * new upload gets an explicit 507 and the person can decide what to remove.
+ * OMB_ATTACHMENTS_MAX_BYTES sets an optional hard ceiling (tests use it). */
+export const ATTACHMENTS_MAX_BYTES = Number(process.env.OMB_ATTACHMENTS_MAX_BYTES) || Number.POSITIVE_INFINITY;
+/** Free space always left on the attachments volume, so uploads can never
+ * fill the disk the app, its database and the OS depend on. */
+export const ATTACHMENTS_DISK_RESERVE_BYTES = 2 * 1024 * 1024 * 1024;
 /** Interrupted streamed uploads use private partial files. A crash can leave
  * one behind, so future uploads remove only our stale partials — never a
  * committed attachment that a transcript may still reference. */
@@ -47,55 +54,6 @@ function invalidateAttachmentAccounting() {
     committedAttachmentBytes = null;
     attachmentAccountingVersion += 1;
 }
-/** Mimes the endpoint accepts, mapped to the extension stored on disk.
- * Sniffing is not attempted — a lie here only changes the filename. */
-const IMAGE_MIMES = {
-    "image/png": ".png",
-    "image/jpeg": ".jpg",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
-};
-/** Useful document and audio formats accepted by the upload endpoint.
- * Generic archives, binaries, HTML, SVG, and executable/script mimes stay
- * out. Office/OpenDocument packages are allowed because they are documents,
- * despite using ZIP internally. The claimed mime determines the extension;
- * an attacker-controlled filename never does. */
-const FILE_MIMES = {
-    "audio/opus": ".opus",
-    "audio/ogg": ".ogg",
-    "audio/mpeg": ".mp3",
-    "audio/mp4": ".m4a",
-    "audio/x-m4a": ".m4a",
-    "audio/aac": ".aac",
-    "audio/wav": ".wav",
-    "audio/x-wav": ".wav",
-    "audio/wave": ".wav",
-    "audio/flac": ".flac",
-    "audio/x-flac": ".flac",
-    "audio/webm": ".webm",
-    "text/plain": ".txt",
-    "text/markdown": ".md",
-    "text/csv": ".csv",
-    "text/tab-separated-values": ".tsv",
-    "application/json": ".json",
-    "application/pdf": ".pdf",
-    "application/rtf": ".rtf",
-    "text/rtf": ".rtf",
-    "application/msword": ".doc",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
-    "application/vnd.ms-excel": ".xls",
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
-    "application/vnd.ms-powerpoint": ".ppt",
-    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
-    "application/vnd.oasis.opendocument.text": ".odt",
-    "application/vnd.oasis.opendocument.spreadsheet": ".ods",
-    "application/vnd.oasis.opendocument.presentation": ".odp",
-};
-export function extensionForMime(mime) {
-    if (!mime)
-        return null;
-    return IMAGE_MIMES[mime.split(";")[0].trim().toLowerCase()] ?? null;
-}
 export function ensureAttachmentsDir() {
     mkdirSync(ATTACHMENTS_DIR, { recursive: true, mode: 0o700 });
 }
@@ -160,11 +118,23 @@ function addCommittedBytes(delta, version = attachmentAccountingVersion) {
     }
     committedAttachmentBytes += delta;
 }
-/** Bytes that count against ATTACHMENTS_MAX_BYTES right now, for callers
- * that plan a batch (the Grok Bot history import) before saving any of it. */
-export function attachmentBytesUsed() {
+/** Bytes that count against ATTACHMENTS_MAX_BYTES right now. */
+function attachmentBytesUsed() {
     return committedBytes() + reservedAttachmentBytes;
 }
+/** Bytes the disk can still take before dropping to the reserve. Committed
+ * files are already off the free count; reservations are not written yet. */
+function diskHeadroomBytes() {
+    ensureAttachmentsDir();
+    const { bavail, bsize } = statfsSync(ATTACHMENTS_DIR);
+    return Number(bavail) * Number(bsize) - ATTACHMENTS_DISK_RESERVE_BYTES - reservedAttachmentBytes;
+}
+/** How many more bytes uploads may add right now: the smaller of the
+ * optional ceiling and the disk headroom. Callers that plan a batch (the
+ * Grok Bot history import) read this before saving any of it. */
+export function attachmentBytesAvailable() {
+    return Math.max(0, Math.min(ATTACHMENTS_MAX_BYTES - attachmentBytesUsed(), diskHeadroomBytes()));
+}
 /** Remove only abandoned temporary uploads, and refresh the cached usage
  * total from the same fresh scan. Outside accounting recovery, this is the
  * only full directory walk after start-up; nothing on the upload path calls it
@@ -239,10 +209,9 @@ class AttachmentReservation {
         this.reserveAtLeast(bytes, bytes);
     }
     reserveAtLeast(required, preferred) {
-        const used = committedBytes();
-        const available = ATTACHMENTS_MAX_BYTES - used - reservedAttachmentBytes;
+        const available = attachmentBytesAvailable();
         if (available < required) {
-            throw statusError(507, `attachments storage is full (limit ${ATTACHMENTS_MAX_BYTES} bytes)`);
+            throw statusError(507, "attachments storage is full (the disk is nearly out of free space)");
         }
         // Unknown-length HTTP bodies reserve in bounded chunks. Taking whatever
         // remains below the preferred increment avoids falsely rejecting a small
@@ -328,14 +297,6 @@ async function digestFile(path) {
 function statusError(status, message) {
     return Object.assign(new Error(message), { status });
 }
-function normalizedMime(mime) {
-    const value = mime?.split(";")[0]?.trim().toLowerCase();
-    return value || null;
-}
-export function extensionForFileMime(mime) {
-    const value = normalizedMime(mime);
-    return value ? FILE_MIMES[value] ?? null : null;
-}
 /** Strip platform-reserved characters and replace any sender-provided
  * extension with the canonical one for the accepted mime. Separators and
  * encoded separators are rejected rather than massaged so traversal attempts

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

@@ -6,6 +6,7 @@ export const AVATAR_IMAGE_TIMEOUT_MS = 120_000;
 const MAX_UPSTREAM_RESPONSE_BYTES = 15 * 1024 * 1024;
 export const avatarGenerationRequestSchema = z.object({
     prompt: z.string().trim().max(AVATAR_DIRECTION_MAX_CHARS).default(""),
+    source: z.enum(["auto", "subscription", "api"]).default("auto"),
 });
 const generatedImageResponseSchema = z.object({
     data: z.array(z.object({ b64_json: z.string().min(1).optional(), url: z.string().optional() })).min(1),

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

@@ -0,0 +1,74 @@
+import { decodeGeneratedImage } from "./generated-image.js";
+import { avatarGenerationPrompt, generateAvatarImage, AVATAR_IMAGE_TIMEOUT_MS } from "./avatar-image.js";
+import { PASS, ROUTES } from "./routes/table.js";
+export async function generateRoutedAvatar(cfg, instances, bot, direction, source = "auto") {
+    if (source !== "api") {
+        const subscription = await avatarSubscription(instances);
+        if (subscription)
+            return generateSubscriptionAvatar(subscription, bot, direction);
+        if (source === "subscription" || instances.some(instance => instance.enabled && instance.generateImage)) {
+            throw Object.assign(new Error("Sign in to an image-capable subscription in Settings, or explicitly choose an image API connection."), { status: 409 });
+        }
+    }
+    return generateAvatarImage(cfg, bot, direction);
+}
+export function installAvatarSubscriptionRoute(instances) {
+    ROUTES.push(async (context) => {
+        if (context.path !== "/api/avatar-subscription" || context.method !== "GET")
+            return PASS;
+        const available = instances();
+        const subscription = await avatarSubscription(available);
+        context.res.setHeader("Cache-Control", "no-store");
+        context.json(context.res, 200, { offered: available.some(instance => instance.enabled && instance.generateImage),
+            available: Boolean(subscription), label: subscription?.displayName ?? "Signed-in subscription" });
+    });
+}
+/** 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.`,
+    };
+}