openmausbot 0.1.90 → 0.1.91

package/dist-server/server/boat.js

@@ -13,6 +13,7 @@
 import { createHash } from "node:crypto";
 import { DATA_DIR } from "./config.js";
 import { loadEnvironmentId } from "./environment.js";
+import { boatCredential, boatProviderApi } from "./included-services.js";
 import { adoptResolvedBoat, beginBoatCreate, boatCreateRecoverySnapshot, discardBoatCreate, rememberCreatedBoat, resolveBoatCreate, retireDeletedBoatCreate, } from "./boat-create-idempotency.js";
 import { boatDeletionSnapshot, getBoatDeletion, hasPendingBoatDeletionForBot, markBoatDeletionAccepted, markBoatDeletionBlocked, prepareBoatDeletion, retireBoatDeletion, } from "./boat-delete-journal.js";
 const shellQuote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -34,10 +35,8 @@ export function isolatedRemoteCommand(command) {
         shellQuote(command),
     ].join(" ");
 }
-// overridable so tests can point at a stub instead of the live provider.
 // Boat's provider surface keeps its historical Box-era names: env OMB_BOX_API,
 // base path /api/box/v1, REST paths /boxes/*, and the box_ token prefix.
-const BOAT_API = process.env.OMB_BOX_API || "https://ascii.dev/api/box/v1";
 const READY = new Set(["idle", "ready", "running"]);
 const SLEEPING = new Set(["archived", "archiving", "stopped", "stopping"]);
 const DEFAULT_BOAT_TTL_SECONDS = 8 * 60 * 60;
@@ -105,11 +104,15 @@ export function boatTurnLifecycleAction({ explicitCloud, canMount, state, }) {
 function snapshotBoatConfig(cfg) {
     return { box: cfg.box ? { token: cfg.box.token } : undefined };
 }
+/** The base URL follows the credential in use (included-services.ts): an own
+ * token goes to Boat (OMB_BOX_API points it at a stub in tests), Cloud Pro's
+ * included token only to its relay. */
 function boatFetch(cfg, path, opts = {}) {
-    return fetch(`${BOAT_API}${path}`, {
+    const account = boatAccount(cfg);
+    return fetch(`${account?.api ?? boatProviderApi()}${path}`, {
         ...opts,
         headers: {
-            authorization: `Bearer ${cfg.box?.token}`,
+            authorization: `Bearer ${account?.token}`,
             "content-type": "application/json",
             ...opts.headers,
         },
@@ -280,7 +283,7 @@ async function requestRecordedBoatDeletion(cfg, identity, pollDelaysMs = BOAT_DE
     }
     if (!removed.ok) {
         markBoatDeletionBlocked(identity.boxId);
-        throw Object.assign(new Error(boatErrorMessage(removed.status, "boat delete", removed.body)), { status: removed.status });
+        throw Object.assign(new Error(boatErrorMessage(removed.status, "boat delete", removed.body, usesIncludedBoat(cfg))), { status: removed.status });
     }
     const confirmation = await confirmAcceptedBoatDeletion(cfg, deletion, removed.body, pollDelaysMs);
     if (confirmation === "blocked")
@@ -346,6 +349,8 @@ async function mintDesktopUrl(cfg, boxId, { vncBudgetMs = 60_000 } = {}) {
 async function waitReady(cfg, boxId, budgetMs = 90_000) {
     assertBoatNotDeleting(boxId);
     const t0 = Date.now();
+    // Boat's words for the last failed resume, if the wait runs out on them.
+    let resumeFailure = null;
     while (Date.now() - t0 < budgetMs) {
         assertBoatNotDeleting(boxId);
         const { body } = await boatJson(cfg, `/boxes/${boxId}`);
@@ -354,11 +359,25 @@ async function waitReady(cfg, boxId, budgetMs = 90_000) {
             return body.box;
         if (state === "error")
             return null;
-        // an archiving boat can't resume until the snapshot lands — nudge after
-        if (state === "archived")
-            await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST" });
+        // an archiving boat can't resume until the snapshot lands — nudge after.
+        // A refusal (a plan limit, say) is final: report it now. A server error
+        // is retried on the next poll, as Boat asks; 409 is a state race with a
+        // wake already under way.
+        if (state === "archived") {
+            const resumed = await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST" });
+            if (resumed.ok)
+                resumeFailure = null;
+            else if (resumed.status !== 409) {
+                const message = boatErrorMessage(resumed.status, "waking the cloud computer", resumed.body, usesIncludedBoat(cfg));
+                if (resumed.status < 500)
+                    throw new Error(message);
+                resumeFailure = message;
+            }
+        }
         await new Promise((r) => setTimeout(r, 2500));
     }
+    if (resumeFailure)
+        throw new Error(resumeFailure);
     return null;
 }
 // Resolving a bot's boat means LISTing every boat in the account, so it is
@@ -367,9 +386,9 @@ async function waitReady(cfg, boxId, budgetMs = 90_000) {
 // whenever the direct read fails (deleted/renamed boat) and always carries
 // the live state so callers can still see "archived".
 const boatIdCache = new Map();
-function boatInventoryProblem(status, body) {
+function boatInventoryProblem(status, body, included = false) {
     if (status === 401 || status === 403) {
-        return "boat.dev rejected the Boat API key — update it in Settings → Connections";
+        return included ? INCLUDED_BOAT_UNAVAILABLE : "boat.dev rejected the Boat API key — update it in Settings → Connections";
     }
     if (status === 429)
         return "boat.dev is rate-limiting this account — wait a minute and refresh";
@@ -396,7 +415,11 @@ async function listBoatPages(cfg) {
             return { ok: false, problem: "Could not reach boat.dev to list cloud computers — check your connection and refresh" };
         }
         if (!listed.ok || !Array.isArray(listed.body?.boxes)) {
-            return { ok: false, problem: boatInventoryProblem(listed.status, listed.body), credentialRejected: listed.status === 401 || listed.status === 403 };
+            return {
+                ok: false,
+                problem: boatInventoryProblem(listed.status, listed.body, usesIncludedBoat(cfg)),
+                credentialRejected: listed.status === 401 || listed.status === 403,
+            };
         }
         boats.push(...listed.body.boxes);
         const next = listed.body?.pageInfo?.nextCursor;
@@ -672,7 +695,7 @@ export async function inspectBoatIdentity(cfg, boxId) {
         return { available: true, identity: null, problem: null };
     }
     if (!inspected.ok) {
-        return { available: false, identity: null, problem: boatInventoryProblem(inspected.status, inspected.body) };
+        return { available: false, identity: null, problem: boatInventoryProblem(inspected.status, inspected.body, usesIncludedBoat(cfg)) };
     }
     const candidate = inspected.body?.box;
     const returnedId = typeof candidate?.id === "string" ? candidate.id : "";
@@ -722,8 +745,9 @@ async function stopBoat(cfg, boxId) {
     // must never say a computer is sleeping when boat.dev rejected the action.
     await runCommand(cfg, boxId, QUIESCE_BROWSER, { timeoutMs: 5_000 }).catch(() => null);
     const stopped = await boatJson(cfg, `/boxes/${boxId}/stop`, { method: "POST" });
-    if (!stopped.ok)
-        throw Object.assign(new Error(boatErrorMessage(stopped.status, "boat sleep", stopped.body)), { status: stopped.status });
+    if (!stopped.ok) {
+        throw Object.assign(new Error(boatErrorMessage(stopped.status, "boat sleep", stopped.body, usesIncludedBoat(cfg))), { status: stopped.status });
+    }
 }
 function forgetBoatId(boxId) {
     for (const [botId, cachedId] of boatIdCache) {
@@ -854,15 +878,30 @@ export async function readyBoat(cfg, botId, budgetMs = 60_000) {
         return boat;
     return waitReady(cfg, boat.id, budgetMs);
 }
+/** The Boat credential a request uses: the person's own token, else Cloud
+ * Pro's included one. Settings' own-key flows read cfg.box.token instead. */
+export function boatAccount(cfg) {
+    return boatCredential(cfg.box?.token);
+}
 export function boatConfigured(cfg) {
-    return Boolean(cfg.box?.token);
+    return Boolean(boatAccount(cfg));
+}
+function usesIncludedBoat(cfg) {
+    return boatAccount(cfg)?.included === true;
+}
+/** What Settings shows: configured-or-not, and whether that is Cloud Pro's
+ * included account rather than a saved key. Never the token. */
+export function describeBoatAccount(cfg) {
+    const account = boatAccount(cfg);
+    return { configured: Boolean(account), ...(account?.included ? { included: true } : {}) };
 }
 /** Ask the provider whether a token is real, before we let someone save
  * it. Without this the paste "succeeds", and the first sign of trouble is
- * a 401 in a different panel minutes later, with nothing to act on. */
+ * a 401 in a different panel minutes later, with nothing to act on. Only
+ * ever an own token, so only ever Boat itself. */
 export async function verifyToken(token) {
     try {
-        const res = await fetch(`${BOAT_API}/boxes`, {
+        const res = await fetch(`${boatProviderApi()}/boxes`, {
             headers: { authorization: `Bearer ${token}` },
             signal: AbortSignal.timeout(20_000),
         });
@@ -884,11 +923,15 @@ export async function verifyToken(token) {
         return { ok: false, message: "Couldn't reach boat.dev to check that token — check your connection and retry." };
     }
 }
+/** A rejected Cloud Pro relay token: nothing the person pasted, so nothing
+ * for them to fix in Settings. */
+const INCLUDED_BOAT_UNAVAILABLE = "Cloud Pro's included cloud computers aren't available right now. Try again later.";
 /** Turn a provider refusal into something a person can act on. The
  * provider's own message is better than anything we can invent — it knows
  * the plan, the limit and the link — so prefer it and only fall back to
- * our own wording when it says nothing useful. */
-export function boatErrorMessage(status, what, body) {
+ * our own wording when it says nothing useful. `included`: the request used
+ * Cloud Pro's included token, not the person's own. */
+export function boatErrorMessage(status, what, body, included = false) {
     const theirs = typeof body?.message === "string" ? body.message.trim() : "";
     const link = typeof body?.error?.details?.billingUrl === "string" ? body.error.details.billingUrl : "";
     if (status === 402) {
@@ -896,6 +939,8 @@ export function boatErrorMessage(status, what, body) {
         return [theirs || "boat.dev needs a paid Boat plan before it will create a computer.", link].filter(Boolean).join(" ");
     }
     if (status === 401 || status === 403) {
+        if (included)
+            return INCLUDED_BOAT_UNAVAILABLE;
         return "your box token was rejected by boat.dev — open App Settings and paste a current token (it starts with box_)";
     }
     if (status === 429) {
@@ -1089,7 +1134,7 @@ export async function provisionBoat(cfg, botId, _botName) {
             // retry when boat.dev reports their shorter TTL ceiling.
             const createRes = await createBoat(cfg, botId, credentialEnv);
             if (!createRes.ok || !createRes.body?.box?.id) {
-                throw new Error(boatErrorMessage(createRes.status, "boat create", createRes.body));
+                throw new Error(boatErrorMessage(createRes.status, "boat create", createRes.body, usesIncludedBoat(cfg)));
             }
             boat = createRes.body.box;
             createRequest = createRes.request;
@@ -1099,7 +1144,7 @@ export async function provisionBoat(cfg, botId, _botName) {
                 body: JSON.stringify({ name: vmName }),
             });
             if (!rename.ok)
-                throw new Error(boatErrorMessage(rename.status, "box naming", rename.body));
+                throw new Error(boatErrorMessage(rename.status, "box naming", rename.body, usesIncludedBoat(cfg)));
             if (createRequest)
                 createRequest = resolveBoatCreate(createRequest);
         }

package/dist-server/server/bot-overview.js

@@ -144,14 +144,17 @@ export function grantsSummary(connectorTools) {
     })
         .sort((a, b) => (a.slug < b.slug ? -1 : 1));
 }
-function computerReach(computer) {
+function computerReach(computer, cloudHome = false) {
+    // A Cloud home never offers either; say so rather than list a preference
+    // that every task there refuses.
+    const unavailable = cloudHome ? ", which isn't available on OMB Cloud" : "";
     switch (computer) {
         case "cloud":
             return "Computer preference: cloud computer.";
         case "vm":
-            return "Computer preference: Local VM.";
+            return `Computer preference: Local VM${unavailable}.`;
         case "local":
-            return "Computer preference: this computer.";
+            return `Computer preference: this computer${unavailable}.`;
         case "browser":
             return "Computer preference: browser only.";
         case "off":
@@ -162,7 +165,7 @@ function computerReach(computer) {
 }
 function reachesLines(facts) {
     const lines = [];
-    const computer = computerReach(facts.bot.computer);
+    const computer = computerReach(facts.bot.computer, facts.cloudHome);
     if (computer)
         lines.push(computer);
     lines.push(facts.bot.cwd ? `Works in ${facts.bot.cwd}.` : "Works in its private workspace.");

package/dist-server/server/cloud-home-start.js

@@ -6,12 +6,13 @@
 // webhook receiver on :8800) and the Caddy edge on 0.0.0.0:8080. The edge is
 // the only listener the network can reach, and it always forwards with
 // X-Forwarded-*, so request-auth.ts never grants a remote request loopback
-// trust. If either child exits, both stop and the machine restarts.
+// trust. If either child exits, both stop and the machine restarts; the one
+// exception is the server asking to be started again after a restore.
 import { spawn } from "node:child_process";
 import { chownSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, posix, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { cloudHomeConfiguration, cloudHomeHost, prepareCloudHomeVolume, withoutIgnoredCloudKeys } from "./cloud-home.js";
+import { CLOUD_HOME_RESTART_EXIT_CODE, cloudHomeConfiguration, cloudHomeHost, prepareCloudHomeVolume, withoutIgnoredCloudKeys } from "./cloud-home.js";
 const SERVICE_USER = "maus";
 /** uid/gid from /etc/passwd; Node has no getpwnam. */
 export function passwdIds(passwd, name) {
@@ -39,6 +40,11 @@ export function cloudHomeChildEnvironments(config, env, home) {
     };
     return { server, edge };
 }
+/** What the launcher does when the server child exits: start it again only
+ * when it asked to (a committed restore), and only a few times in a row. */
+export function serverExitAction(code, stopping, restarts) {
+    return !stopping && code === CLOUD_HOME_RESTART_EXIT_CODE && restarts < 5 ? "restart" : "stop";
+}
 export function startCloudHome(env = process.env) {
     process.umask(0o077);
     const config = cloudHomeConfiguration(env);
@@ -81,13 +87,25 @@ export function startCloudHome(env = process.env) {
                 child.kill("SIGKILL"); }, 20_000);
         force.unref();
     };
-    const run = (command, args, childEnv) => {
+    const run = (command, args, childEnv, again) => {
         const child = spawn(command, args, { env: childEnv, stdio: "inherit" });
         children.push(child);
         child.once("error", () => stop(true));
-        child.once("exit", () => stop(true));
+        child.once("exit", (code) => {
+            children.splice(children.indexOf(child), 1);
+            if (!again?.(code))
+                stop(true);
+        });
     };
-    run(process.execPath, [join(here, "index.js")], server);
+    let restarts = 0;
+    const runServer = () => run(process.execPath, [join(here, "index.js")], server, (code) => {
+        if (serverExitAction(code, stopping, restarts) !== "restart")
+            return false;
+        restarts++;
+        runServer();
+        return true;
+    });
+    runServer();
     run(env.OMB_CLOUD_EDGE_BIN || "/usr/local/bin/caddy", ["run", "--config", env.OMB_CLOUD_EDGE_CONFIG || "/app/cloud/Caddyfile", "--adapter", "caddyfile"], edge);
     process.once("SIGTERM", () => stop(false));
     process.once("SIGINT", () => stop(false));

package/dist-server/server/cloud-home.js

@@ -1,5 +1,5 @@
-// OMB Cloud Pro home machine: the boot contract, the Admin's signed pairing
-// request, and the volume the machine lives on. docs/cloud-pro.md is the
+// OMB Cloud Pro home machine: the boot contract, the places it offers, the
+// Admin's signed pairing request, and the volume the machine lives on. docs/cloud-pro.md is the
 // contract of record (and openmaus-cloud docs/consumer-cloud.md its Admin
 // half); keep them in step.
 //
@@ -39,6 +39,10 @@ export const CLOUD_PAIRING_SKEW_S = 300;
 export const CLOUD_PAIRING_NONCE_MS = 10 * 60_000;
 const MAX_NONCES = 10_000;
 export const CLOUD_HOME_MARKER = ".omb-cloud-home.json";
+/** The server exits with this after a restore commits (Move to Cloud): the
+ * launcher then starts it again, and startup installs the restore. Any other
+ * exit stops the machine for Fly to restart. */
+export const CLOUD_HOME_RESTART_EXIT_CODE = 75;
 export function cloudHomeConfigured(env = process.env) {
     return CLOUD_HOME_KEYS.some((key) => env[key] !== undefined);
 }
@@ -92,6 +96,25 @@ export function withoutIgnoredCloudKeys(env) {
         delete kept[key];
     return kept;
 }
+// The places a Cloud home offers live in shared/cloud-home.ts, so the app
+// lists exactly what the server accepts.
+export { cloudHomeOffersPlace } from "../shared/cloud-home.js";
+/** Why a Cloud home refuses a place it never offers (no "this computer" of
+ * the person's, no Local VM), in the words the person reads; undefined for a
+ * place it offers. A turn's error shows 160 characters, so each fits. */
+export function cloudHomePlaceRefusal(place) {
+    if (place === "local")
+        return "This computer isn't a place on your OMB Cloud: its bots run in the cloud. Set Works on to Auto, Cloud or Browser, or lend your Mac under Settings → OMB Cloud.";
+    if (place === "vm")
+        return "Bots on your OMB Cloud can't use a Local VM: the cloud machine has no container runtime. Set Works on to Auto, Cloud or Browser.";
+    return undefined;
+}
+/** What a turn is told when Cloud is chosen but no Boat account is set up (no
+ * key of the person's and no included Boat). A Cloud home has no Local VM to
+ * suggest instead. */
+export function boatNotConfiguredMessage(cloudHome) {
+    return `Cloud Boat is not configured — add a Boat API key or choose ${cloudHome ? "Browser" : "Local VM"}`;
+}
 /** The Admin's side of the signature (openmaus-cloud cloudPairingSignature). */
 export function cloudPairingSignature(secret, timestamp, nonce, body) {
     const bodyHash = createHash("sha256").update(body).digest("base64url");

package/dist-server/server/cloud-lending.js

@@ -0,0 +1,103 @@
+// Who may use a Mac lent to an OMB Cloud home (docs/cloud-pro.md, "Let my
+// Cloud use this Mac"). A Cloud home is one person's server, but not every
+// turn on it is theirs: a guest the owner paired, a webhook's payload, or a
+// line someone else slipped into a running turn must never reach the Mac.
+//
+// A turn may use the lent Mac only when the harness can prove it acts for the
+// owner:
+// - a conversation the owner started from one of their own devices (a live
+//   session with admin scope), or
+// - a scheduled run of a routine whose instructions the owner wrote (created
+//   or edited from one of those devices), or a run the owner started by hand;
+// and the conversation holds nobody else's words, ever: a resumed session
+// carries everything said in it, so one line (or card answer) from a guest,
+// a teammate bot or a local process, before or during the turn, takes that
+// conversation out of lending. The owner starts a new one to lend again.
+// Webhook runs, guests, rooms, a bot's delegated or peer turn, and anything
+// unprovable never can.
+// Everything here is pure; server/index.ts supplies the records.
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+const personOf = (line) => line?.role === "user" && !line.peerAsk ? line.sender?.id : undefined;
+export function cloudHomeTurnMayLend(turn) {
+    return cloudHomeLendingRefusal(turn) === null;
+}
+export function cloudHomeLendingRefusal(turn) {
+    const { request } = turn;
+    if (!request?.messageId || request.stopped || !request.generations.has(turn.generation))
+        return "unproven";
+    const index = turn.thread.findIndex(line => line.id === request.messageId);
+    if (index < 0)
+        return "unproven";
+    let owner;
+    if (request.automation === undefined) {
+        owner = turn.ownerPerson(personOf(turn.thread[index]));
+    }
+    else {
+        const run = turn.routineRun();
+        owner = request.automation !== "webhook" && Boolean(run) && run.triggerSource !== "webhook" &&
+            run.ownerAuthored && (run.triggerSource !== "manual" || run.ownerStarted);
+    }
+    if (!owner)
+        return "not-owner";
+    // Nothing anyone else wrote (a guest, a teammate bot, a local process) may
+    // be anywhere in this conversation, before or after the request, as a line
+    // (sent, queued, steered or handed in) or as the answer to a card. A
+    // routine's own prompt line names nobody; its provenance was proven above.
+    const clean = turn.thread.every((line, at) => (line.role !== "user" || (at === index && request.automation !== undefined) || turn.ownerPerson(personOf(line))) &&
+        (!answeredByPerson(line.card) || turn.ownerPerson(turn.cardAnswerer(line.card))));
+    return clean ? null : "someone-else";
+}
+/** A card someone answered: a person's verdict or words. The harness's own
+ * settlements (automatic approvals, a turn that ended) are marked dismissed
+ * or unavailable and carry nobody's words. */
+function answeredByPerson(card) {
+    if (!card)
+        return false;
+    return (Boolean(card.answered) && card.answered !== "unavailable" && card.dismissed !== true) || Boolean(card.answeredText);
+}
+/** What a routine run does and when, reduced to what its author decides:
+ * the instructions, where and on what it runs, and its schedule. The
+ * scheduler never rewrites these (it does rewrite a routine's results thread
+ * on each run, so that is guarded by who edits the routine instead: see the
+ * routines PATCH route). An edit by anyone else changes the fingerprint. */
+export function routineFingerprint(routine) {
+    const attachments = (routine.attachments ?? []).map(attachment => [attachment.id, attachment.path]);
+    return createHash("sha256").update(JSON.stringify([
+        routine.prompt ?? "", routine.target ?? null, routine.botId ?? "", routine.groupId ?? null, attachments,
+        routine.schedule ?? null, routine.runOn ?? null,
+    ])).digest("hex");
+}
+const authorsFile = z.object({ version: z.literal(1), routines: z.record(z.string().max(128), z.string().regex(/^[a-f0-9]{64}$/)) }).strict();
+/** Which routines the owner wrote, as the fingerprint of what they wrote.
+ * Persisted beside the routines (owner-only). A missing or damaged file
+ * means none: it never grants anything by being absent. */
+export function createCloudRoutineAuthors(file) {
+    let routines = {};
+    try {
+        if (existsSync(file)) {
+            const stat = lstatSync(file);
+            if (stat.isFile() && !stat.isSymbolicLink() && stat.size <= 1_000_000)
+                routines = authorsFile.parse(JSON.parse(readFileSync(file, "utf8"))).routines;
+        }
+    }
+    catch {
+        routines = {};
+    }
+    const save = () => writeFileAtomic(file, JSON.stringify({ version: 1, routines }), { mode: 0o600 });
+    return {
+        /** The owner wrote this routine as it stands now. */
+        record(id, routine) { routines = { ...routines, [id]: routineFingerprint(routine) }; save(); },
+        forget(id) { if (Object.hasOwn(routines, id)) {
+            const next = { ...routines };
+            delete next[id];
+            routines = next;
+            save();
+        } },
+        /** Whether this routine, as it stands (or as a run snapshotted it), is
+         * exactly what the owner wrote. */
+        authored(id, routine) { return Object.hasOwn(routines, id) && routines[id] === routineFingerprint(routine); },
+    };
+}