openmausbot 0.1.93 → 0.1.95

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

@@ -31,7 +31,8 @@ export function resolveProxy(relative) {
  * the smoke test can assert each one actually exists in a packaged layout —
  * the check that would have caught the 0.1.24 breakage. */
 export const SPAWNED_PROXIES = {
-    browser: resolveProxy("browser-proxy"),
+    // The built-in browser and the cloud computer: argv[2] picks which.
+    harnessMcp: resolveProxy("harness-mcp-proxy"),
     localComputer: resolveProxy("local-computer-proxy"),
     permission: resolveProxy("permission-proxy"),
     containerMcp: resolveProxy("container-mcp"),
@@ -40,6 +41,7 @@ export const SPAWNED_PROXIES = {
     dweb: resolveProxy("drivers/dweb-proxy"),
     connectors: resolveProxy("connector-proxy"),
     mcpGate: resolveProxy("mcp-gate"),
+    mcpRemote: resolveProxy("mcp-remote-proxy"),
     phone: resolveProxy("drivers/phone-proxy"),
     hook: resolveProxy("hooks/omb-hook"),
     // Loaded by the external `pi` process via `-e`, not by this server — but

package/dist-server/server/redact.js

@@ -18,6 +18,8 @@ const SECRET_KEY_PARTS = ["token", "secret", "password", "passwd", "apikey", "ap
  * every real one is spelled (API_KEY, consumer-key, xai_key). */
 function isSecretName(name) {
     const lower = name.toLowerCase();
+    if (lower === "omb_gate_upstream" || lower === "omb_remote_mcp_server")
+        return true;
     if (SECRET_KEY_PARTS.some((part) => lower.includes(part)))
         return true;
     return /(^|[_.-])keys?$/.test(lower);

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

@@ -1,6 +1,6 @@
 import { timingSafeEqual } from "node:crypto";
 import { isIP } from "node:net";
-import { denyReason as companionDenial } from "../companion/src/routes.js";
+import { denyReason as companionDenial, isCompanionNotice } from "../companion/src/routes.js";
 const LOOPBACK_SCOPES = ["admin", "client"];
 const SERVICE_SCOPES = ["client"];
 /** What a `service`-trust loopback caller may reach, and nothing else:
@@ -442,7 +442,8 @@ export function resolveRequestAuth(req, options) {
             if (!secureTokenMatch(companionToken, options.companionMutationToken ?? "") ||
                 req.headers["x-openmausbot-companion"] !== "1" ||
                 !/^[\w-]{1,128}$/.test(headerValue(req.headers["x-openmausbot-companion-device"]) ?? "") ||
-                companionDenial({ path, method, authenticated: true }))
+                // a phone's allowlisted route, or the companion's own notice (an unpaired phone)
+                (companionDenial({ path, method, authenticated: true }) && !isCompanionNotice(method, path)))
                 return deny(403, "forbidden: invalid companion request");
             return { auth: { kind: "loopback", scopes: LOOPBACK_SCOPES }, status: 401, error: "" };
         }

package/dist-server/server/room-handoffs.js

@@ -225,20 +225,12 @@ export class RoomHandoffs {
         if (path.some(n => n.botId === target.botId && (!n.groupId || !target.groupId || n.groupId === target.groupId))) {
             throw new Error("Cannot assign work back to an ancestor; results return automatically");
         }
-        const existing = this.children(parent.id).find(n => n.key === key);
-        if (existing) {
-            if (existing.groupId !== target.groupId || existing.botId !== target.botId || existing.text !== text ||
-                existing.kind !== kind || existing.requestBatchKey !== requestBatchKey)
-                throw new Error("request_key was already used for different work");
+        // The same text to the same teammate and place under one parent is one
+        // request, so a repeat lands on it. Only rework=true runs a finished or
+        // failed one again.
+        const existing = this.children(parent.id).findLast(n => n.botId === target.botId && n.groupId === target.groupId && n.text === text);
+        if (existing && !(rework && terminal(existing)))
             return { node: existing, duplicate: true };
-        }
-        if (requestBatchKey && target.groupId) {
-            const batch = this.children(parent.id).filter(n => n.requestBatchKey === requestBatchKey && n.groupId === target.groupId);
-            if (batch.some(n => n.text !== text || n.threadId !== target.threadId))
-                throw new Error("request_key was already used for different room work");
-            if (batch.some(n => n.startedAt !== undefined))
-                throw new Error("This shared room request has already started; use a new request_key for additional recipients");
-        }
         if (!rework && this.children(parent.id).some(n => n.kind === kind &&
             n.groupId === target.groupId && n.botId === target.botId && n.status === "completed")) {
             throw new Error("This agent already completed your assignment. Do not send acknowledgements or approvals as new work. Finish with your decision; results return automatically. Only use rework=true for concrete additional work.");

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { LiveSessionError, MAX_SDP_BYTES } from "../live-call.js";
+import { LiveCallBusyError } from "../live-call-controller.js";
+import { PASS } from "./table.js";
+const id = z.string().regex(/^[\w-]{1,120}$/);
+const sessionBody = z.object({
+    botId: id,
+    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"]),
+}).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.
+const settingsBody = z.object({
+    voice: z.string().trim().max(40).regex(/^[a-z]*$/).optional(),
+    readTypedReplies: z.boolean().optional(),
+    idleMinutes: z.number().int().min(1).max(60).optional(),
+}).strict();
+const DEVICE_ID = /^[\w-]{1,128}$/;
+/** The paired phone the companion vouched for, or undefined. The companion
+ * sends its own id for the phone that authenticated (never one the phone
+ * chose); in the desktop app the harness has already checked the companion's
+ * private token before this runs (server/request-auth.ts). */
+function companionDevice(req) {
+    if (req.headers["x-openmausbot-companion"] !== "1")
+        return undefined;
+    const device = req.headers["x-openmausbot-companion-device"];
+    return typeof device === "string" && DEVICE_ID.test(device) ? device : undefined;
+}
+/** The parsed JSON body, or undefined when it is not JSON (the schema then refuses it). */
+async function bodyOf(req, readBody) {
+    try {
+        return await readBody(req);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createLiveRoutes(deps) {
+    return async ({ req, res, path, method, auth, json, readBody }) => {
+        if (!path.startsWith("/api/live/"))
+            return PASS;
+        if (method === "POST" && path === "/api/live/session") {
+            const parsed = sessionBody.safeParse(await bodyOf(req, readBody));
+            if (!parsed.success)
+                return json(res, 400, { error: "The call request was not valid." });
+            const target = deps.resolveTarget(parsed.data.botId, parsed.data.threadId);
+            if (!target)
+                return json(res, 404, { error: "That bot or chat does not exist." });
+            try {
+                // A phone's call is bound to the phone, so unpairing it ends the call.
+                const device = companionDevice(req);
+                const { call, sdp } = await deps.calls.start({ auth, ...(device ? { device } : {}), ...target, client: parsed.data.client, sdp: parsed.data.sdp });
+                return json(res, 201, { call, transport: { type: "webrtc", sdp } });
+            }
+            catch (error) {
+                if (error instanceof LiveCallBusyError)
+                    return json(res, 409, { error: error.message, activeCall: error.call });
+                if (error instanceof LiveSessionError) {
+                    // The one 409 a session refuses with is a missing key.
+                    return json(res, error.status, error.status === 409 ? { error: error.message, needsKey: true } : { error: error.message });
+                }
+                throw error;
+            }
+        }
+        if (method === "POST" && path === "/api/live/call/end") {
+            const parsed = endBody.safeParse(await bodyOf(req, readBody));
+            if (!parsed.success)
+                return json(res, 400, { error: "The request was not valid." });
+            const call = await deps.calls.end(parsed.data.callId);
+            return call ? json(res, 200, { call }) : json(res, 404, { error: "That call is not running." });
+        }
+        if (method === "GET" && path === "/api/live/call")
+            return json(res, 200, { call: deps.calls.current() });
+        // The companion unpaired a phone: end the call that phone holds, if any.
+        if (method === "POST" && path === "/api/live/device-revoked") {
+            if (req.headers["x-openmausbot-companion"] !== "1")
+                return json(res, 403, { error: "Only the phone companion can report an unpaired phone." });
+            const device = companionDevice(req);
+            if (!device)
+                return json(res, 400, { error: "The unpaired phone was not named." });
+            return json(res, 200, { call: deps.calls.deviceRevoked(device) });
+        }
+        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." });
+            }
+            // as PUT /api/config: an empty patch is not saved (or broadcast)
+            if (!Object.keys(parsed.data).length)
+                return json(res, 400, { error: "nothing to save" });
+            return json(res, 200, { live: await deps.saveSettings(parsed.data) });
+        }
+        return PASS;
+    };
+}

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

@@ -677,7 +677,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" ? "Boat-hosted agent" : "Bot’s current model and configured computer";
+    const destination = definition.runOn === "cloud" ? "Bot’s current model on its Boat 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

@@ -1381,7 +1381,11 @@ export class RoutineManager {
             if (event.denials?.length)
                 run.denials = [...new Set([...(run.denials ?? []), ...event.denials])];
             if (!event.ok) {
-                this.failRun(run, event.stopReason ?? run.error ?? "The bot did not complete this run");
+                const genericStopReason = event.stopReason === "error" || event.stopReason === "tool_error";
+                this.failRun(run, (genericStopReason ? run.error : undefined) ??
+                    event.stopReason ??
+                    run.error ??
+                    "The bot did not complete this run");
                 queueMicrotask(() => void this.tick());
                 return cloneRun(run);
             }

package/dist-server/server/setup-mode.js

@@ -51,8 +51,6 @@ function buildSetupPrompt(profileAside, cwd) {
         " Full Access does not supply answers, credentials, or broader permissions for another bot. A credential request still needs the user's secure entry. Report failed or cancelled changes honestly." +
         " Finish by saying exactly what remains for the user to do by hand — authorizing an app or account (OAuth), creating a third-party application or bot token, or deciding a pending review — and point them to the Access section of the bot's settings for the app connections.");
 }
-/** The setup block naming skill_manage, for a turn with skill authoring on. */
-export const SETUP_PROMPT = buildSetupPrompt(SKILL_MANAGE_ASIDE);
 export function setupSystemPrompt(active, options) {
     if (!active)
         return "";

package/dist-server/server/skill-learn.js

@@ -6,7 +6,6 @@
 // prompt and recognises the slash command, so it works on every engine
 // that mounts the agents tools.
 import { SAVE_RUN_AS_SKILL_LINE } from "../shared/learn-request.js";
-export const LEARN_COMMAND = "/learn";
 export const LEARN_SOURCE_PREFIX = "learn:";
 export const LEARN_PROMPT_MARKER = "[/learn]";
 export const LEARN_DESCRIPTION_SOFT_MAX = 60;

package/dist-server/server/skill-library.js

@@ -4,6 +4,13 @@
 // declared trigger terms and mounted capabilities.
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join } from "node:path";
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { mkdirSync } from "node:fs";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+import { isSkillName, parseSkillMd, SKILL_FILE_MAX_BYTES } from "../shared/skill-md.js";
 const SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function strings(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim())
@@ -99,9 +106,6 @@ export function mergeSkills(bundled, user) {
     }
     return [...byId.values()];
 }
-export function skillInstructionsFor(text, capabilities, skills, options) {
-    return renderSkillInstructions(selectBundledSkills(text, capabilities, skills), options);
-}
 export function selectBundledSkills(text, capabilities, skills) {
     const haystack = text.toLowerCase();
     const available = new Set(capabilities);
@@ -114,3 +118,191 @@ export function renderSkillInstructions(selected, { includeRoot = false } = {})
         return "";
     return selected.map(({ manifest, instructions, directory }) => `\n\n<openmaus-skill id=${JSON.stringify(manifest.id)} version=${JSON.stringify(manifest.version)}${includeRoot ? ` root=${JSON.stringify(directory)}` : ""}>\n${instructions}\n</openmaus-skill>`).join("");
 }
+const skillLibraryEntrySchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    source: z.string(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    importedAt: z.string(),
+    reviewState: z.enum(["approved", "disabled"]),
+    license: z.string().optional(),
+    compatibility: z.string().optional(),
+    tags: z.array(z.string().regex(/^[a-z0-9][a-z0-9-]{0,23}$/)).max(8).optional(),
+    warnings: z.array(z.string()),
+    skippedFiles: z.array(z.string()),
+    package: z.object({
+        installId: z.string().regex(/^[a-f0-9]{32}$/),
+        key: z.string().min(1).max(64),
+        release: z.string().min(1).max(40),
+        r: z.string().regex(/^[a-f0-9]{64}$/),
+        w: z.string().regex(/^[a-f0-9]{64}$/),
+        via: z.literal("preset").optional(),
+    }).optional(),
+});
+const skillLibraryIndexSchema = z.record(z.string(), skillLibraryEntrySchema);
+/** Every library write emits here so later skills-lane consumers can drop
+ * caches without polling. The payload names what changed. */
+export const skillLibraryEvents = new EventEmitter();
+export function skillsLibraryRoot(dataDir = DATA_DIR) {
+    return join(dataDir, "skills-library");
+}
+function libraryIndexPath(root) {
+    return join(root, "index.json");
+}
+export function librarySkillDirectory(root, name) {
+    return join(root, "skills", name);
+}
+/** The path agents are told to read for an assigned library skill. */
+export function librarySkillFilePath(name, root = skillsLibraryRoot()) {
+    return join(root, "skills", name, "SKILL.md");
+}
+/** Where a migrated per-bot copy is preserved. Archives are write-once:
+ * migration never deletes the original bytes, it moves them here. */
+export function libraryArchiveDirectory(root, botId, name) {
+    return join(root, "archive", botId, name);
+}
+/** A missing index is a legitimate empty library; an index that exists but
+ * cannot be read or validated is not, and writers must refuse rather than
+ * replace it and strand every stored skill. */
+function readSkillLibraryIndexState(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(libraryIndexPath(root), "utf8"));
+        const result = skillLibraryIndexSchema.safeParse(parsed);
+        return result.success
+            ? { index: result.data }
+            : { error: "the skills library index is invalid" };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { index: {} };
+        return { error: "the skills library index could not be read" };
+    }
+}
+export function readSkillLibraryIndex(root = skillsLibraryRoot()) {
+    const result = readSkillLibraryIndexState(root);
+    return "error" in result ? {} : result.index;
+}
+function writeSkillLibraryIndex(root, index) {
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    writeFileAtomic(libraryIndexPath(root), `${JSON.stringify(index, null, 2)}\n`, { mode: 0o600 });
+}
+function sha256Hex(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+function libraryContentMatches(root, entry) {
+    try {
+        const file = join(librarySkillDirectory(root, entry.name), "SKILL.md");
+        if (!existsSync(file))
+            return false;
+        return sha256Hex(readFileSync(file, "utf8")) === entry.sha256;
+    }
+    catch {
+        return false;
+    }
+}
+function librarySkillListing(root, entry) {
+    const intact = libraryContentMatches(root, entry);
+    return {
+        name: entry.name,
+        description: entry.description,
+        enabled: entry.reviewState === "approved" && intact,
+        editable: false,
+        source: entry.source,
+        sha256: entry.sha256,
+        importedAt: entry.importedAt,
+        ...(entry.license ? { license: entry.license } : {}),
+        ...(entry.compatibility ? { compatibility: entry.compatibility } : {}),
+        tags: entry.tags ?? [],
+        warnings: intact
+            ? entry.warnings
+            : [...entry.warnings, "stored SKILL.md changed after review — enablement is blocked"],
+        skippedFiles: entry.skippedFiles,
+    };
+}
+export function listLibrarySkills(root = skillsLibraryRoot()) {
+    return Object.values(readSkillLibraryIndex(root))
+        .map((entry) => librarySkillListing(root, entry))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Put a skill in the library. Installing the same name with the same
+ * SKILL.md bytes is idempotent (the existing entry wins); the same name
+ * with different bytes is refused, mirroring the per-bot import rule.
+ * Every failure returns `{ error }` — callers fall back. */
+export function installLibrarySkill(input) {
+    const root = input.root ?? skillsLibraryRoot();
+    if (!isSkillName(input.name))
+        return { error: "invalid skill name" };
+    if (Buffer.byteLength(input.instructions, "utf8") > SKILL_FILE_MAX_BYTES) {
+        return { error: `SKILL.md is larger than ${SKILL_FILE_MAX_BYTES / 1024}KB` };
+    }
+    const parsed = parseSkillMd(input.instructions);
+    if ("error" in parsed)
+        return parsed;
+    if (parsed.name !== input.name)
+        return { error: `the skill is named "${parsed.name}", not "${input.name}"` };
+    const sha256 = sha256Hex(input.instructions);
+    const indexRead = readSkillLibraryIndexState(root);
+    if ("error" in indexRead)
+        return indexRead;
+    const index = indexRead.index;
+    const existing = index[input.name];
+    if (existing) {
+        if (existing.sha256 === sha256)
+            return librarySkillListing(root, existing);
+        return { error: `a skill named "${input.name}" is already in the library — choose a different name` };
+    }
+    // Callers such as the library migration do not pass tags; frontmatter
+    // tags parsed from the instructions are the source of record then.
+    const tags = input.tags?.length ? input.tags : parsed.tags;
+    const entry = {
+        name: input.name,
+        description: input.description?.trim() || parsed.description,
+        source: input.source,
+        sha256,
+        importedAt: new Date().toISOString(),
+        reviewState: input.reviewState ?? "disabled",
+        ...(input.license ? { license: input.license } : {}),
+        ...(input.compatibility ? { compatibility: input.compatibility } : {}),
+        ...(tags?.length ? { tags } : {}),
+        warnings: input.warnings ?? [],
+        skippedFiles: [],
+        ...(input.package ? { package: { ...input.package } } : {}),
+    };
+    // Bytes first, index second: the index is the commit point, so a crash
+    // between the two leaves unreferenced bytes, never a dangling entry.
+    mkdirSync(librarySkillDirectory(root, input.name), { recursive: true, mode: 0o700 });
+    writeFileAtomic(join(librarySkillDirectory(root, input.name), "SKILL.md"), input.instructions, { mode: 0o600 });
+    index[input.name] = entry;
+    writeSkillLibraryIndex(root, index);
+    skillLibraryEvents.emit("invalidate", { kind: "install", name: input.name });
+    return librarySkillListing(root, entry);
+}
+export function readLibrarySkillFile(name, root = skillsLibraryRoot()) {
+    if (!isSkillName(name))
+        return null;
+    const entry = readSkillLibraryIndex(root)[name];
+    if (!entry)
+        return null;
+    try {
+        const text = readFileSync(join(librarySkillDirectory(root, name), "SKILL.md"), "utf8");
+        return sha256Hex(text) === entry.sha256 ? text : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setLibrarySkillReviewState(name, reviewState, root = skillsLibraryRoot()) {
+    if (!isSkillName(name))
+        return { error: "invalid skill name" };
+    const index = readSkillLibraryIndex(root);
+    const entry = index[name];
+    if (!entry)
+        return { error: `no library skill named "${name}"` };
+    if (reviewState === "approved" && !libraryContentMatches(root, entry)) {
+        return { error: "stored SKILL.md changed after review — the library entry cannot be approved" };
+    }
+    entry.reviewState = reviewState;
+    writeSkillLibraryIndex(root, index);
+    skillLibraryEvents.emit("invalidate", { kind: "review-state", name });
+    return librarySkillListing(root, entry);
+}