openmausbot 0.1.96 → 0.1.98

package/dist-server/server/key-rejections.js

@@ -0,0 +1,57 @@
+// A saved key counts as working until the provider says otherwise. When a
+// real use of it is refused as a bad key (a chat request, or Test in
+// Settings → API keys), every engine on that key and endpoint reports it as
+// not signed in, until the key is saved or cleared again or a later use of
+// it succeeds. In memory only: after a restart the key shows as working
+// until its next use fails. The key itself is never kept, only a hash of it
+// beside the provider's base URL.
+import { createHash } from "node:crypto";
+export const KEY_REJECTED_REASON = "The provider rejected this key. Change it in Settings → API keys.";
+const rejected = new Set();
+const listeners = new Set();
+const fingerprint = (key) => createHash("sha256").update(key.trim()).digest("hex").slice(0, 32);
+const markOf = (url, key) => `${url.trim().replace(/\/+$/, "")} ${fingerprint(key)}`;
+const changed = () => { for (const listener of listeners)
+    listener(); };
+export function keyRejected(url, key) {
+    return rejected.size > 0 && rejected.has(markOf(url, key));
+}
+export function noteKeyRejected(url, key) {
+    const mark = markOf(url, key);
+    if (rejected.has(mark))
+        return;
+    rejected.add(mark);
+    changed();
+}
+export function noteKeyAccepted(url, key) {
+    if (rejected.size > 0 && rejected.delete(markOf(url, key)))
+        changed();
+}
+/** Drops every mark on this key, whatever endpoint it was used against. */
+export function forgetKey(key) {
+    if (rejected.size === 0)
+        return;
+    const suffix = ` ${fingerprint(key)}`;
+    const before = rejected.size;
+    for (const mark of rejected)
+        if (mark.endsWith(suffix))
+            rejected.delete(mark);
+    if (rejected.size !== before)
+        changed();
+}
+export function onKeyRejectionChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+/** The provider refused the key itself: HTTP 401, or a 400/403 whose body
+ * says the key is invalid or revoked (xAI answers a wrong key with a 400).
+ * Rate limits, quota, billing and model access are not the key's fault. */
+export function rejectsKey(status, body) {
+    if (/\b(?:quota|billing|credits?|rate.?limit|insufficient.?(?:balance|funds))\b/i.test(body))
+        return false;
+    if (status === 401)
+        return true;
+    if (status !== 400 && status !== 403)
+        return false;
+    return /\binvalid_api_key\b|\b(?:invalid|incorrect|revoked|expired|disabled|deactivated)[ _-]?(?:api[ _-]?)?key\b|\bapi[ _-]?key (?:is |was |has been )?(?:invalid|incorrect|revoked|expired|disabled|not valid)\b/i.test(body);
+}

package/dist-server/server/live-call.js

@@ -11,6 +11,7 @@
 // This file owns the one server-side step: exchanging the renderer's WebRTC
 // offer for an answer. The OpenAI key never leaves the harness; the renderer
 // only ever holds the SDP answer and the media connection it describes.
+import { CLOUD_HOME_PLACE } from "./system-prompt.js";
 export const LIVE_MODEL = "gpt-live-1";
 const OPENAI_BASE = "https://api.openai.com";
 export const DEFAULT_LIVE_VOICE = "marin";
@@ -57,14 +58,18 @@ export class LiveSessionError extends Error {
     }
 }
 /** Frontend instructions for the voice. Business rules stay with the bot;
- * this only says who is speaking and when to hand work over. Structure
- * follows the GPT-Live prompting guide's template. */
-export function liveInstructions(bot) {
+ * this only says who is speaking, where it runs and when to hand work over.
+ * Structure follows the GPT-Live prompting guide's template. `cloudHome`:
+ * the harness is the person's My Cloud, named as the bot's own system prompt
+ * names it (CLOUD_HOME_PLACE). */
+export function liveInstructions(bot, { cloudHome = false } = {}) {
     const name = oneLine(bot.name) || "the agent";
     const title = oneLine(bot.title ?? "");
     const description = oneLine(bot.description ?? "").slice(0, 400);
+    const where = cloudHome ? `runs on ${CLOUD_HOME_PLACE}` : "runs in OpenMausBot on the user's own computer";
+    const changes = cloudHome ? "My Cloud" : "the computer";
     return [
-        `You are ${name}${title ? `, ${title}` : ""}, an AI agent that runs in OpenMausBot on the user's own computer.${description ? ` ${description}` : ""}`,
+        `You are ${name}${title ? `, ${title}` : ""}, an AI agent that ${where}.${description ? ` ${description}` : ""}`,
         `To the user you are one assistant, ${name}, and you speak in the first person. Your work — looking things up, using your tools, files and memory, researching, deciding, and answering anything that needs facts this conversation does not hold — happens when you delegate. Delegating is how you think and act; it is not someone else.`,
         "Never mention a backend, delegation, a voice layer, or another system or model doing the work, and never say you are only a voice. Say \"I\" about the work.",
         "Never ask the user whether you may look something up or check something. When it needs checking, delegate at once and say briefly that you are checking.",
@@ -74,7 +79,7 @@ export function liveInstructions(bot) {
         "Interruption policy: Stop speaking when the user interrupts. Listen to what they say.",
         "Delegation policy:",
         "Backend tools:",
-        `- ${name}: your own files, tools, memory, settings and this conversation's history. It researches, writes, changes things on the computer, and answers questions, including questions about yourself such as which AI model you run on, your settings, your tools and your memory.`,
+        `- ${name}: your own files, tools, memory, settings and this conversation's history. It researches, writes, changes things on ${changes}, and answers questions, including questions about yourself such as which AI model you run on, your settings, your tools and your memory.`,
         "Delegate to the backend when:",
         "- The user asks a question, asks for work, or gives an instruction.",
         "- The user asks something about you that this conversation does not already answer, for example which AI model you run on.",
@@ -131,7 +136,7 @@ export async function createLiveSession(input) {
     const body = {
         session: {
             model: LIVE_MODEL,
-            instructions: liveInstructions(input.bot),
+            instructions: liveInstructions(input.bot, { cloudHome: input.cloudHome }),
             // client delegation: every request comes back to the harness, which
             // runs it as a normal turn on the bot
             delegation: { type: "client" },

package/dist-server/server/managed-policy.js

@@ -16,7 +16,7 @@ const policySchema = z.object({
     computers: z.object({ thisComputer: z.boolean(), localVm: z.boolean(), box: z.boolean(), vps: z.boolean() }).strict(),
     remoteAccess: z.boolean(),
 }).strict();
-const computerLabels = { thisComputer: "this computer", localVm: "local virtual machines", box: "Boat cloud computers", vps: "VPS computers" };
+const computerLabels = { thisComputer: "this computer", localVm: "local virtual machines", box: "cloud computers", vps: "VPS computers" };
 export function parseManagedPolicy(raw, now = Date.now()) {
     if (raw === null)
         return null;

package/dist-server/server/message-file.js

@@ -17,9 +17,12 @@ export function messageFileRoots(options) {
             options.attachments,
         ])];
 }
-function statusError(status, message) {
-    return Object.assign(new Error(message), { status });
+function statusError(status, message, code) {
+    return Object.assign(new Error(message), { status, ...(code ? { code } : {}) });
 }
+// The client offers "Show in folder" for exactly this refusal, so it carries a
+// stable code instead of being recognised by its English text.
+const outsideWorkspace = () => statusError(403, "the linked file is outside this conversation's workspace", "outside_workspace");
 function decodePathWithSuffixRemoved(href) {
     // Split before decoding so an encoded `?` or `#` remains part of the
     // filename, while a real Markdown query/fragment never reaches the file
@@ -396,7 +399,7 @@ export async function openMessageFile(href, roots) {
             }
             const canonicalAfter = await realpath(candidate);
             if (!containedBy(root, canonicalAfter))
-                throw statusError(403, "the linked file is outside this conversation's workspace");
+                throw outsideWorkspace();
             const after = await stat(canonicalAfter);
             if (opened.dev !== after.dev || opened.ino !== after.ino) {
                 throw statusError(409, "the linked file changed while it was being opened");
@@ -416,7 +419,7 @@ export async function openMessageFile(href, roots) {
         }
     }
     if (sawOutsideRoot)
-        throw statusError(403, "the linked file is outside this conversation's workspace");
+        throw outsideWorkspace();
     throw statusError(404, "the linked file is unavailable");
 }
 /** A safe attachment header with a readable ASCII fallback and UTF-8 name. */

package/dist-server/server/model-catalog/presets.js

@@ -139,6 +139,14 @@ export const PROVIDER_PRESETS = [
         anthropic: { baseUrl: "https://opencode.ai/zen" },
         checkedAt: CHECKED,
     },
+    {
+        id: "wallaby",
+        catalogId: "wallaby",
+        label: "Wallaby",
+        api: "https://api.wallabytoken.com/v1",
+        keyCheck: "/models",
+        checkedAt: "2026-10-05",
+    },
 ];
 const BY_ID = new Map(PROVIDER_PRESETS.map((preset) => [preset.id, preset]));
 export function providerPreset(id) {

package/dist-server/server/peer-roster.js

@@ -6,10 +6,18 @@
 import { sameAudience } from "./bot-visibility.js";
 const sectionKey = (section) => section?.trim() || "";
 export const PEER_ACCESS_HELP = "Call list_bots for reachable teammates. If the intended Chief is missing, ask the user to check team membership and this bot's allowed peers, or message the Chief directly. A Chief's access to another team does not grant that team's bots access back to the Chief. Do not use computer control to bypass this.";
+/** OMB_OPEN_TEAMS=1 runs the workspace as one team: any bot may reach a bot
+ * in any section, so sections only group the sidebar. Off by default. Peer
+ * lists, hidden bots and visibility still apply, and it grants no Chief
+ * authority (coordinatorSupervises). Read per call, so no caller caches it. */
+const openTeams = () => process.env.OMB_OPEN_TEAMS === "1";
 /** Coordination is scoped to the bot's own team unless the owner explicitly
- * allows its Chief to work with additional teams. A title, peer id, imported
- * persona or a room membership is not a grant. Invalid saved grants fail closed. */
+ * allows its Chief to work with additional teams, or opens every team to
+ * every bot (openTeams). A title, peer id, imported persona or a room
+ * membership is not a grant. Invalid saved grants fail closed. */
 export function canAccessTeam(from, section) {
+    if (openTeams())
+        return true;
     const target = sectionKey(section);
     return target === sectionKey(from.section) || Boolean(from.chiefOfStaff &&
         Array.isArray(from.managedSections) && from.managedSections.some(value => typeof value === "string" && sectionKey(value) === target));

package/dist-server/server/permission-proxy.js

@@ -36,6 +36,9 @@ const allowQuestion = allowsTool(selection.scope, { kind: "mcp", server: "ogb",
 const socketPath = process.argv[2] ?? "";
 const waiting = new Map();
 const conn = connect(socketPath);
+// Both streams below carry JSON lines that can be larger than one read.
+// Decoding as a stream keeps a character split across two reads whole.
+conn.setEncoding("utf8");
 const dead = () => {
     for (const resolve of waiting.values()) {
         resolve({ behavior: "deny", message: "OpenMausBot: permission broker unavailable — skip this action" });
@@ -227,6 +230,7 @@ async function handle(msg) {
     }
 }
 let inBuf = "";
+process.stdin.setEncoding("utf8");
 process.stdin.on("data", (chunk) => {
     inBuf += chunk;
     let nl;

package/dist-server/server/provider-key-check.js

@@ -14,9 +14,13 @@ export function isLoopback(hostname) {
     const host = hostname.replace(/^\[|\]$/g, "");
     return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
 }
+/** A provider's base URL: the configured one, or its default. */
+export function providerBaseUrl(provider, base) {
+    return (base?.trim() || DEFAULT_URLS[provider]).replace(/\/+$/, "");
+}
 /** The models endpoint for a provider, from its base URL or the default. */
 export function providerModelsUrl(provider, base) {
-    const root = (base?.trim() || DEFAULT_URLS[provider]).replace(/\/+$/, "");
+    const root = providerBaseUrl(provider, base);
     if (provider === "anthropic")
         return root.endsWith("/v1") ? `${root}/models` : `${root}/v1/models`;
     return `${root}/models`;

package/dist-server/server/request-auth.js

@@ -340,7 +340,7 @@ export function clientBotPatchViolation(body) {
     return null;
 }
 /** Same for a room: name and reading state, never its folder or who answers. */
-const CLIENT_GROUP_PATCH_FIELDS = new Set(["name", "bulletin", "unread", "pinnedMessageId", "section"]);
+const CLIENT_GROUP_PATCH_FIELDS = new Set(["name", "bulletin", "unread", "pinnedMessageId", "section", "turnTimeoutMinutes"]);
 export function clientGroupPatchViolation(body) {
     if (!body || typeof body !== "object" || Array.isArray(body))
         return "body";

package/dist-server/server/room-turn-end.js

@@ -0,0 +1,15 @@
+/** How a room member's provider turn ended, read from its turn.completed and
+ * from what ended it early: the member's cloud computer, claimed by its first
+ * computer call, could not start (a failure with its cause) or parked waiting
+ * for its seat. Kept free of index.ts so the rule stays unit-testable. */
+export function roomTurnEnd(event, orchestrated, claim) {
+    if (claim?.parked)
+        return { outcome: "parked" };
+    // The cause, not the "interrupted" the ending interrupt settles as; and a
+    // chat round stops here, as it stops on a failure at setup.
+    if (claim)
+        return { outcome: "provider_failed", stopReason: claim.message };
+    if (orchestrated && !event.ok)
+        return { outcome: "provider_failed", stopReason: event.stopReason ?? null };
+    return { outcome: "settled" };
+}

package/dist-server/server/room-turn-timeout.js

@@ -1,6 +1,34 @@
+import { MAX_ROOM_TURN_TIMEOUT_MINUTES, MIN_ROOM_TURN_TIMEOUT_MINUTES, } from "./config.js";
 export function roomTurnTimeoutMs(minutes) {
     return minutes * 60_000;
 }
+/** A conversation may replace the global group ceiling. Null clears that
+ * choice. Anything else is refused rather than silently clamped. */
+export function parseConversationTurnTimeout(value) {
+    if (value === null)
+        return { ok: true, minutes: null };
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < MIN_ROOM_TURN_TIMEOUT_MINUTES ||
+        value > MAX_ROOM_TURN_TIMEOUT_MINUTES) {
+        return {
+            ok: false,
+            error: "Turn limit must be a whole number from 1 to 1,440, or null to use the group default.",
+        };
+    }
+    return { ok: true, minutes: value };
+}
+/** The ceiling captured for one turn. An override wins; a missing or
+ * unusable one keeps the global group limit. */
+export function effectiveRoomTurnTimeoutMinutes(globalMinutes, override) {
+    if (typeof override === "number" &&
+        Number.isInteger(override) &&
+        override >= MIN_ROOM_TURN_TIMEOUT_MINUTES &&
+        override <= MAX_ROOM_TURN_TIMEOUT_MINUTES) {
+        return override;
+    }
+    return globalMinutes;
+}
 /**
  * One room turn's slice of the configured room ceiling.
  *

package/dist-server/server/routes/live.js

@@ -8,11 +8,11 @@ const sessionBody = z.object({
     threadId: id.optional(),
     // Not trimmed: the SDP offer goes to OpenAI byte for byte.
     sdp: z.string().min(1).refine((sdp) => Buffer.byteLength(sdp) <= MAX_SDP_BYTES),
-    client: z.enum(["desktop", "ios", "android"]),
+    client: z.enum(["desktop", "web", "ios", "android"]),
 }).strict();
 const endBody = z.object({ callId: z.string().min(1).max(120) }).strict();
 // Strict, so `key` (or anything else) is refused rather than ignored: the key
-// is only ever set on the computer that runs the harness.
+// is saved through the desktop's credential store or PUT /api/config, never here.
 const settingsBody = z.object({
     voice: z.string().trim().max(40).regex(/^[a-z]*$/).optional(),
     readTypedReplies: z.boolean().optional(),
@@ -86,7 +86,7 @@ export function createLiveRoutes(deps) {
         if (method === "PATCH" && path === "/api/live/settings") {
             const parsed = settingsBody.safeParse(await bodyOf(req, readBody));
             if (!parsed.success) {
-                return json(res, 400, { error: "Those Live settings are not valid. The OpenAI key can only be changed on the computer that runs OpenMausBot." });
+                return json(res, 400, { error: "Those Live settings are not valid." });
             }
             // as PUT /api/config: an empty patch is not saved (or broadcast)
             if (!Object.keys(parsed.data).length)

package/dist-server/server/routes/thread-models.js

@@ -0,0 +1,36 @@
+import { sameModelSelection } from "../../shared/thread-model.js";
+import { PASS } from "./table.js";
+const MAX_THREAD_IDS = 10_000;
+export function createThreadModelRoutes(deps) {
+    return async ({ req, res, path, method, auth, json, readBody }) => {
+        const m = path.match(/^\/api\/bots\/([\w-]+)\/threads\/follow-model$/);
+        if (!m || method !== "POST")
+            return PASS;
+        const bot = deps.bot(m[1]);
+        if (!bot)
+            return json(res, 404, { error: "no such bot" });
+        if (!deps.mayChangeModel(auth))
+            return json(res, 403, { error: "On this Cloud only its owner can change a bot's model." });
+        const body = await readBody(req);
+        if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "threadIds")) {
+            return json(res, 400, { error: "send {} or { threadIds }" });
+        }
+        const raw = body.threadIds;
+        if (raw !== undefined && (!Array.isArray(raw) || raw.length > MAX_THREAD_IDS || raw.some((id) => typeof id !== "string"))) {
+            return json(res, 400, { error: "threadIds must be a list of this bot's thread ids" });
+        }
+        const tasks = bot.tasks ?? [];
+        const ids = new Set(tasks.map((task) => task.threadId));
+        const foreign = raw?.find((id) => !ids.has(id));
+        if (foreign !== undefined)
+            return json(res, 400, { error: `"${foreign}" is not one of this bot's threads` });
+        if (bot.approvalGrant)
+            return json(res, 409, { error: "wait for the approval-level change to finish before changing models" });
+        const listed = raw === undefined ? null : new Set(raw);
+        const own = tasks.filter((task) => (!listed || listed.has(task.threadId)) &&
+            task.modelSelection !== undefined && !sameModelSelection(task.modelSelection, bot.modelSelection));
+        const busy = own.filter((task) => deps.busy(bot.id, task.threadId));
+        const switched = deps.follow(bot.id, own.filter((task) => !busy.includes(task)).map((task) => task.threadId));
+        return json(res, 200, { switched: switched.length, busy: busy.length, bot: deps.reply(bot.id) });
+    };
+}

package/dist-server/server/routine-requests.js

@@ -674,7 +674,7 @@ function cardCopy(operation, manager, timeZone, now) {
     const nextRunAt = nextForOperation(operation, manager, now);
     const scheduleTimeZone = definition.schedule.type === "cron" ? definition.schedule.timeZone : timeZone;
     const when = operation.action === "run_now" ? "Now" : scheduleText(definition.schedule, timeZone);
-    const destination = definition.runOn === "cloud" ? "Bot’s current model on its Boat cloud computer" : "Bot’s current model and configured computer";
+    const destination = definition.runOn === "cloud" ? "Bot’s current model on its cloud computer" : "Bot’s current model and configured computer";
     const current = operation.action === "create"
         ? null
         : manager.listRoutines().find((routine) => routine.id === operation.routineId) ?? null;

package/dist-server/server/routines.js

@@ -943,7 +943,7 @@ export class RoutineManager {
         this.commitMutation(() => {
             run = this.newRun(routine, this.now(), true, allocations, request?.threadId ?? routine.sourceThreadId);
             // Preserve the invoking chat as provenance/fallback for this run.
-            // An explicitly configured results destination continues to win.
+            // The routine's results destination continues to win.
             if (request)
                 run.sourceThreadId = request.threadId;
             if (request)
@@ -1297,7 +1297,7 @@ export class RoutineManager {
                         ? run.groupId
                             ? this.options.createGoalTask?.(run.groupId, title) ?? null
                             : null
-                        : this.options.createTask(run.botId, title, run.triggerSource === "webhook", run.routineId);
+                        : this.options.createTask(run.botId, title, run.triggerSource === "webhook", run);
                 if (!task) {
                     this.failRun(run, run.target === "room-goal"
                         ? "Could not create a room task for this goal"
@@ -1546,7 +1546,7 @@ export class RoutineManager {
         if (value === null) {
             const destination = this.options.resolveResultsThread?.(routine, true);
             if (!destination)
-                throw new Error("Could not create a results thread for this routine");
+                throw new Error("Could not find a results thread for this routine");
             routine.resultsThreadId = destination;
             return () => this.options.discardResultsThread?.(routine.botId, destination);
         }

package/dist-server/server/screen-frame-gate.js

@@ -7,9 +7,7 @@
 //      shell command over computer_exec or a status read does not count,
 //      however the driver happens to spell the tool's name;
 //   2. is the end frame different from the one the transcript already
-//      shows — a boxAgent turn starts as screen work by definition, so this
-//      is what keeps its shell-only replies from re-picturing the same idle
-//      desktop.
+//      shows — this keeps a reply from re-picturing the same idle desktop.
 import { createHash } from "node:crypto";
 // Tool-name classification lives in shared/tool-surface.ts so the renderer
 // reads a tool the same way the poller does.

package/dist-server/server/skills.js

@@ -29,7 +29,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { z } from "zod";
-import { writeFileAtomic } from "./atomic.js";
+import { writeFileAtomic, writeFileAtomicIfChanged } from "./atomic.js";
 import { DATA_DIR } from "./config.js";
 import { redactSecretsInText } from "./redact.js";
 import { LEARN_SOURCE_PREFIX } from "./skill-learn.js";
@@ -191,9 +191,10 @@ function readManagedLinks(botId) {
         return [];
     }
 }
+// Rebuilt on every turn and almost always the same list.
 function writeManagedLinks(botId, names) {
     mkdirSync(skillStateDir(botId), { recursive: true, mode: 0o700 });
-    writeFileAtomic(managedLinksPath(botId), `${JSON.stringify([...new Set(names)].sort(), null, 2)}\n`, { mode: 0o600 });
+    writeFileAtomicIfChanged(managedLinksPath(botId), `${JSON.stringify([...new Set(names)].sort(), null, 2)}\n`, { mode: 0o600 });
 }
 function manifestFromFile(path) {
     try {