openmausbot 0.1.84 → 0.1.85

package/dist-server/server/tool-results.js

@@ -0,0 +1,72 @@
+// Short-lived overflow for built-in agents tools, not another history store.
+// Authorize the live turn before using this cache; ownership is BOTH the bot
+// and conversation, so room speakers and sibling threads cannot share IDs.
+import { randomUUID } from "node:crypto";
+import { redactSecretsInText } from "../shared/redact.js";
+export const TOOL_RESULT_PREVIEW_CHARS = 16_000;
+export const TOOL_RESULT_MAX_CHARS = 128 * 1024;
+export const TOOL_RESULT_TTL_MS = 60 * 60_000;
+const MAX_RESULTS = 128;
+const MAX_RESULTS_PER_OWNER = 16;
+const MAX_BYTES = 16 * 1024 * 1024;
+const MAX_OWNER_BYTES = 2 * 1024 * 1024;
+export function toolResultPrefix(text, chars) {
+    const prefix = text.slice(0, chars);
+    const last = prefix.charCodeAt(prefix.length - 1);
+    return last >= 0xd800 && last <= 0xdbff ? prefix.slice(0, -1) : prefix;
+}
+/** Bounded in memory; lost on restart, expired after an hour, or evicted
+ * oldest-first under pressure. Reads do not extend retention. The transcript
+ * remains the durable record; this cache is only a way to page a large answer. */
+export class ToolResults {
+    results = new Map();
+    now;
+    constructor(now = Date.now) { this.now = now; }
+    expire() {
+        const now = this.now();
+        for (const [id, result] of this.results) {
+            if (result.expiresAt <= now)
+                this.results.delete(id);
+        }
+    }
+    save(owner, text, truncated = false) {
+        this.expire();
+        // Redact before taking the prefix, including a secret crossing its edge.
+        const redacted = redactSecretsInText(text);
+        const bounded = toolResultPrefix(redacted, TOOL_RESULT_MAX_CHARS);
+        const result = { botId: owner.botId, threadId: owner.threadId, text: bounded, bytes: Buffer.byteLength(bounded),
+            expiresAt: this.now() + TOOL_RESULT_TTL_MS, truncated: truncated || bounded.length < redacted.length };
+        const id = `r-${randomUUID()}`;
+        this.results.set(id, result);
+        // At most 129 entries are inspected here. Enforce the owner's limit
+        // before the global one so one noisy thread does not evict its neighbours.
+        for (const ownOnly of [true, false]) {
+            const entries = [...this.results].filter(([, entry]) => !ownOnly ||
+                (entry.botId === owner.botId && entry.threadId === owner.threadId));
+            let bytes = entries.reduce((sum, [, entry]) => sum + entry.bytes, 0);
+            let count = entries.length;
+            for (const [oldId, entry] of entries) {
+                if (bytes <= (ownOnly ? MAX_OWNER_BYTES : MAX_BYTES) && count <= (ownOnly ? MAX_RESULTS_PER_OWNER : MAX_RESULTS))
+                    break;
+                this.results.delete(oldId);
+                bytes -= entry.bytes;
+                count--;
+            }
+        }
+        return { id, length: bounded.length, truncated: result.truncated, expiresAt: result.expiresAt };
+    }
+    read(owner, id, offset) {
+        this.expire();
+        const result = this.results.get(id);
+        if (!result || result.botId !== owner.botId || result.threadId !== owner.threadId)
+            return null;
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset > result.text.length)
+            return null;
+        // A supplied offset may point to the low half of a surrogate pair.
+        const char = result.text.charCodeAt(offset);
+        const start = char >= 0xdc00 && char <= 0xdfff ? Math.max(0, offset - 1) : offset;
+        const text = toolResultPrefix(result.text.slice(start), TOOL_RESULT_PREVIEW_CHARS);
+        return { id, text, offset: start, nextOffset: start + text.length, length: result.text.length,
+            truncated: result.truncated, expiresAt: result.expiresAt };
+    }
+}

package/dist-server/server/tts/grok.js

@@ -0,0 +1,74 @@
+// xAI TTS runs on the harness and reuses the existing workspace xAI key.
+import { z } from "zod";
+const API = (process.env.OMB_XAI_TTS_API || "https://api.x.ai/v1").replace(/\/+$/, "");
+const voicesSchema = z.object({
+    voices: z.array(z.object({
+        voice_id: z.string().min(1),
+        name: z.string().min(1),
+        description: z.string().optional(),
+    })),
+});
+function refusal(status) {
+    if (status === 401 || status === 403)
+        return "xAI rejected the key or its TTS permissions. Check the xAI key in Settings.";
+    if (status === 402)
+        return "The xAI account needs credits to generate speech.";
+    if (status === 429)
+        return "xAI is rate-limiting speech. Wait a moment and try again.";
+    if (status === 404)
+        return "xAI could not find that voice. Refresh the voice list and select a voice again.";
+    return `Grok voice failed (HTTP ${status}). Try again later.`;
+}
+async function request(path, init) {
+    let response;
+    try {
+        response = await fetch(`${API}${path}`, { ...init, redirect: "error" });
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+            throw new Error("Grok voice timed out. Try again.");
+        }
+        throw new Error("Could not reach Grok voice. Check your connection.");
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        // Remote error bodies can echo credentials or request text.
+        throw new Error(refusal(response.status));
+    }
+    return response;
+}
+export async function listVoices(key) {
+    const response = await request("/tts/voices", {
+        headers: { authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(20_000),
+    });
+    const parsed = voicesSchema.safeParse(await response.json().catch(() => null));
+    if (!parsed.success)
+        throw new Error("Grok returned an invalid voice list. Try again later.");
+    return parsed.data.voices.map((voice) => ({
+        id: voice.voice_id, label: voice.name, description: voice.description,
+    }));
+}
+export async function synthesize(text, voiceId, key) {
+    const response = await request("/tts", {
+        method: "POST",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json", accept: "audio/mpeg" },
+        body: JSON.stringify({ text, voice_id: voiceId, language: "auto", output_format: { codec: "mp3" } }),
+        signal: AbortSignal.timeout(60_000),
+    });
+    const mime = (response.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+    if (mime !== "audio/mpeg" && mime !== "audio/mp3") {
+        await response.body?.cancel();
+        throw new Error("Grok returned an unexpected audio format. Try again later.");
+    }
+    let bytes;
+    try {
+        bytes = new Uint8Array(await response.arrayBuffer());
+    }
+    catch {
+        throw new Error("Grok audio download was interrupted. Try again.");
+    }
+    if (!bytes.byteLength)
+        throw new Error("Grok returned empty audio. Try again.");
+    return { bytes, mime: "audio/mpeg" };
+}

package/dist-server/server/tts/index.js

@@ -1,5 +1,6 @@
 import * as chatterbox from "./chatterbox.js";
 import * as elevenlabs from "./elevenlabs.js";
+import * as grok from "./grok.js";
 import * as fish from "./fish.js";
 import * as systemVoices from "./system-voices.js";
 export class NoVoiceConfigured extends Error {
@@ -17,13 +18,15 @@ export class NoVoiceConfigured extends Error {
 }
 export function voiceProvider(cfg) {
     const provider = cfg.tts?.provider;
-    return provider === "fish" || provider === "system" || provider === "chatterbox" ? provider : "elevenlabs";
+    return provider === "xai" || provider === "fish" || provider === "system" || provider === "chatterbox" ? provider : "elevenlabs";
 }
 /** The system provider needs no credential — it is only ever offered where
  * the platform actually has it, so "configured" means "this engine can
  * speak", not "a key is on file". */
 export function providerConfigured(cfg) {
     const provider = voiceProvider(cfg);
+    if (provider === "xai")
+        return Boolean(cfg.xai?.key);
     if (provider === "system")
         return systemVoices.systemVoicesAvailable();
     if (provider === "chatterbox")
@@ -34,6 +37,8 @@ export function providerConfigured(cfg) {
 }
 export function voiceConfigured(cfg) {
     const provider = voiceProvider(cfg);
+    if (provider === "xai")
+        return Boolean(cfg.xai?.key && cfg.tts?.voice);
     if (provider === "system") {
         return systemVoices.systemVoicesAvailable() && Boolean(cfg.tts?.voice);
     }
@@ -47,6 +52,8 @@ export function voiceConfigured(cfg) {
  * because the app-wide fallback has not been selected yet. */
 export function voiceReady(cfg, voiceId) {
     const provider = voiceProvider(cfg);
+    if (provider === "xai")
+        return Boolean(cfg.xai?.key && (voiceId || cfg.tts?.voice));
     if (provider === "system") {
         return systemVoices.systemVoicesAvailable() && Boolean(voiceId || cfg.tts?.voice);
     }
@@ -75,6 +82,8 @@ export function verifyKey(provider, key) {
 }
 export async function listVoices(cfg, run) {
     const provider = voiceProvider(cfg);
+    if (provider === "xai")
+        return cfg.xai?.key ? grok.listVoices(cfg.xai.key) : [];
     if (provider === "system")
         return systemVoices.listSystemVoices(run);
     if (provider === "chatterbox") {
@@ -94,6 +103,15 @@ export async function listVoices(cfg, run) {
  * to speak with, which the route turns into a 409 the client can explain. */
 export function speak(cfg, text, voiceId, run) {
     const provider = voiceProvider(cfg);
+    if (provider === "xai") {
+        const key = cfg.xai?.key;
+        if (!key)
+            throw new NoVoiceConfigured("key", "Add an xAI key in Settings to use Grok voice.");
+        const voice = voiceId || cfg.tts?.voice;
+        if (!voice)
+            throw new NoVoiceConfigured("voice");
+        return grok.synthesize(text, voice, key);
+    }
     if (provider === "system") {
         const voice = voiceId || cfg.tts?.voice;
         // An injected runner is the cross-platform test seam for `/usr/bin/say`;

package/dist-server/server/webhooks.js

@@ -12,12 +12,14 @@ const RATE_WINDOW_MS = 60_000;
 const RATE_LIMIT = 10;
 const MAX_PENDING_RUNS = 3;
 const runOnSchema = z.enum(["maus", "cloud"]);
+const deliverySchema = z.enum(["run", "post"]);
 const eventTypesSchema = z.array(z.string()).max(20).optional();
 const triggerInputSchema = z.object({
     name: z.string(),
     prompt: z.string(),
     botId: z.string(),
     runOn: runOnSchema.optional(),
+    delivery: deliverySchema.optional(),
     enabled: z.boolean().optional(),
     verificationPending: z.boolean().optional(),
     eventTypes: eventTypesSchema,
@@ -36,6 +38,7 @@ const storedWebhookSchema = z.object({
     prompt: z.string(),
     botId: z.string().min(1),
     runOn: runOnSchema,
+    delivery: deliverySchema.optional(),
     enabled: z.boolean(),
     createdAt: z.number().finite().nonnegative(),
     updatedAt: z.number().finite().nonnegative(),
@@ -120,6 +123,8 @@ function cleanInput(input) {
     };
     if (eventTypes.length)
         clean.eventTypes = eventTypes;
+    if (input.delivery)
+        clean.delivery = input.delivery;
     return clean;
 }
 function parseTriggerInput(value) {
@@ -256,6 +261,7 @@ export class WebhookManager {
             prompt: patch.prompt ?? trigger.prompt,
             botId: patch.botId ?? trigger.botId,
             runOn: patch.runOn ?? trigger.runOn,
+            delivery: patch.delivery ?? trigger.delivery,
             enabled: patch.enabled ?? trigger.enabled,
             verificationPending: patch.verificationPending ?? trigger.verificationPending,
             eventTypes: patch.eventTypes ?? trigger.eventTypes,
@@ -397,6 +403,28 @@ export class WebhookManager {
         recent.push(now);
         this.rate.set(trigger.endpointId, recent);
         const deliveryId = requestedDeliveryId || randomUUID();
+        // delivery:"post": the payload text becomes the bot's own chat message — no task,
+        // no model turn. For notification-style webhooks (a scheduled brief, an alert)
+        // that should read like the bot said it. Dedup/rate/attempt bookkeeping is shared.
+        if (trigger.delivery === "post") {
+            // Never fall through to a task run: a stored post webhook on a server
+            // without a post sink is a configuration error, not a run request.
+            if (!this.options.post)
+                fail(503, "This server cannot post webhook messages to chat");
+            const raw = event.payload;
+            const text = raw && typeof raw === "object" && typeof raw.text === "string" && raw.text.trim() ? raw.text : serializePayload(event.payload);
+            this.options.post(trigger.botId, text.slice(0, 20000));
+            this.deliveries.push({ key: `${trigger.endpointId}:${deliveryId}`, runId: "post", at: now });
+            if (this.deliveries.length > MAX_DELIVERIES)
+                this.deliveries.splice(0, this.deliveries.length - MAX_DELIVERIES);
+            trigger.lastReceivedAt = now;
+            trigger.deliveryCount += 1;
+            trigger.updatedAt = now;
+            this.appendAttempt(trigger, event, { outcome: "accepted", statusCode: 202, deliveryId, reason: "Posted to chat (no task run)" });
+            this.save();
+            this.emit(trigger);
+            return { deliveryId, duplicate: false };
+        }
         const run = this.options.enqueue({
             webhookId: trigger.id,
             webhookName: trigger.name,

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

@@ -15,7 +15,13 @@ export function supportsApprovalMode(driverKind, mode) {
         return ["claudeAgent", "grokAgent", "antigravityAgent", "qwenAgent", "geminiAgent"].includes(driverKind ?? "");
     if (mode !== "full")
         return true;
-    return ["codex", "claudeAgent", "antigravityAgent", "cursorAgent", "grokAgent", "opencodeGo", "qwenAgent", "geminiAgent"].includes(driverKind ?? "");
+    // The chat-completions family has no provider-side reviewer, so Full is
+    // implemented in the harness: createOpenAIChatRuntime answers its own tool
+    // gate instead of opening a card. Without this a bot on one of these
+    // engines could never stop asking — not by its own level, and not through
+    // a Chief's delegated Full access either.
+    return ["codex", "claudeAgent", "antigravityAgent", "cursorAgent", "grokAgent", "opencodeGo", "qwenAgent", "geminiAgent",
+        "openai-compat", "grok", "minimax"].includes(driverKind ?? "");
 }
 /** A Full/Custom grant belongs to one provider's tool semantics. Other
  * modes carry across only when the destination actually implements them.

package/dist-server/shared/digest.js

@@ -0,0 +1 @@
+export {};

package/dist-server/shared/markdown-windows-paths.js

@@ -0,0 +1,36 @@
+// Markdown reads a backslash before punctuation as an escape, so a bot's link
+// to C:\Users\me\.openmausbot\report.md parsed as C:\Users\me.openmausbot\report.md:
+// the separator before ".openmausbot" (the default data folder on Windows),
+// "_drafts" or "-old" was dropped and the link named a file that isn't there.
+// In a link, image or definition destination that starts with a drive letter,
+// such a backslash stays a path separator. "\\" and the destination's own
+// delimiters "\(", "\)", "\<" and "\>" still escape, so a destination whose
+// backslashes were already escaped reads as before. The server authorizes a
+// file by the target it parses and the client sends the target it rendered,
+// so both parse with this extension.
+const destinations = new WeakSet();
+const DRIVE = /^[A-Za-z]:(?:[\\/]|$)/;
+const STILL_ESCAPES = new Set(["\\", "(", ")", "<", ">"]);
+function enterDestination() {
+    this.buffer();
+    destinations.add(this.stack[this.stack.length - 1]);
+}
+function exitCharacterEscapeValue(token) {
+    // The text node `characterEscape` opened, as mdast's own data handler pops it.
+    const tail = this.stack.pop();
+    const value = this.sliceSerialize(token);
+    const separator = destinations.has(this.stack[this.stack.length - 1])
+        && DRIVE.test(tail.value)
+        && !STILL_ESCAPES.has(value);
+    tail.value += separator ? `\\${value}` : value;
+    tail.position.end = { line: token.end.line, column: token.end.column, offset: token.end.offset };
+}
+export const windowsPathDestinations = {
+    enter: {
+        resourceDestinationString: enterDestination,
+        definitionDestinationString: enterDestination,
+    },
+    exit: {
+        characterEscapeValue: exitCharacterEscapeValue,
+    },
+};

package/dist-server/shared/provider-icon.js

@@ -0,0 +1,110 @@
+export const PROVIDER_ICON_PRESETS = [
+    "openai", "anthropic", "google", "azure", "aws", "xai", "deepseek",
+    "meta", "mistral", "qwen", "moonshot", "cohere", "openrouter",
+];
+export const PROVIDER_ICON_MAX_BYTES = 128 * 1024;
+export const PROVIDER_ICON_MAX_DIMENSION = 1024;
+export const PROVIDER_ICON_MEDIA_TYPES = ["image/png", "image/jpeg", "image/webp"];
+export const PROVIDER_ICON_LABELS = {
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    google: "Google Gemini",
+    azure: "Microsoft Azure",
+    aws: "Amazon Bedrock (AWS)",
+    xai: "xAI",
+    deepseek: "DeepSeek",
+    meta: "Meta",
+    mistral: "Mistral AI",
+    qwen: "Qwen",
+    moonshot: "Moonshot AI",
+    cohere: "Cohere",
+    openrouter: "OpenRouter",
+};
+function decodedBase64Bytes(value) {
+    const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    return Math.floor(value.length * 3 / 4) - padding;
+}
+function imageDimensions(bytes, mime) {
+    const u16be = (offset) => bytes[offset] * 256 + bytes[offset + 1];
+    const u16le = (offset) => bytes[offset] + bytes[offset + 1] * 256;
+    const u24le = (offset) => bytes[offset] + bytes[offset + 1] * 256 + bytes[offset + 2] * 65536;
+    const u32le = (offset) => bytes[offset] + bytes[offset + 1] * 0x100 + bytes[offset + 2] * 0x10000 + bytes[offset + 3] * 0x1000000;
+    const u32be = (offset) => bytes[offset] * 0x1000000 + bytes[offset + 1] * 0x10000 + bytes[offset + 2] * 0x100 + bytes[offset + 3];
+    if (mime === "image/png") {
+        if (bytes.length < 33 || bytes.slice(0, 8).join(",") !== "137,80,78,71,13,10,26,10" ||
+            String.fromCharCode(...bytes.slice(12, 16)) !== "IHDR" ||
+            bytes.slice(-8).join(",") !== "73,69,78,68,174,66,96,130")
+            return null;
+        return { width: u32be(16), height: u32be(20) };
+    }
+    if (mime === "image/jpeg") {
+        if (bytes.length < 12 || bytes[0] !== 0xff || bytes[1] !== 0xd8 || bytes.at(-2) !== 0xff || bytes.at(-1) !== 0xd9)
+            return null;
+        for (let offset = 2; offset + 8 < bytes.length;) {
+            if (bytes[offset] !== 0xff) {
+                offset += 1;
+                continue;
+            }
+            const marker = bytes[offset + 1];
+            if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+                return { height: u16be(offset + 5), width: u16be(offset + 7) };
+            }
+            if (marker === 0xd8 || marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+                offset += 2;
+                continue;
+            }
+            const length = u16be(offset + 2);
+            if (length < 2)
+                return null;
+            offset += length + 2;
+        }
+        return null;
+    }
+    if (bytes.length < 30 || String.fromCharCode(...bytes.slice(0, 4)) !== "RIFF" ||
+        String.fromCharCode(...bytes.slice(8, 12)) !== "WEBP" || u32le(4) + 8 !== bytes.length)
+        return null;
+    const format = String.fromCharCode(...bytes.slice(12, 16));
+    if (format === "VP8X")
+        return { width: u24le(24) + 1, height: u24le(27) + 1 };
+    if (format === "VP8L" && bytes[20] === 0x2f) {
+        const bits = bytes[21] | bytes[22] << 8 | bytes[23] << 16 | bytes[24] << 24;
+        return { width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1 };
+    }
+    if (format === "VP8 " && bytes[23] === 0x9d && bytes[24] === 0x01 && bytes[25] === 0x2a) {
+        return { width: u16le(26) & 0x3fff, height: u16le(28) & 0x3fff };
+    }
+    return null;
+}
+/** Validate the complete persisted value. Custom images are local data URLs,
+ * never remote URLs, and use magic bytes so a forged MIME label is rejected. */
+export function providerIconError(icon) {
+    if (icon.kind === "preset") {
+        return PROVIDER_ICON_PRESETS.includes(icon.preset)
+            ? null : "Choose a supported provider icon.";
+    }
+    const match = /^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(icon.dataUrl);
+    if (!match)
+        return "Upload a PNG, JPEG, or WebP image.";
+    const byteLength = decodedBase64Bytes(match[2]);
+    if (byteLength > PROVIDER_ICON_MAX_BYTES) {
+        return "Provider icons must be 128 KB or smaller.";
+    }
+    let decoded;
+    try {
+        decoded = atob(match[2]);
+    }
+    catch {
+        return "The uploaded image is not valid base64.";
+    }
+    if (decoded.length !== byteLength)
+        return "The uploaded image is not valid base64.";
+    const bytes = Uint8Array.from(decoded, (value) => value.charCodeAt(0));
+    const dimensions = imageDimensions(bytes, match[1]);
+    if (!dimensions)
+        return "The uploaded image is incomplete or does not match its file type.";
+    if (dimensions.width < 1 || dimensions.height < 1 || dimensions.width > PROVIDER_ICON_MAX_DIMENSION ||
+        dimensions.height > PROVIDER_ICON_MAX_DIMENSION || dimensions.width * dimensions.height > PROVIDER_ICON_MAX_DIMENSION ** 2) {
+        return `Provider icons must be at most ${PROVIDER_ICON_MAX_DIMENSION} × ${PROVIDER_ICON_MAX_DIMENSION} pixels.`;
+    }
+    return null;
+}

package/dist-server/shared/team-backup.js

@@ -20,6 +20,9 @@ const task = z.object({
     key,
     title: z.string().max(2_000),
     createdAt: timestamp,
+    // Travels only when the first message already named this task, so a
+    // restore cannot re-arm one generated title on a row that used it.
+    titleFromFirstMessage: z.literal(true).optional(),
     openedBy: z.object({ botId: key, name, at: timestamp, kind: z.enum(["pair", "work"]).optional() }).optional(),
     closedBy: z.object({ botId: key, name, at: timestamp }).optional(),
     activeLeafId: key.nullable(),