limixbot 0.3.4 → 0.3.12

package/dist-server/package.json

@@ -1 +1 @@
-{"type":"module","version":"0.3.4"}
+{"type":"module","version":"0.3.12"}

package/dist-server/server/boat-create-idempotency.js

@@ -12,7 +12,7 @@ const LOCK_RETRY_MS = 20;
 const MAX_REAPER_GENERATIONS = 128;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const BOT_ID = /^[A-Za-z0-9_-]{1,120}$/;
-const BOAT_ID = /^bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}$/;
+const BOAT_ID = /^(?:bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}|m_[a-z0-9]{20,40})$/;
 const lockWait = new Int32Array(new SharedArrayBuffer(4));
 function isRequest(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/dist-server/server/boat-delete-journal.js

@@ -11,7 +11,7 @@ const LOCK_RETRY_MS = 20;
 const MAX_REAPER_GENERATIONS = 128;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const BOT_ID = /^[A-Za-z0-9_-]{1,120}$/;
-const BOAT_ID = /^bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}$/;
+const BOAT_ID = /^(?:bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}|m_[a-z0-9]{20,40})$/;
 const OPERATION_ID = /^bdop_[a-f0-9]{32}$/;
 const PROVIDER_STATUSES = new Set(["pending", "processing", "blocked", "completed"]);
 /** Codes of a create refused while the bot's previous computer is being removed, or right after its removal finished. */

package/dist-server/server/boat.js

@@ -7,6 +7,7 @@ import { DATA_DIR } from "./config.js";
 import { loadEnvironmentId } from "./environment.js";
 import { boatCredential, boatProviderApi } from "./included-services.js";
 import { relayBody, relayPath } from "./boat-relay.js";
+import { instaboxFetch, isInstaboxKey, verifyInstaboxKey } from "./limix-instabox.js";
 import { blockedUntilBoatFinishes, boatDeletionOperation, deletionBlockedError, keptForNewerSnapshots, } from "./boat-deletion.js";
 import { adoptResolvedBoat, beginBoatCreate, boatCreateRecoverySnapshot, discardBoatCreate, rememberCreatedBoat, resolveBoatCreate, retireDeletedBoatCreate, } from "./boat-create-idempotency.js";
 import { BOAT_DELETING, BOAT_DELETION_FINISHED, boatDeletionSnapshot, getBoatDeletion, hasPendingBoatDeletionForBot, markBoatDeletionAccepted, markBoatDeletionBlocked, prepareBoatDeletion, retireBoatDeletion, } from "./boat-delete-journal.js";
@@ -41,7 +42,7 @@ const BOAT_INVENTORY_PAGE_SIZE = 200;
 const MAX_BOAT_INVENTORY_PAGES = 10;
 const LEGACY_MANAGED_BOAT_NAME = /^ogb-[a-z0-9]{1,8}-[a-f0-9]{6}$/;
 const SCOPED_MANAGED_BOAT_NAME = /^ogb-[a-f0-9]{12}-[a-z0-9]{1,8}-[a-f0-9]{6}$/;
-const BOAT_ID = /^bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}$/;
+const BOAT_ID = /^(?:bx_[23456789abcdefghjkmnpqrstuvwxyz]{8}|m_[a-z0-9]{20,40})$/;
 /** Sandbox.state in v1, plus OpenMausBot's own `removing` for a sandbox whose deletion is under way. */
 const BOAT_STATES = new Set([
     "init", "provisioning", "provisioned", "cloning", "ready", "idle", "running", "archiving", "archived", "error", "cancelled", "removing",
@@ -71,6 +72,8 @@ function snapshotBoatConfig(cfg) {
 /** An own token goes to Boat; Cloud Pro's included token only to its relay. */
 export function boatFetch(cfg, path, opts = {}) {
     const account = boatAccount(cfg);
+    if (isInstaboxKey(account?.token))
+        return instaboxFetch(account.token, path, opts);
     return fetch(`${account?.api ?? boatProviderApi()}${relayPath(account, path)}`, {
         ...opts,
         headers: {
@@ -785,6 +788,8 @@ export function describeBoatAccount(cfg) {
     return { configured: Boolean(account), ...(account?.included ? { included: true } : {}) };
 }
 export async function verifyToken(token) {
+    if (isInstaboxKey(token))
+        return verifyInstaboxKey(token);
     try {
         const res = await fetch(`${boatProviderApi()}/sandboxes?limit=1`, {
             headers: { authorization: `Bearer ${token}` },
@@ -798,7 +803,7 @@ export async function verifyToken(token) {
                 ok: false, rejected: true,
                 message: /^(boat|box)_/.test(token)
                     ? "boat.dev rejected that key — it may have been revoked or expired. Copy a fresh one from your boat.dev account."
-                    : "That doesn't look like a Boat API key: they start with boat_ (older ones with box_). Copy the API key from your boat.dev account (an account or session token won't work here).",
+                    : "That isn't a Boat or Instabox API key: Boat keys start with boat_ (older ones with box_), Instabox keys with ibk_. Copy the whole key, first letters included.",
             };
         }
         return { ok: false, message: `boat.dev returned ${res.status} for that token — try again in a moment.` };
@@ -810,6 +815,8 @@ export async function verifyToken(token) {
 const INCLUDED_BOAT_UNAVAILABLE = "The cloud computers included with your Cloud plan aren't available right now. Try again later.";
 const boatServiceName = (included) => included ? "Limix Bot Cloud's computer service" : "boat.dev";
 export function boatErrorMessage(status, what, body, included = false) {
+    if (typeof body?.message === "string" && body.message.startsWith("Instabox:"))
+        return `${what} failed. ${body.message}`;
     const theirs = typeof body?.message === "string" ? body.message.trim() : "";
     const link = typeof body?.error?.details?.billingUrl === "string" ? body.error.details.billingUrl : "";
     if (status === 402) {
@@ -849,7 +856,7 @@ function idempotentCreateInProgress(result) {
 }
 async function requestBoatCreate(cfg, botId, ttlSeconds) {
     // noEnv: no key this server holds ever reaches the computer. A trial-TTL retry needs a different idempotency key.
-    const body = JSON.stringify({ ttlSeconds, noEnv: true });
+    const body = JSON.stringify({ ttlSeconds, noEnv: true, ...(isInstaboxKey(boatAccount(cfg)?.token) ? { name: await boatNameFor(botId) } : {}) });
     let attempt = beginBoatCreate(botId, body);
     let request = attempt.request;
     let createdThisAttempt = attempt.startedNow;

package/dist-server/server/bot-api-host.js

@@ -10,6 +10,7 @@ import { personKey } from "./person-key.js";
 import { PASS } from "./routes/table.js";
 import { parseJson, schemaIssue } from "./schema.js";
 import { bearerSecret, header, json, readRawBody } from "./webhook-ingress.js";
+import { isLimixOwnerThread, LIMIX_OWNER_HEADER, limixOwnerCall, markLimixOwnerThread } from "./limix-owner-lane.js";
 /** How long a call waits by default before answering "working" with its thread id. Under the 60 s that Fly's proxy is reported
  * (community.fly.io, staff replies, 2022-2024) to allow a connection with no bytes: a dropped answer would lose the thread id. */
 export const BOT_API_DEFAULT_WAIT_MS = 50_000;
@@ -93,13 +94,13 @@ export function createBotApiHost(deps) {
             return { thread: threadId, status: "working" };
         return { reply: replyText(after), thread: threadId };
     }
-    async function runCall(botId, call, turnStarted) {
+    async function runCall(botId, call, turnStarted, owner = false) {
         const store = deps.store;
         let threadId = call.thread;
         if (threadId !== undefined) {
             const task = store.taskByThread(botId, threadId);
             // Only a thread this API opened: the caller never writes into the person's own conversations.
-            if (!task || task.botApi !== true)
+            if (!task || task.botApi !== true || isLimixOwnerThread(threadId) !== owner)
                 fail(404, "no such thread");
             if (deps.threadBusy(botId, threadId))
                 return { status: 409, body: { thread: threadId, status: "working" } };
@@ -116,6 +117,8 @@ export function createBotApiHost(deps) {
             threadId = task.threadId;
             opened = true;
             store.patchTask(botId, threadId, { botApi: true, outside: true });
+            if (owner)
+                markLimixOwnerThread(threadId);
         }
         const receivedAt = Date.now();
         const userMessage = store.appendMessage(threadId, { role: "user", kind: "text", text: message, via: "api" });
@@ -192,7 +195,8 @@ export function createBotApiHost(deps) {
                 json(res, 403, { error: BOT_API_UPGRADE });
                 return true;
             }
-            if (!deps.canConfine(botId)) {
+            const limixOwner = limixOwnerCall(req.headers[LIMIX_OWNER_HEADER]);
+            if (!limixOwner && !deps.canConfine(botId)) {
                 manager.recordRefused(botId, 403, CANNOT_CONFINE);
                 json(res, 403, { error: CANNOT_CONFINE });
                 return true;
@@ -200,7 +204,7 @@ export function createBotApiHost(deps) {
             if (req.method === "GET") {
                 const threadId = url.searchParams.get("thread") ?? "";
                 const task = /^[\w-]{1,128}$/.test(threadId) ? deps.store.taskByThread(botId, threadId) : undefined;
-                if (!task || task.botApi !== true) {
+                if (!task || task.botApi !== true || isLimixOwnerThread(threadId) !== limixOwner) {
                     json(res, 404, { error: "no such thread" });
                     return true;
                 }
@@ -237,7 +241,7 @@ export function createBotApiHost(deps) {
                 return true;
             }
             try {
-                const answer = await runCall(botId, call, release);
+                const answer = await runCall(botId, call, release, limixOwner);
                 manager.record(botId, { outcome: "accepted", statusCode: answer.status, threadId: answer.body.thread, preview: call.message,
                     reason: "reply" in answer.body ? "Replied" : answer.body.status === "needs_approval" ? "Stopped at an approval" : "Still working" });
                 json(res, answer.status, answer.body);

package/dist-server/server/index.js

@@ -588,6 +588,7 @@ import { createPersonCalendar } from "./host/person-calendar.js";
 import { createDevsReports } from "./host/devs-reports.js";
 import { limixReportAlias, limixReportSender, limixStatusAsker } from "./limix-report-mail.js";
 import { captureRecentLog } from "./recent-log.js";
+import { isLimixOwnerThread } from "./limix-owner-lane.js";
 import { createShareAnswer } from "./host/share-answer.js";
 import { createCardRequester, linePersonKey } from "./host/thread-person.js";
 import { selfThreadRefusal } from "./host/self-threads.js";
@@ -2786,7 +2787,7 @@ const outsideLineage = createOutsideLineage({
     node: (id) => coordinator.node(id), active: () => coordinator.active(), language: (threadId) => threadLanguage(threadId),
 });
 const { outsideDrivenThread, cloudGuestDriven, cloudGuestDrivenHandoff, outsideWorkStaysHere, confinedWhy, guestEngineRefusal } = outsideLineage;
-function botApiThread(id) { const owner = store.botByThread(id); return Boolean(owner && store.taskByThread(owner.id, id)?.botApi); }
+function botApiThread(id) { const owner = store.botByThread(id); return Boolean(owner && store.taskByThread(owner.id, id)?.botApi) && !isLimixOwnerThread(id); }
 const { messagePage, messageWindow } = messagePages(store);
 const replyVoiceNotes = createReplyVoiceNotes({ store, config: () => cfg, voiceReady: tts.voiceReady, speak: tts.speak, save: saveAudio, remove: deleteAttachment, redact: redactSecretsInText, language: threadLanguage });
 const { cloudLendingTurn, cloudLendingRefusalNotice, cloudLendingRefusalForBot, cloudLendingRefusal, cloudThreadStarters, cloudBotOpened, cloudLendingView, cloudReportFromOthers, handsOnLending, handedInUnproven, cloudOwnTurnRefusal, roomTurnStarted, roomTurnEnded, roomRun } = createCloudLendingTurns({

package/dist-server/server/limix-instabox.js

@@ -0,0 +1,382 @@
+// Limix Bot: Instabox (https://instabox.sh) as the cloud computer service, behind the same transport as Boat.
+// An Instabox API key (ibk_…) pasted in Settings → API keys sends every Boat REST call here, translated to the Instabox
+// API (https://instabox.sh/docs/api.md, checked 2026-11-12): machines instead of sandboxes, operations instead of
+// deletion operations, /exec instead of /commands. The answers come back in Boat's shape, so the rest of the app is
+// unchanged. Instabox cannot rename a machine, so the create carries the name (see `instaboxCreateName`).
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "./config.js";
+export const INSTABOX_API = "https://api.instabox.sh";
+/** Instabox's free plan creates only from agent-browser, android, omarchy or ci (refused with template_not_allowed, seen
+ * 2026-11-12): universal first, then agent-browser, a Linux desktop with a browser. */
+export const INSTABOX_TEMPLATES = ["universal", "agent-browser"];
+const DESKTOP_WIDTH = 1280;
+const DESKTOP_HEIGHT = 800;
+const EXEC_MAX_SECONDS = 600;
+const STREAM_TTL_SECONDS = 3600;
+const IDLE_SUSPEND_SECONDS = 3600;
+const BG_DIR = "/tmp/limix-bg";
+export const isInstaboxKey = (token) => typeof token === "string" && token.trim().startsWith("ibk_");
+/** Boat's sandbox states, from an Instabox machine state. */
+export function boatStateFromInstabox(state) {
+    switch (state) {
+        case "running": return "running";
+        case "creating":
+        case "starting":
+        case "resuming": return "provisioning";
+        case "stopping":
+        case "suspending": return "archiving";
+        case "stopped":
+        case "suspended": return "archived";
+        case "deleting": return "removing";
+        case "error": return "error";
+        default: return "init";
+    }
+}
+/** A machine the person made in Instabox themselves, taken over by a bot: Instabox names cannot change, so the bot's
+ * computer name is remembered here, by machine id. */
+const adoptedFile = () => join(DATA_DIR, "limix-instabox-adopted.json");
+function adopted() {
+    try {
+        const saved = JSON.parse(readFileSync(adoptedFile(), "utf8"));
+        return saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
+    }
+    catch {
+        return {};
+    }
+}
+function adopt(machineId, name) {
+    writeFileSync(adoptedFile(), JSON.stringify({ ...adopted(), [machineId]: name }));
+}
+const MANAGED_NAME = /^ogb-/;
+/** The one machine in the account that no bot uses yet and that Limix did not make, else null: with several, none is
+ * taken, since the others may be for something else. */
+async function adoptable(token, signal) {
+    const listed = await ib(token, "/v1/machines?limit=100", { signal });
+    if (!listed.ok || !Array.isArray(listed.body?.machines))
+        return null;
+    const taken = adopted();
+    const free = listed.body.machines.filter((m) => typeof m?.id === "string" && !taken[m.id] && !MANAGED_NAME.test(String(m?.name ?? ""))
+        && !["deleting", "error"].includes(m?.state));
+    return free.length === 1 ? free[0] : null;
+}
+function sandboxFrom(machine) {
+    const id = String(machine?.id ?? "");
+    return {
+        id,
+        name: adopted()[id] ?? (typeof machine?.name === "string" ? machine.name : ""),
+        state: boatStateFromInstabox(machine?.state),
+        desktopAvailable: true,
+        createdAt: machine?.createdAt ?? null,
+    };
+}
+/** Boat's deletion receipts carry bdop_ + 32 hex; Instabox operations are op_…, so each gets a stable stand-in. */
+const deletionOps = new Map();
+export function deletionOperationId(opId) {
+    return `bdop_${createHash("sha256").update(opId).digest("hex").slice(0, 32)}`;
+}
+function deletionStatus(state) {
+    if (state === "succeeded")
+        return "completed";
+    if (state === "queued")
+        return "pending";
+    if (state === "failed" || state === "cancelled")
+        return "blocked";
+    return "processing";
+}
+function json(status, body) {
+    return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+}
+/** Boat's error envelope ({message, error:{code}}) from Instabox's ({error:{code,message}}). */
+function boatError(status, body) {
+    const code = typeof body?.error?.code === "string" ? body.error.code : undefined;
+    const message = typeof body?.error?.message === "string" ? body.error.message : `Instabox ${status}`;
+    const scopes = Array.isArray(body?.error?.requiredScopes) ? ` (key needs: ${body.error.requiredScopes.join(", ")})` : "";
+    const hint = typeof body?.error?.hint === "string" ? ` ${body.error.hint}` : "";
+    // Boat's 403 means "wrong key" to the rest of the app; Instabox's 403 is a missing scope, unaccepted terms or a plan
+    // limit, so it travels as 409 and keeps Instabox's own words.
+    return json(status === 403 ? 409 : status, { ok: false, message: `Instabox: ${message}${scopes}${hint}${code ? ` [${code}]` : ""}`, error: { code, message } });
+}
+async function ib(token, path, call = {}) {
+    const headers = { "X-API-Key": token, ...call.headers };
+    if (call.body !== undefined)
+        headers["content-type"] = "application/json";
+    if (call.idempotent)
+        headers["Idempotency-Key"] ??= randomUUID();
+    const raw = await fetch(`${INSTABOX_API}${path}`, {
+        method: call.method ?? "GET",
+        headers,
+        body: call.body === undefined ? undefined : JSON.stringify(call.body),
+        signal: call.signal ?? undefined,
+    });
+    const body = raw.headers.get("content-type")?.includes("json") ? await raw.clone().json().catch(() => null) : null;
+    return { status: raw.status, ok: raw.ok, body, raw };
+}
+/** Commands run with DISPLAY pointed at the machine's X server, wherever Instabox started it. */
+const WITH_DISPLAY = 'if [ -z "$DISPLAY" ]; then for s in /tmp/.X11-unix/X*; do [ -e "$s" ] && export DISPLAY=":${s##*X}" && break; done; fi; ';
+async function exec(token, machineId, cmd, timeoutSeconds, signal) {
+    return ib(token, `/v1/machines/${machineId}/exec`, {
+        method: "POST",
+        body: { cmd: WITH_DISPLAY + cmd, timeoutSeconds: Math.max(1, Math.min(EXEC_MAX_SECONDS, Math.round(timeoutSeconds))), noHistory: true },
+        signal,
+    });
+}
+const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+/** The screen tools the computer-use driver calls; installed once per machine, quietly, if the template lacks them. */
+const SCREEN_TOOLS = "command -v xdotool >/dev/null && command -v xclip >/dev/null && (command -v scrot || command -v import || command -v ffmpeg) >/dev/null"
+    + " || { S=; [ \"$(id -u)\" = 0 ] || S='sudo -n'; $S apt-get update -qq >/dev/null 2>&1;"
+    + " DEBIAN_FRONTEND=noninteractive $S apt-get install -y -qq xdotool xclip scrot imagemagick >/dev/null 2>&1; }; command -v xdotool >/dev/null";
+const toolsReady = new Set();
+async function startDesktop(token, machineId, signal) {
+    const status = await ib(token, `/v1/machines/${machineId}/desktop`, { method: "POST", body: { action: "status" }, signal });
+    if (!status.ok)
+        return boatError(status.status, status.body);
+    const running = status.body?.running === true || status.body?.state === "running";
+    if (!running) {
+        const started = await ib(token, `/v1/machines/${machineId}/desktop`, {
+            method: "POST", body: { action: "start", width: DESKTOP_WIDTH, height: DESKTOP_HEIGHT }, signal,
+        });
+        if (!started.ok) {
+            if (started.status === 409 || started.status === 202)
+                return "provisioning";
+            return boatError(started.status, started.body);
+        }
+        if (!(started.body?.running === true || started.body?.state === "running"))
+            return "provisioning";
+    }
+    if (!toolsReady.has(machineId)) {
+        const tools = await exec(token, machineId, SCREEN_TOOLS, 300, signal);
+        if (tools.ok && tools.body?.exitCode === 0)
+            toolsReady.add(machineId);
+    }
+    return "ready";
+}
+/** POST /sandboxes/{id}/commands with detached: the process writes its output and exit code under /tmp/limix-bg. */
+async function startDetached(token, machineId, command, signal) {
+    const processId = Math.floor(Date.now() / 1000) * 1000 + Math.floor(Math.random() * 1000);
+    const base = `${BG_DIR}/${processId}`;
+    const script = `mkdir -p ${BG_DIR}; ( bash -lc ${shellQuote(command)} > ${base}.out 2> ${base}.err; echo $? > ${base}.exit ) </dev/null >/dev/null 2>&1 & echo started`;
+    const res = await exec(token, machineId, script, 30, signal);
+    if (!res.ok)
+        return boatError(res.status, res.body);
+    if (!/started/.test(String(res.body?.stdout ?? "")))
+        return json(502, { ok: false, message: "Instabox did not start the command" });
+    return json(200, { processId });
+}
+async function readDetached(token, machineId, processId, tailBytes, signal) {
+    if (!/^\d{1,16}$/.test(processId))
+        return json(404, { ok: false, message: "unknown process" });
+    const base = `${BG_DIR}/${processId}`;
+    const n = Math.max(1, Math.min(1_000_000, tailBytes));
+    const script = `[ -e ${base}.out ] || { echo GONE; exit 0; }; printf 'EXIT:%s\\n' "$(cat ${base}.exit 2>/dev/null)";`
+        + ` printf 'OUT:'; tail -c ${n} ${base}.out | base64 -w0; printf '\\nERR:'; tail -c ${n} ${base}.err | base64 -w0; echo`;
+    const res = await exec(token, machineId, script, 30, signal);
+    if (!res.ok)
+        return boatError(res.status, res.body);
+    const out = String(res.body?.stdout ?? "");
+    if (out.startsWith("GONE"))
+        return json(404, { ok: false, message: "unknown process" });
+    const field = (key) => out.match(new RegExp(`^${key}:(.*)$`, "m"))?.[1]?.trim() ?? "";
+    const exit = field("EXIT");
+    const decode = (b64) => Buffer.from(b64, "base64").toString("utf8");
+    const running = exit === "";
+    return json(200, {
+        running,
+        exitCode: running ? null : Number.parseInt(exit, 10),
+        stdout: decode(field("OUT")),
+        stderr: decode(field("ERR")),
+    });
+}
+/** Boat's request (path relative to its API, with its method, headers and JSON body) answered by Instabox. */
+export async function instaboxFetch(rawToken, path, opts = {}) {
+    const token = rawToken.trim();
+    const method = (opts.method ?? "GET").toUpperCase();
+    const signal = opts.signal;
+    const url = new URL(path, "http://boat.invalid");
+    const parts = url.pathname.split("/").filter(Boolean);
+    const reqHeaders = new Headers(opts.headers);
+    let reqBody = null;
+    if (typeof opts.body === "string" && opts.body) {
+        try {
+            reqBody = JSON.parse(opts.body);
+        }
+        catch {
+            reqBody = null;
+        }
+    }
+    if (parts[0] === "deletion-operations" && parts.length === 2 && method === "GET") {
+        const known = deletionOps.get(parts[1]);
+        if (!known)
+            return json(404, { ok: false, message: "unknown deletion operation" });
+        const op = await ib(token, `/v1/operations/${known.opId}`, { signal });
+        if (op.status === 404)
+            return json(200, { operation: { id: parts[1], kind: "sandbox", targetId: known.machineId, status: "completed", stage: "completed" } });
+        if (!op.ok)
+            return boatError(op.status, op.body);
+        const status = deletionStatus(op.body?.state);
+        return json(200, { operation: { id: parts[1], kind: "sandbox", targetId: known.machineId, status, stage: status === "completed" ? "completed" : status === "blocked" ? "retrying" : "removing" } });
+    }
+    if (parts[0] !== "sandboxes")
+        return json(404, { ok: false, message: `Instabox has no equivalent of ${path}` });
+    if (parts.length === 1) {
+        if (method === "GET") {
+            const q = new URLSearchParams();
+            const limit = url.searchParams.get("limit");
+            const cursor = url.searchParams.get("cursor");
+            if (limit)
+                q.set("limit", String(Math.min(100, Number(limit) || 100)));
+            if (cursor)
+                q.set("cursor", cursor);
+            const listed = await ib(token, `/v1/machines${q.toString() ? `?${q}` : ""}`, { signal });
+            if (!listed.ok)
+                return boatError(listed.status, listed.body);
+            const machines = Array.isArray(listed.body?.machines) ? listed.body.machines : [];
+            return json(200, { sandboxes: machines.map(sandboxFrom), pageInfo: { nextCursor: listed.body?.nextCursor ?? null } });
+        }
+        if (method === "POST") {
+            const name = typeof reqBody?.name === "string" ? reqBody.name : undefined;
+            const existing = name ? await adoptable(token, signal) : null;
+            if (existing && name) {
+                adopt(existing.id, name);
+                return json(201, { sandbox: sandboxFrom(existing) });
+            }
+            const key = reqHeaders.get("Idempotency-Key");
+            let created;
+            for (const templateId of INSTABOX_TEMPLATES) {
+                created = await ib(token, "/v1/machines", {
+                    method: "POST",
+                    idempotent: true,
+                    headers: key ? { "Idempotency-Key": `${key}-${templateId}` } : {},
+                    body: { ...(name ? { name } : {}), templateId, autoSuspendAfterSeconds: IDLE_SUSPEND_SECONDS, desiredState: "running" },
+                    signal,
+                });
+                if (created.body?.error?.code !== "template_not_allowed")
+                    break;
+            }
+            if (!created.ok) {
+                if (created.status === 409 && created.body?.error?.code === "idempotency_in_progress")
+                    return json(409, { ok: false, error: { code: "idempotency_in_progress" } });
+                return boatError(created.status, created.body);
+            }
+            const machineId = created.body?.machineId ?? created.body?.id;
+            if (typeof machineId !== "string")
+                return json(502, { ok: false, message: "Instabox did not say which machine it created" });
+            return json(201, { sandbox: { id: machineId, name: name ?? "", state: "provisioning", desktopAvailable: true } });
+        }
+    }
+    const machineId = parts[1];
+    if (!/^m_[a-z0-9]{20,40}$/.test(machineId ?? ""))
+        return json(404, { ok: false, message: "not an Instabox machine id" });
+    if (parts.length === 2) {
+        if (method === "GET") {
+            const got = await ib(token, `/v1/machines/${machineId}`, { signal });
+            if (!got.ok)
+                return got.status === 404 ? json(404, { ok: false, message: "not found" }) : boatError(got.status, got.body);
+            return json(200, { sandbox: sandboxFrom(got.body) });
+        }
+        if (method === "PATCH") {
+            // The name was given at create; Instabox names cannot change afterwards.
+            const got = await ib(token, `/v1/machines/${machineId}`, { signal });
+            if (!got.ok)
+                return boatError(got.status, got.body);
+            if (typeof reqBody?.name === "string" && sandboxFrom(got.body).name !== reqBody.name) {
+                return json(409, { ok: false, message: "Instabox cannot rename a machine; delete it and let Limix Bot create a new one" });
+            }
+            return json(200, { sandbox: sandboxFrom(got.body) });
+        }
+        if (method === "DELETE") {
+            const removed = await ib(token, `/v1/machines/${machineId}`, { method: "DELETE", idempotent: true, headers: { "X-Confirm-Delete": machineId }, signal });
+            if (removed.status === 404 || removed.status === 410)
+                return json(404, { ok: false, message: "not found" });
+            if (!removed.ok)
+                return boatError(removed.status, removed.body);
+            const opId = typeof removed.body?.id === "string" ? removed.body.id : null;
+            if (!opId)
+                return json(202, { operation: { id: deletionOperationId(machineId), kind: "sandbox", targetId: machineId, status: "completed", stage: "completed" } });
+            const id = deletionOperationId(opId);
+            deletionOps.set(id, { opId, machineId });
+            const status = deletionStatus(removed.body?.state);
+            return json(202, { operation: { id, kind: "sandbox", targetId: machineId, status, stage: status === "completed" ? "completed" : "removing" } });
+        }
+    }
+    const action = parts.slice(2).join("/");
+    if (method === "POST" && (action === "resume" || action === "stop")) {
+        let verb = action === "stop" ? "stop" : "start";
+        if (action === "resume") {
+            const got = await ib(token, `/v1/machines/${machineId}`, { signal });
+            if (got.ok && got.body?.state === "suspended")
+                verb = "resume";
+        }
+        const res = await ib(token, `/v1/machines/${machineId}/${verb}`, { method: "POST", idempotent: true, body: {}, signal });
+        if (!res.ok)
+            return res.status === 409 ? json(409, { ok: false, message: "busy" }) : boatError(res.status, res.body);
+        return json(202, { ok: true });
+    }
+    if (method === "POST" && action === "desktop") {
+        const started = await startDesktop(token, machineId, signal);
+        if (started instanceof Response)
+            return started;
+        if (started === "provisioning")
+            return json(200, { provisioning: true });
+        const stream = await ib(token, `/v1/machines/${machineId}/desktop/stream`, {
+            method: "POST", body: { viewOnly: false, ttlSeconds: STREAM_TTL_SECONDS }, signal,
+        });
+        if (!stream.ok)
+            return boatError(stream.status, stream.body);
+        return json(200, { desktopUrl: typeof stream.body?.url === "string" ? stream.body.url : null });
+    }
+    if (method === "POST" && action === "commands") {
+        const command = typeof reqBody?.command === "string" ? reqBody.command : "";
+        if (reqBody?.detached === true)
+            return startDetached(token, machineId, command, signal);
+        const res = await exec(token, machineId, command, EXEC_MAX_SECONDS, signal);
+        if (!res.ok)
+            return boatError(res.status, res.body);
+        return json(200, { exitCode: res.body?.exitCode ?? null, stdout: res.body?.stdout ?? "", stderr: res.body?.stderr ?? "", ...(res.body?.timedOut ? { timedOut: true } : {}) });
+    }
+    if (method === "GET" && parts[2] === "commands" && parts.length === 4) {
+        return readDetached(token, machineId, parts[3], Number(url.searchParams.get("tailBytes") ?? 4096), signal);
+    }
+    if (method === "GET" && (action === "artifacts" || action === "files")) {
+        const filePath = url.searchParams.get("path") ?? "";
+        if (!filePath.startsWith("/"))
+            return json(400, { ok: false, message: "absolute path required" });
+        const direct = await ib(token, `/v1/machines/${machineId}/files/content?path=${encodeURIComponent(filePath)}`, { signal });
+        if (direct.ok && !direct.raw.headers.get("content-type")?.includes("json")) {
+            const bytes = Buffer.from(await direct.raw.arrayBuffer());
+            if (action === "files")
+                return json(200, { content: bytes.toString("base64") });
+            return new Response(new Uint8Array(bytes), { status: 200, headers: { "content-type": "application/octet-stream" } });
+        }
+        const res = await exec(token, machineId, `base64 -w0 ${shellQuote(filePath)}`, 60, signal);
+        if (!res.ok)
+            return boatError(res.status, res.body);
+        if (res.body?.exitCode !== 0)
+            return json(404, { ok: false, message: "file not found" });
+        const content = String(res.body?.stdout ?? "").trim();
+        if (action === "files")
+            return json(200, { content });
+        return new Response(new Uint8Array(Buffer.from(content, "base64")), { status: 200, headers: { "content-type": "application/octet-stream" } });
+    }
+    if (method === "POST" && (action === "files/download-url" || action === "files/upload-url")) {
+        return json(501, { ok: false, code: "not_available", error: { code: "not_available" } });
+    }
+    return json(404, { ok: false, message: `Instabox has no equivalent of ${method} ${url.pathname}` });
+}
+/** Instabox checks a key with GET /v1/me. */
+export async function verifyInstaboxKey(rawToken) {
+    const token = rawToken.trim();
+    try {
+        const res = await fetch(`${INSTABOX_API}/v1/me`, { headers: { "X-API-Key": token }, signal: AbortSignal.timeout(20_000) });
+        if (res.ok)
+            return { ok: true };
+        if (res.status === 401 || res.status === 403) {
+            return { ok: false, rejected: true, message: "Instabox rejected that key — it may have been revoked. Create a new one at instabox.sh with the machines scopes." };
+        }
+        return { ok: false, message: `Instabox returned ${res.status} for that key — try again in a moment.` };
+    }
+    catch {
+        return { ok: false, message: "Couldn't reach Instabox to check that key — check your connection and retry." };
+    }
+}

package/dist-server/server/limix-owner-lane.js

@@ -0,0 +1,51 @@
+// Limix Bot: the bot's owner may talk to it from Telegram / Zalo / Discord with any AI, not only the ones that can run a
+// confined guest turn. The connector (limix-gateway) sends X-Limix-Owner only for a sender the owner linked with /link,
+// in a private chat; the secret is made per launch by the desktop app and never reaches an engine (deleted below,
+// before any engine is started). An owner thread stays an owner thread: a guest's call can never continue it.
+import { timingSafeEqual } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "./config.js";
+const TOKEN = process.env.LIMIX_OWNER_LANE_TOKEN?.trim() ?? "";
+delete process.env.LIMIX_OWNER_LANE_TOKEN;
+export const LIMIX_OWNER_HEADER = "x-limix-owner";
+export function limixOwnerCall(header) {
+    if (!/^[A-Za-z0-9_-]{43}$/.test(TOKEN) || typeof header !== "string")
+        return false;
+    const a = Buffer.from(header), b = Buffer.from(TOKEN);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+const MAX_THREADS = 5_000;
+let threads = null;
+const file = () => join(DATA_DIR, "limix-owner-threads.json");
+function loaded() {
+    if (threads)
+        return threads;
+    threads = new Set();
+    try {
+        const saved = JSON.parse(readFileSync(file(), "utf8"));
+        if (Array.isArray(saved))
+            for (const id of saved)
+                if (typeof id === "string")
+                    threads.add(id);
+    }
+    catch {
+        // No owner threads yet.
+    }
+    return threads;
+}
+export function isLimixOwnerThread(threadId) {
+    return loaded().has(threadId);
+}
+export function markLimixOwnerThread(threadId) {
+    const all = loaded();
+    if (all.has(threadId))
+        return;
+    all.add(threadId);
+    try {
+        writeFileSync(file(), JSON.stringify([...all].slice(-MAX_THREADS)));
+    }
+    catch {
+        // Kept in memory for this launch.
+    }
+}

package/dist-server/shared/first-reply-rescue.js

@@ -4,13 +4,13 @@
 // still reads it; this payload is what lets the desktop draw its buttons.
 /** The waiting row's words, for clients that print the tool name. */
 export function firstReplyWaitingName(botName, ai) {
-    return `notice: ${botName} hasn't heard back from ${ai} yet.`;
+    return `notice: ${botName} vẫn chưa nhận được phản hồi từ ${ai}.`;
 }
 /** The same row once its turn ended without an answer: history, true as it stands. */
 export function firstReplyOverName(botName, ai) {
-    return `notice: ${botName} didn't hear back from ${ai}.`;
+    return `notice: ${botName} không nhận được phản hồi từ ${ai}.`;
 }
 /** The same row once the AI's first output arrived. */
 export function firstReplySettledName(ai) {
-    return `notice: ${ai} answered after a slow start.`;
+    return `notice: ${ai} đã trả lời, sau một lúc chậm.`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limixbot",
-  "version": "0.3.4",
+  "version": "0.3.12",
   "description": "Run the Limix Bot server anywhere and pair your devices to it (Leox ৹ Limix AI)",
   "license": "Apache-2.0",
   "type": "module",