openmausbot 0.1.95 → 0.1.97

package/dist-server/server/turn-images.js

@@ -9,6 +9,7 @@ import { lstatSync, realpathSync, statSync } from "node:fs";
 import { dirname, extname, resolve } from "node:path";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { ATTACHMENTS_DIR, IMAGE_MAX_BYTES } from "./attachments.js";
+import { decodeAttachmentAttribute } from "./message-file.js";
 /** Matches the companion composer policy. Four maximum-sized images are
  * bounded to 40 MiB before a provider is asked to ingest them. */
 export const TURN_IMAGE_MAX_COUNT = 4;
@@ -24,27 +25,6 @@ const MIME_BY_EXTENSION = {
 function statusError(status, message) {
     return Object.assign(new Error(message), { status });
 }
-/** Decode exactly the entities emitted by the composer. Repeated or unknown
- * encodings stay encoded and therefore cannot acquire a privileged path. */
-function decodeAttachmentAttribute(value) {
-    return value.replace(/&(quot|lt|gt|amp);|&#(9|10|13);/g, (entity, named, numeric) => {
-        if (numeric === "9")
-            return "\t";
-        if (numeric === "10")
-            return "\n";
-        if (numeric === "13")
-            return "\r";
-        if (named === "quot")
-            return '"';
-        if (named === "lt")
-            return "<";
-        if (named === "gt")
-            return ">";
-        if (named === "amp")
-            return "&";
-        return entity;
-    });
-}
 function walk(node, visit) {
     const pending = [node];
     while (pending.length > 0) {

package/dist-server/server/turn-resources.js

@@ -1,12 +1,12 @@
-import { realpathSync } from "node:fs";
-import { relative, resolve, sep } from "node:path";
 /** One harness owns the data directory. Claims are synchronous and last for
  * the whole turn, not just a click: a screenshot and its following click
- * must see the same desktop. These coordinate app-managed resources; they
- * are not a sandbox for arbitrary shell commands. */
+ * must see the same desktop. These coordinate app-managed resources — a
+ * desktop, a browser session, a phone — that only one turn can drive at a
+ * time. A project folder is not one: a bot's threads work in one folder
+ * side by side, as several agent sessions do in one repo. They are not a
+ * sandbox for arbitrary shell commands. */
 export class TurnResources {
     owners = new Map();
-    reclaims = new Map();
     /** Arrival-ordered waiters per requested resource (#1652). Entries exist
      * only while a turn is genuinely waiting (the exclusive bind's poll loop):
      * a lazy claim that failed once and moved on must not sit at the front and
@@ -72,25 +72,16 @@ export class TurnResources {
     waitEstimateMs(resource) {
         return this.waitStats.get(resource)?.ewmaMs;
     }
-    blocker(resource, owner, now = Date.now()) {
-        this.expireIdle(resource, now);
-        for (const [key, current] of this.owners) {
-            if (overlaps(key, resource) && !sameOwner(current.owner, owner))
-                return current.owner;
-        }
-        return undefined;
+    blocker(resource, owner) {
+        const current = this.owners.get(resource);
+        return current && !sameOwner(current, owner) ? current : undefined;
     }
-    claim(resource, owner, options = {}) {
-        const now = options.now ?? Date.now();
-        if (this.blocker(resource, owner, now))
+    claim(resource, owner) {
+        if (this.blocker(resource, owner))
             return false;
         const existing = this.owners.get(resource);
-        if (existing && sameOwner(existing.owner, owner)) {
-            // A repeated claim by the sitting owner changes nothing: replacing
-            // the record would restart activityAt, and re-claims alone would
-            // hold the seat past every quiet window (#1653).
+        if (existing && sameOwner(existing, owner))
             return true;
-        }
         // The free seat belongs to the front waiter; a current holder's
         // revalidation above never loses its own claim to this queue.
         const queue = this.waiters.get(resource);
@@ -101,76 +92,12 @@ export class TurnResources {
             if (!queue.length)
                 this.waiters.delete(resource);
         }
-        const record = { owner };
-        if (options.idle) {
-            record.idle = options.idle;
-            // Taking (or retaking) a seat is itself screen activity: the quiet
-            // window of #1653 starts at the claim, not at the first later call.
-            record.activityAt = now;
-        }
-        this.owners.set(resource, record);
-        const reclaimed = this.reclaims.get(resource);
-        // Seating an owner closes any idle-release record for this resource:
-        // the previous holder re-claimed (its turn lives on), or another turn
-        // took the free seat — an occupied seat is exactly where #1653 says
-        // the old holder yields.
-        if (reclaimed)
-            this.reclaims.delete(resource);
+        this.owners.set(resource, owner);
         return true;
     }
-    owns(resource, owner, now = Date.now()) {
-        this.expireIdle(resource, now);
-        const current = this.owners.get(resource);
-        return Boolean(current && sameOwner(current.owner, owner));
-    }
-    /** A real screen call touched this claim (#1653): restart its quiet
-     * window. Claims without an idle policy — and anything the screen
-     * poller drives — are no-ops, so preview frames can never hold a seat. */
-    activity(resource, owner, now = Date.now()) {
-        // Expiry first: a straggler screen completion arriving at or past the
-        // quiet boundary must release the seat and open the reclaim window,
-        // not restart the clock on a claim that already lapsed.
-        this.expireIdle(resource, now);
+    owns(resource, owner) {
         const current = this.owners.get(resource);
-        if (current?.idle && sameOwner(current.owner, owner))
-            current.activityAt = now;
-    }
-    /** A screen-touching computer tool call started on this claim (#1653):
-     * the desktop is executing real I/O for the sitting owner, so the seat
-     * cannot be idle-released mid-call. Only the sitting owner's start
-     * counts; a start whose completion never arrives holds the seat until
-     * settle — the pre-#1653 behavior, never an overlapping handoff. */
-    beginComputerCall(resource, owner) {
-        const current = this.owners.get(resource);
-        if (current?.idle && sameOwner(current.owner, owner)) {
-            current.computerCallsInFlight = (current.computerCallsInFlight ?? 0) + 1;
-        }
-    }
-    /** The in-flight computer call finished: drop its fence and let the
-     * completion's own activity tick govern the quiet window. A no-op when
-     * the claim lapsed or another turn seated itself in between. */
-    endComputerCall(resource, owner) {
-        const current = this.owners.get(resource);
-        if (!current?.idle || !sameOwner(current.owner, owner))
-            return;
-        const inFlight = current.computerCallsInFlight ?? 0;
-        if (inFlight > 0)
-            current.computerCallsInFlight = inFlight - 1;
-    }
-    /** Who may still re-claim `resource` directly after an idle release
-     * (#1653): the mid-task turn that went quiet, until its reclaim window
-     * ends or another turn seats itself. The direct re-claim itself is
-     * just `claim`: a free seat answers the returning holder's next screen
-     * call without the wait a new arrival would enter. */
-    reclaimHolder(resource, now = Date.now()) {
-        const reclaimed = this.reclaims.get(resource);
-        if (!reclaimed)
-            return undefined;
-        if (reclaimed.until <= now) {
-            this.reclaims.delete(resource);
-            return undefined;
-        }
-        return reclaimed.owner;
+        return Boolean(current && sameOwner(current, owner));
     }
     release(owner) {
         for (const [key, queue] of this.waiters) {
@@ -181,81 +108,23 @@ export class TurnResources {
                 this.waiters.delete(key);
         }
         for (const [key, current] of this.owners) {
-            if (sameOwner(current.owner, owner))
+            if (sameOwner(current, owner))
                 this.owners.delete(key);
         }
-        // A settling turn keeps no reclaim priority (#1653): only a live
-        // mid-task turn may pick its seat back up.
-        for (const [key, reclaimed] of this.reclaims) {
-            if (sameOwner(reclaimed.owner, owner))
-                this.reclaims.delete(key);
-        }
     }
     /** Drop one of an owner's claims early, when the sequence that took it
      * could not finish. The owner's other claims stand until settle. */
-    releaseOne(resource, owner, now = Date.now()) {
-        if (this.owns(resource, owner, now))
+    releaseOne(resource, owner) {
+        if (this.owns(resource, owner))
             this.owners.delete(resource);
         this.stopWaiting(resource, owner);
-        // owns() may have just expired a quiet claim into a reclaim record
-        // for this same owner: an early release keeps no reclaim priority.
-        const reclaimed = this.reclaims.get(resource);
-        if (reclaimed && sameOwner(reclaimed.owner, owner))
-            this.reclaims.delete(resource);
-    }
-    /** Quiet-window expiry (#1653), evaluated when the claim is touched: a
-     * screen-quiet seat is released while its turn lives and remembered for
-     * the reclaim window. Synchronous on purpose — the claim map decides
-     * every transition on the server's single thread. */
-    expireIdle(resource, now) {
-        const current = this.owners.get(resource);
-        if (!current?.idle || current.activityAt === undefined)
-            return;
-        // A call the desktop is still executing fences the seat (#1653):
-        // releasing mid-call would hand one desktop to two turns at once.
-        if ((current.computerCallsInFlight ?? 0) > 0)
-            return;
-        if (!current.idle.quietElapsed(current.activityAt, now))
-            return;
-        this.owners.delete(resource);
-        this.reclaims.set(resource, { owner: current.owner, until: now + current.idle.reclaimMs });
     }
     /** Whether any live owner holds this resource: the parked-resume drain's
      * gate (#1651) — a resume fires only when the seat it queued on is free. */
-    free(resource, now = Date.now()) {
-        for (const key of this.owners.keys()) {
-            if (!overlaps(key, resource))
-                continue;
-            // A quiet-window claim expires the moment anything needs to know
-            // whether the seat is free: the parked-resume gate must not wait on
-            // a claim whose window already elapsed (#1653).
-            this.expireIdle(key, now);
-            if (this.owners.has(key))
-                return false;
-        }
-        return true;
+    free(resource) {
+        return !this.owners.has(resource);
     }
 }
 function sameOwner(a, b) {
     return a.threadId === b.threadId && a.generation === b.generation;
 }
-export function workspaceResource(cwd) {
-    // Selected folders must exist before the engine starts. Resolve symlinks
-    // and native filename casing so aliases cannot grant two writers to the
-    // same project on case-insensitive volumes.
-    const canonical = realpathSync.native(resolve(cwd));
-    return `workspace:${process.platform === "win32" ? canonical.toLowerCase() : canonical}`;
-}
-function overlaps(a, b) {
-    if (a === b)
-        return true;
-    if (!a.startsWith("workspace:") || !b.startsWith("workspace:"))
-        return false;
-    const left = a.slice("workspace:".length);
-    const right = b.slice("workspace:".length);
-    const contains = (parent, child) => {
-        const path = relative(parent, child);
-        return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !path.startsWith(sep) && !/^[A-Za-z]:/.test(path));
-    };
-    return contains(left, right) || contains(right, left);
-}

package/dist-server/server/usage-ledger.js

@@ -26,7 +26,9 @@ const promptBytesOf = (value) => {
         ? { stable: clean(record.stable), volatile: clean(record.volatile) }
         : null;
 };
-function monthKey(at) {
+/** The UTC month a row belongs to, `YYYY-MM`: the name of its month file.
+ * The decision, admin-activity and decider logs use the same layout. */
+export function monthKey(at) {
     return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
 }
 export function usageFileFor(dataDir, at) {

package/dist-server/server/workspace.js

@@ -20,7 +20,7 @@ export const WORKSPACES_DIR = join(DATA_DIR, "workspaces");
 export const TASK_WORKSPACES_DIR = join(DATA_DIR, "task-workspaces");
 /** MCP support does not imply native filesystem tools or a local working directory. */
 export function supportsWorkspaceFiles(driverKind) {
-    return !["grok", "openai-compat", "minimax", "mistral", "cerebras", "boxAgent"].includes(driverKind);
+    return !["grok", "openai-compat", "minimax", "mistral", "cerebras"].includes(driverKind);
 }
 /** Default task files are private to the thread, outside the bot's shared
  * memory folder. This is directory organization, not a shell sandbox. */
@@ -588,9 +588,8 @@ export function writeMemoryTopic(botId, name, text) {
     writeFileAtomic(join(workspaceDir(botId), "memory", name), redactSecretsInText(text), { mode: 0o600 });
     indexWrittenMemoryFile(botId, `memory/${name}`);
 }
-/** Read one topic file. The name gate runs here too, not only in the HTTP
- * route — a future caller must not be able to turn this into a read of an
- * arbitrary path. Null for anything invalid or unreadable. */
+/** Read one topic file. The name gate runs here, so no caller can turn this
+ * into a read of an arbitrary path. Null for anything invalid or unreadable. */
 export function readMemoryTopic(botId, name) {
     if (!isMemoryTopicName(name))
         return null;

package/dist-server/server-launcher.js

@@ -0,0 +1,72 @@
+// server/server-launcher.ts
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// server/restart.ts
+var RESTART_EXIT_CODE = 75;
+var MAX_RESTARTS = 5;
+var STABLE_RUN_MS = 6e4;
+function restartPolicy(now = Date.now) {
+  let restarts = 0, startedAt = now();
+  return {
+    again(code, stopping = false) {
+      if (now() - startedAt >= STABLE_RUN_MS) restarts = 0;
+      if (stopping || code !== RESTART_EXIT_CODE || restarts >= MAX_RESTARTS) return false;
+      restarts++;
+      startedAt = now();
+      return true;
+    }
+  };
+}
+
+// server/server-launcher.ts
+function superviseServer(start, options = {}) {
+  const signals = options.signals ?? process, now = options.now ?? Date.now;
+  return new Promise((done) => {
+    let child, stopping = false;
+    const policy = restartPolicy(now);
+    const pass = (signal) => () => {
+      stopping = true;
+      child.kill(signal);
+    };
+    const onTerm = pass("SIGTERM"), onInt = pass("SIGINT");
+    const finish = (code) => {
+      signals.off("SIGTERM", onTerm);
+      signals.off("SIGINT", onInt);
+      done(code);
+    };
+    const run = () => {
+      child = start();
+      child.once("error", () => finish(1));
+      child.once("exit", (code, signal) => {
+        if (policy.again(code, stopping)) {
+          console.log("OpenMausBot is starting again to finish installing a copy from the desktop app\u2026");
+          run();
+          return;
+        }
+        finish(code ?? (stopping && (signal === "SIGTERM" || signal === "SIGINT") ? 0 : 1));
+      });
+    };
+    signals.on("SIGTERM", onTerm);
+    signals.on("SIGINT", onInt);
+    run();
+  });
+}
+function isEntry() {
+  try {
+    return Boolean(process.argv[1]) && import.meta.url === pathToFileURL(realpathSync(resolve(process.argv[1]))).href;
+  } catch {
+    return false;
+  }
+}
+if (isEntry()) {
+  const server = join(dirname(fileURLToPath(import.meta.url)), "index.js");
+  void superviseServer(() => spawn(process.execPath, [server], { stdio: "inherit" })).then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  superviseServer
+};

package/dist-server/shared/ask-question.js

@@ -34,7 +34,7 @@ export const MAX_CUSTOM_ANSWER = 2000;
 export function isPersistentQuestionCard(card) {
     return Boolean(card && (card.requestType === "question" || card.questionRequest ||
         (!card.requestType && !card.tool && !card.routineRequest && !card.skillRequest && !card.profileRequest &&
-            !card.modelRequest && !card.tighteningRequest && !card.teamSetupRequest)));
+            !card.modelRequest && !card.teamSetupRequest)));
 }
 /** System/provider completion ends the live run, not the human's question. */
 export function shouldSettleRequestCard(card, source) {
@@ -109,55 +109,6 @@ export function parseAskQuestions(input) {
     }
     return questions.length ? questions : null;
 }
-/** The fenced block a turn-boundary agent ends its run with when it wants
- * to ask the person something (the BoatAgent transport): the harness cannot
- * pause mid-run, so the questions ride the final output and OMB parses them
- * at settle. The block is model-authored — untrusted input like any tool
- * call — so its body runs through parseAskQuestions and the same caps. */
-const OMB_ASK_FENCE = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}\2[ \t]*(?=\r?\n|$)/;
-const OMB_ASK_FENCE_GLOBAL = new RegExp(OMB_ASK_FENCE.source, OMB_ASK_FENCE.flags + "g");
-/** The questions inside the first fenced omb-ask block in an output, or
- * null when there is nothing worth showing (no fence, invalid JSON, or no
- * entry that parses as a question). The first fence wins: a second block
- * in the same output is ignored, not merged. */
-export function parseOmbAskQuestions(output) {
-    const match = OMB_ASK_FENCE.exec(output);
-    if (!match)
-        return null;
-    try {
-        return parseAskQuestions(JSON.parse(match[3]));
-    }
-    catch {
-        return null;
-    }
-}
-/** The output with its omb-ask block(s) removed, for display: the person
- * reads the prose around the ask, never the raw protocol JSON. Text
- * without a block is returned untouched. */
-export function stripOmbAskBlock(output) {
-    if (!OMB_ASK_FENCE.test(output))
-        return output;
-    return output.replace(OMB_ASK_FENCE_GLOBAL, "").replace(/\n{3,}/g, "\n\n").trim();
-}
-/** The prompt contract that teaches a model the turn-held ask transport: end
- * the reply with a fenced `omb-ask` block carrying the questions, and the
- * answers come back on the next prompt. A harness that cannot pause mid-run
- * (the BoatAgent transport) appends this to every prompt; the caps in the text
- * are the constants above, so the taught contract and the parser cannot
- * drift apart. */
-export function ombAskProtocolPrompt() {
-    return [
-        "",
-        "## Asking the person a question",
-        "When a decision belongs to the person, end your reply with a fenced block exactly like this:",
-        "",
-        "```omb-ask",
-        '{"questions":[{"question":"Ship the release now?","header":"Release","options":[{"label":"Ship now"},{"label":"Wait for the QA signoff"}]}]}',
-        "```",
-        "",
-        `The block must be the last thing in your reply. You may ask up to ${MAX_QUESTIONS} questions at once, each with up to ${MAX_OPTIONS} options; the person can always answer in their own words. Their answers arrive on your next prompt as \`Q:\`/\`A:\` lines — never invent them.`,
-    ].join("\n");
-}
 /** The one line the card subtitle and a spoken prompt show. */
 export function askQuestionSummary(questions) {
     const first = questions[0]?.question ?? "";
@@ -254,10 +205,6 @@ export const ASK_USER_TOOL_DEFINITION = {
         },
     },
 };
-/** The synthetic tool string for an ask parsed out of model-authored final
- * output (the BoatAgent turn-held transport): there is no tool call to name,
- * but the event and the ASKS_A_PERSON backstop need one string. */
-export const OMB_ASK_TOOL = "omb-ask";
 /** The lead-in on a formatted answer. It exists for the model — the answer
  * is delivered on the deny channel, so it has to say what it is — and the
  * card strips it back off when it shows the person what they sent. */
@@ -283,23 +230,6 @@ export function formatQuestionAnswers(questions, answers) {
 export function answerWithoutPreamble(answer) {
     return answer.startsWith(`${ANSWER_PREAMBLE}\n\n`) ? answer.slice(ANSWER_PREAMBLE.length + 2) : answer;
 }
-/** The longest formatted answer OMB will echo back into a follow-up prompt
- * (the BoatAgent continuation). formatQuestionAnswers itself does not
- * truncate — the tool-result channel has no stated limit — but a prompt is
- * not the place to find one: six answers at the custom-answer cap is the
- * most a legitimate reply weighs, so that is the ceiling. */
-export const MAX_ANSWER_ECHO = 6 * MAX_CUSTOM_ANSWER;
-/** Cap a formatted answer for echoing into a follow-up prompt. An over-cap
- * echo is cut back to the last whole block so no partial answer reads as
- * one, and says it was truncated. */
-export function capAnswerEcho(answer, limit = MAX_ANSWER_ECHO) {
-    if (answer.length <= limit)
-        return answer;
-    const cut = answer.slice(0, limit);
-    const boundary = cut.lastIndexOf("\n\nQ: ");
-    const kept = boundary > 0 ? cut.slice(0, boundary) : cut;
-    return kept + "\n\n[answer truncated]";
-}
 /**
  * The answer text, read back as one value per question.
  *

package/dist-server/shared/cloud-computer.js

@@ -0,0 +1,10 @@
+// Which engines can work on a cloud computer: Hosted desktop on Boat, or a
+// self-hosted VPS. One rule for the server (every attach, readiness check and
+// select_computer offer) and the renderer (the Works on panel, the composer's
+// place chip, Webhooks and Routines), so the two never disagree.
+/** An engine with computer tools gets the cloud computer as one more stdio
+ * computer server, on a Boat and on a VPS alike. The turn always stays on the
+ * bot's own engine; nothing hands it to another one. */
+export function canWorkOnCloud(engine) {
+    return engine?.computerMcp === true;
+}

package/dist-server/shared/credential-request.js

@@ -18,7 +18,7 @@ export const CREDENTIAL_TARGETS = {
     },
     opencodeGoApiKey: {
         label: "OpenCode API key",
-        description: "Used for OpenCode Go and other key-backed OpenCode providers.",
+        description: "Used for OpenCode Zen and Go.",
         placeholder: "Paste your OpenCode API key",
         helpUrl: "https://opencode.ai/docs/providers/",
     },

package/dist-server/shared/failed-turn.js

@@ -0,0 +1,22 @@
+const MARKER = "error:";
+/** The longest cause a row keeps. Clients wrap the row and show it whole, so
+ * this only bounds a pathological message (a provider's HTML body, a stack
+ * trace); a sentence a person acts on fits, its next action included. */
+export const FAILED_TURN_MAX_CHARS = 600;
+/** The activity row a failed turn is stored as. */
+export function failedTurnTool(cause, flags = {}) {
+    const words = cause.length > FAILED_TURN_MAX_CHARS ? `${cause.slice(0, FAILED_TURN_MAX_CHARS - 1)}…` : cause;
+    return {
+        name: `${MARKER} ${words}`,
+        ok: false,
+        ...(flags.setup ? { setup: true } : {}),
+        ...(flags.terminal ? { terminal: true } : {}),
+        ...(flags.claudeUpdate ? { claudeUpdate: true } : {}),
+        ...(flags.place ? { place: flags.place } : {}),
+    };
+}
+/** The cause a failed-turn row carries, without its marker; null for any
+ * other activity row. */
+export function failedTurnCause(name) {
+    return name.startsWith(MARKER) ? name.slice(MARKER.length).trim() : null;
+}

package/dist-server/shared/live-approval.js

@@ -1,12 +1,12 @@
 /** "approval": a provider or peer ask the voice may decide with a strict yes/no.
  * "review": a harness-native proposal (skill, routine, profile, default
- * model, tightening, team setup) that must be reviewed on screen.
+ * model, team setup) that must be reviewed on screen.
  * "question": a provider question. An expired proposal is settled: nothing
  * can answer it any more. */
 export function liveCardKind(card) {
     if (!card?.requestId || card.answered || card.dismissed || card.expired)
         return null;
-    if (card.skillRequest || card.routineRequest || card.profileRequest || card.modelRequest || card.tighteningRequest || card.teamSetupRequest) {
+    if (card.skillRequest || card.routineRequest || card.profileRequest || card.modelRequest || card.teamSetupRequest) {
         return "review";
     }
     return card.tool ? "approval" : "question";

package/dist-server/shared/package-format.js

@@ -55,9 +55,9 @@ const encoder = new TextEncoder();
 export function utf8Bytes(value) {
     return encoder.encode(value).length;
 }
-// ── shared field helpers (identical to the v1 reader) ─────────────────────
-const requiredText = (max) => z.string({ error: "must be text" }).trim().min(1, { message: "is required" }).max(max, { message: "is too long" });
-const optionalText = (max) => z
+// ── shared field helpers (the team manifest reader uses these too) ────────
+export const requiredText = (max) => z.string({ error: "must be text" }).trim().min(1, { message: "is required" }).max(max, { message: "is too long" });
+export const optionalText = (max) => z
     .union([z.string({ error: "must be text" }), z.null(), z.undefined()])
     .transform((value) => value?.trim() || undefined)
     .refine((value) => value === undefined || value.length <= max, { message: "is too long" })