openmausbot 0.1.97 → 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/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/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-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/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/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)
@@ -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/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 {