openmausbot 0.1.86 → 0.1.87

package/dist-server/server/computer-wait.js

@@ -7,8 +7,17 @@
 // that, name the holder as a bot running a thread, and keep the same words
 // on every surface (chat chip, room chip, the gate's refusal) so a person
 // who has read it once recognises it everywhere.
-/** Whole minutes, or seconds under one minute, for the give-up notice. */
-const minutes = (ms) => ms >= 60_000 ? `${Math.round(ms / 60_000)} minutes` : `${Math.round(ms / 1000)} seconds`;
+/** Whole minutes, or seconds under one minute, singular at exactly one. */
+const minutes = (ms) => {
+    const value = ms >= 60_000 ? Math.round(ms / 60_000) : Math.round(ms / 1000);
+    const unit = ms >= 60_000 ? "minute" : "second";
+    return `${value} ${unit}${value === 1 ? "" : "s"}`;
+};
+/** How long a wait lasted, for the resolution line: waits under a second
+ * are honest about being over in a blink instead of claiming "0 seconds". */
+export function computerWaitDuration(ms) {
+    return ms < 1_000 ? "under a second" : minutes(ms);
+}
 const holderPhrase = (holder) => holder.task ? `${holder.name} is running ${holder.task}` : `${holder.name} is using it`;
 /** The chip a turn shows while it is queued behind another turn's desktop. */
 export function computerWaitingText(holder) {
@@ -16,14 +25,18 @@ export function computerWaitingText(holder) {
         return "Waiting for its turn on this computer. Starts automatically when it is free.";
     return `Waiting for its turn on this computer — ${holderPhrase(holder)}. Starts automatically when that finishes.`;
 }
-/** The same chip once the wait landed and this turn holds the desktop. */
-export function computerFreeText() {
-    return "Computer free — continuing";
+/** The resolution appended once the wait landed and this turn holds the
+ * desktop: how long it waited, and who held it. The waiting chip stays as
+ * written — this line is the history beside it, not its replacement. */
+export function computerFreeAfterText(holder, waitedMs) {
+    const who = holder ? ` (${holder.task ? `${holder.name} · ${holder.task}` : holder.name} held it)` : "";
+    return `Computer free — continuing after waiting ${computerWaitDuration(waitedMs)}${who}`;
 }
-/** The same chip when the wait ended without the desktop: the turn was
- * stopped, or the claim was abandoned. */
-export function computerWaitEndedText() {
-    return "Stopped waiting for the computer";
+/** The resolution appended when the wait ended because the turn was stopped
+ * or its claim was cancelled. */
+export function computerStoppedWaitingText(holder, waitedMs) {
+    const who = holder ? ` — ${holderPhrase(holder)}` : "";
+    return `Stopped waiting for the computer after ${computerWaitDuration(waitedMs)}${who}.`;
 }
 /** The error after the wait ceiling: still names who holds it, and says
  * what a person can do — stop that turn, or move this one. */

package/dist-server/server/config.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
+import { newBotDefaultsSchema } from "./new-bot-defaults.js";
 import { EFFORT_LEVELS } from "../shared/wire.js";
 import { isModelVariant } from "./contracts.js";
 import { PROVIDER_ICON_PRESETS, providerIconError } from "../shared/provider-icon.js";
@@ -289,8 +290,8 @@ const instanceConfigSchema = z.object({
 });
 const instanceConfigMapSchema = z.record(z.string(), instanceConfigSchema);
 const defaultModelSelectionSchema = z.object({
-    instanceId: z.string().trim().min(1),
-    model: z.string().trim().min(1),
+    instanceId: z.string().trim().min(1).max(200),
+    model: z.string().trim().min(1).max(500),
     effort: z.enum(EFFORT_LEVELS).optional(),
     variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
 }).refine((selection) => selection.variant === undefined || selection.effort === undefined, "choose either a model variant or an effort level");
@@ -303,6 +304,15 @@ const threadsConfigSchema = z.object({
      * Absent keeps them forever. */
     eventLogRetentionDays: z.number().int().min(1).max(3650).optional(),
 }).strict();
+/** Workspace-wide defaults every new bot starts with (Store.createBot). */
+const newBotsConfigSchema = z.object({
+    /** Effort for a new bot whose model selection names none. */
+    effort: z.enum(EFFORT_LEVELS).optional(),
+}).strict();
+/** PATCH newBots: null clears a default back to absent (no level is sent). */
+const newBotsPatchSchema = z.object({
+    effort: newBotsConfigSchema.shape.effort.nullable(),
+}).strict();
 /** PATCH threads: every knob is independently patchable, and null clears an
  * event-log knob back to its absent (off) default. */
 const threadsPatchSchema = threadsConfigSchema.extend({
@@ -317,12 +327,15 @@ const appConfigSchema = z.object({
      * addresses or `@domain` entries; admins get every scope, members chat only. */
     signIn: z.object({ admins: z.array(z.string().max(320)).max(500).optional(), members: z.array(z.string().max(320)).max(5000).optional() }).optional(),
     defaultModelSelection: defaultModelSelectionSchema.optional(),
+    newBotDefaults: newBotDefaultsSchema.optional(),
+    newBots: newBotsConfigSchema.optional(),
     /** CLI-only launch preferences. Never enable remote access implicitly. */
     cliStartup: z.object({
         access: z.enum(["local", "tunnel", "tailscale", "public-url"]),
         publicUrl: z.string().url().optional(),
         phone: z.enum(["ios", "android"]).optional(),
     }).optional(),
+    mistral: z.object({ key: optionalText }).optional(),
     xai: z.object({ key: optionalText, url: optionalText }).optional(),
     /** Anthropic API key for Claude Code billed per token, handed only to
      * Claude instances; `url` only for a proxy or a test double. Never a
@@ -400,8 +413,8 @@ const appConfigSchema = z.object({
         }).optional(),
         customModel: z.string().trim().max(200).refine((value) => !["\r", "\n", "\0"].some((character) => value.includes(character)), "Use a model ID without control characters").optional(),
     }).optional(),
-    /** Non-secret profile details shown in the sidebar. */
-    profile: z.object({ name: optionalText, email: optionalText }).optional(),
+    /** Non-secret profile details; aboutMe is shared with every bot. */
+    profile: z.object({ name: optionalText, email: optionalText, aboutMe: z.string().max(24_000).optional() }).optional(),
     /** UI language override (BCP-47, lowercase). Empty/absent = follow the
      * system language. Unknown tags degrade to English in the renderer. */
     language: optionalText,
@@ -432,7 +445,7 @@ const storedAppConfigSchema = appConfigSchema.extend({
     browserProfiles: storedBrowserProfilesSchema.optional(),
 });
 const appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true })
-    .extend({ threads: threadsPatchSchema.optional() });
+    .extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() });
 const jsonObjectSchema = z.record(z.string(), z.json());
 /** Resolve a canonical profile record to its exact durable Electron
  * partition identity. Callers must never substitute the display/API id. */
@@ -685,6 +698,9 @@ export function loadConfig() {
     // Anything that saves a credential mid-session must keep process.env in
     // step (syncCredentialEnv below), or the value injected at boot would
     // shadow the save until the next launch.
+    cfg.mistral = { ...cfg.mistral };
+    if (process.env.MISTRAL_API_KEY !== undefined)
+        cfg.mistral.key = process.env.MISTRAL_API_KEY;
     cfg.xai = { ...cfg.xai };
     if (process.env.XAI_API_KEY !== undefined)
         cfg.xai.key = process.env.XAI_API_KEY;
@@ -746,6 +762,7 @@ export function loadConfig() {
 export function syncCredentialEnv(patch) {
     const secrets = [
         [patch.xai?.key, "XAI_API_KEY"],
+        [patch.mistral?.key, "MISTRAL_API_KEY"],
         [patch.anthropic?.key, "OMB_ANTHROPIC_API_KEY"],
         [patch.openaiCompat?.key, "OPENAI_COMPAT_API_KEY"],
         [patch.composio?.apiKey, "COMPOSIO_API_KEY"],
@@ -788,6 +805,7 @@ export function syncCredentialEnv(patch) {
  * child these are someone else's keys riding along in `...process.env`. */
 export const WORKSPACE_CREDENTIAL_ENV = [
     "XAI_API_KEY",
+    "MISTRAL_API_KEY",
     "OMB_ANTHROPIC_API_KEY",
     "OMB_ANTHROPIC_API_URL",
     "OMB_HOSTED_MODEL_TOKEN",
@@ -850,6 +868,7 @@ export const PROVIDER_CREDENTIAL_ENV = [
     "OPENAI_API_KEY",
     "OPENCODE_API_KEY",
     "XAI_API_KEY",
+    "MISTRAL_API_KEY",
     "CURSOR_API_KEY",
     "CURSOR_AUTH_TOKEN",
 ];
@@ -874,7 +893,7 @@ export function saveConfig(patch, options = {}) {
     catch {
         /* first write */
     }
-    const checkedPatch = appConfigSchema.partial().extend({ threads: threadsPatchSchema.optional() }).parse(patch);
+    const checkedPatch = appConfigSchema.partial().extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() }).parse(patch);
     const before = configSaveListeners.size ? structuredClone(disk) : disk;
     // A write is the durable migration point. Preserve every other raw key in
     // config.json, but never write #567's mixed-case or duplicate profile ids
@@ -882,7 +901,7 @@ export function saveConfig(patch, options = {}) {
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "anthropic", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "threads", "context", "localVm", "features", "budgets", "billing", "decisions", "onboarding", "browserEngine"]) {
+    for (const key of ["xai", "anthropic", "mistral", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "threads", "context", "localVm", "features", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
@@ -894,8 +913,9 @@ export function saveConfig(patch, options = {}) {
         if (key === "threads" && !current.success)
             merged.maxConcurrentPerBot = DEFAULT_MAX_CONCURRENT_BOT_THREADS;
         Object.assign(merged, section);
-        // null is the patch's explicit "remove this key" marker (today only the
-        // threads event-log knobs use it); a key the patch omits keeps its value.
+        // null is the patch's explicit "remove this key" marker (the threads
+        // event-log knobs and newBots.effort use it); a key the patch omits
+        // keeps its value.
         for (const [sectionKey, sectionValue] of Object.entries(section)) {
             if (sectionValue === null)
                 delete merged[sectionKey];
@@ -915,6 +935,24 @@ export function saveConfig(patch, options = {}) {
     // an effort level omitted from the new selection.
     if (checkedPatch.defaultModelSelection !== undefined) {
         disk.defaultModelSelection = checkedPatch.defaultModelSelection;
+        if (disk.newBotDefaults) {
+            const previousDefaults = newBotDefaultsSchema.parse(disk.newBotDefaults);
+            disk.newBotDefaults = newBotDefaultsSchema.parse({
+                ...previousDefaults,
+                profile: { ...previousDefaults.profile, modelSelection: checkedPatch.defaultModelSelection },
+            });
+        }
+    }
+    // Replace the complete template so clearing a field, file or routine
+    // cannot revive an old value through the general section merge above.
+    if (checkedPatch.newBotDefaults !== undefined) {
+        disk.newBotDefaults = checkedPatch.newBotDefaults;
+        if (checkedPatch.newBotDefaults.profile.modelSelection) {
+            disk.defaultModelSelection = checkedPatch.newBotDefaults.profile.modelSelection;
+        }
+        else {
+            delete disk.defaultModelSelection;
+        }
     }
     if (checkedPatch.cliStartup !== undefined)
         disk.cliStartup = checkedPatch.cliStartup;
@@ -938,6 +976,14 @@ export function saveConfig(patch, options = {}) {
         if (routingConflict)
             throw Object.assign(new Error(routingConflict), { status: 409 });
         disk.browserProfiles = nextProfiles;
+        if (disk.newBotDefaults) {
+            const defaults = newBotDefaultsSchema.parse(disk.newBotDefaults);
+            const profileId = defaults.profile.browserProfile;
+            if (profileId && profileId !== "guest" && !nextProfiles.some(profile => profile.id === profileId)) {
+                delete defaults.profile.browserProfile;
+                disk.newBotDefaults = defaults;
+            }
+        }
     }
     if (checkedPatch.instances) {
         const currentInstances = jsonObjectSchema.safeParse(disk.instances);
@@ -1046,6 +1092,8 @@ export function persistableInstanceConfigs(cfg) {
  * environment of an unrelated child process. */
 function injectedEnvironment(cfg, driver) {
     const environment = new Map();
+    if (driver === "mistral" && cfg.mistral?.key)
+        environment.set("MISTRAL_API_KEY", cfg.mistral.key);
     if (driver === "grok" && cfg.xai?.key)
         environment.set("XAI_API_KEY", cfg.xai.key);
     // The workspace Anthropic key reaches Claude Code as the variable it
@@ -1096,6 +1144,7 @@ export function instanceConfigs(cfg) {
         opencodeGo: { driver: "opencodeGo" },
         computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
+        mistral: { driver: "mistral" },
         qwen: { driver: "qwenAgent" },
         hermes: { driver: "hermesAgent" },
         pi: { driver: "piAgent" },
@@ -1111,6 +1160,7 @@ export function instanceConfigs(cfg) {
     const PRODUCT_FLEET_ADDITIONS = {
         cursor: { driver: "cursorAgent" },
         openaiCompat: { driver: "openai-compat" },
+        mistral: { driver: "mistral" },
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;

package/dist-server/server/connector-verdict.js

@@ -0,0 +1,141 @@
+// The harness-side verdict for connected-app tool calls (issue #1736, part
+// of the per-bot Composio tool grants umbrella #1734).
+//
+// Every Composio tool call crosses POST /api/internal/connectors/mcp: the
+// provider CLIs talk to the stdio bridge, and the bridge forwards each
+// JSON-RPC frame there. So the grants verdict lives on the harness side,
+// where the loopback token already names the bot and the decision log is
+// native — the bridge never sees a key it could have to enforce with.
+//
+// Three shapes reach this module:
+//
+//   * a direct per-toolkit call — params.name is the tool itself, e.g.
+//     GMAIL_SEND_EMAIL;
+//   * the executor meta-tool — COMPOSIO_MULTI_EXECUTE_TOOL, whose
+//     arguments name one or many target tools;
+//   * everything else — connection cards, discovery, notifications —
+//     which passes through untouched (advertisement filtering is slice 3).
+//
+// Unrecognized argument shapes are denied by default: a call whose target
+// tools cannot be read is a call whose tools cannot be checked, and the
+// grants promise — "this bot may call exactly these tools" — must hold
+// even against a model that garbles the protocol.
+import { CONNECTOR_TOOL_NAME_PATTERN } from "../shared/wire.js";
+/** The executor meta-tool: the only meta-tool whose arguments name target
+ * tools. Discovery and connection meta-tools keep their existing flows. */
+export const COMPOSIO_MULTI_EXECUTE_TOOL = "COMPOSIO_MULTI_EXECUTE_TOOL";
+/** The service a Composio tool name belongs to: the upper-snake prefix
+ * before the first underscore, lowercased (GMAIL_SEND_EMAIL to gmail). A
+ * name with no underscore names no service, so no grant can cover it. */
+export function serviceSlugFor(tool) {
+    const underscore = tool.indexOf("_");
+    if (underscore <= 0)
+        return null;
+    return tool.slice(0, underscore).toLowerCase();
+}
+/** Classify one relayed JSON-RPC frame. Anything that is not a tools/call,
+ * or is a discovery/connection/platform meta-tool, passes through. */
+export function connectorCallFromFrame(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return { kind: "passthrough" };
+    const frame = payload;
+    if (frame.method !== "tools/call")
+        return { kind: "passthrough" };
+    const params = frame.params;
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+        return { kind: "unrecognized", invoked: "tools/call", reason: "the call carried no params object" };
+    }
+    const name = params.name;
+    if (typeof name !== "string" || !name) {
+        return { kind: "unrecognized", invoked: "tools/call", reason: "the call named no tool" };
+    }
+    if (name === COMPOSIO_MULTI_EXECUTE_TOOL) {
+        return multiExecuteCall(name, params.arguments);
+    }
+    // Platform meta-tools (search, schemas, remote workbench) are not
+    // connected-app tools; grants are keyed by service slug, and slice 3
+    // owns what the model is even shown.
+    if (name.startsWith("COMPOSIO_"))
+        return { kind: "passthrough" };
+    // Per-service connection cards keep their card flow in any spelling.
+    if (name.endsWith("_MANAGE_CONNECTIONS") || name.endsWith("_WAIT_FOR_CONNECTIONS")) {
+        return { kind: "passthrough" };
+    }
+    if (!CONNECTOR_TOOL_NAME_PATTERN.test(name)) {
+        return { kind: "unrecognized", invoked: name, reason: "the tool name is not a Composio tool name" };
+    }
+    return { kind: "tools", invoked: name, names: [name] };
+}
+/** Read the target tools out of COMPOSIO_MULTI_EXECUTE_TOOL arguments:
+ * the upstream schema is a 1-50 item tools array of { tool_slug,
+ * arguments }; a legacy single { tool_slug } object is accepted too.
+ * Anything else cannot be checked, so it is denied. */
+function multiExecuteCall(invoked, args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        return { kind: "unrecognized", invoked, reason: "the arguments were not an object" };
+    }
+    const tools = args.tools;
+    const singleSlug = args.tool_slug;
+    if (Array.isArray(tools)) {
+        if (tools.length === 0) {
+            return { kind: "unrecognized", invoked, reason: "the tools list was empty" };
+        }
+        const names = [];
+        for (const item of tools) {
+            const slug = item && typeof item === "object" && !Array.isArray(item)
+                ? item.tool_slug
+                : undefined;
+            if (typeof slug !== "string" || !slug) {
+                return { kind: "unrecognized", invoked, reason: "an entry in the tools list named no tool_slug" };
+            }
+            names.push(slug);
+        }
+        return { kind: "tools", invoked, names };
+    }
+    if (typeof singleSlug === "string" && singleSlug) {
+        return { kind: "tools", invoked, names: [singleSlug] };
+    }
+    return { kind: "unrecognized", invoked, reason: "the arguments named no tools to execute" };
+}
+/** Judge distinct target names against a bot's grants. grants undefined
+ * is the legacy all-tools bot and passes everything; an explicit record —
+ * including the empty one — allows only what it names. */
+export function evaluateConnectorTools(names, grants) {
+    if (grants === undefined) {
+        return { allowed: true, legacy: true, denials: [], rule: "composio" };
+    }
+    const denials = [];
+    let rule = "";
+    for (const tool of new Set(names)) {
+        const service = serviceSlugFor(tool);
+        const grant = service === null ? undefined : grants[service];
+        if (grant && (grant.tools === "*" || grant.tools.includes(tool))) {
+            if (!rule)
+                rule = "connectorTools." + service;
+            continue;
+        }
+        denials.push({ tool, service, onGrantedService: Boolean(grant) });
+    }
+    return { allowed: denials.length === 0, legacy: false, denials, rule };
+}
+/** Safe to hand straight to the model: names the refused tool and says who
+ * can change it. It never lists what the bot could have called instead —
+ * a refusal that enumerates adjacent grants teaches the model to probe. */
+export function connectorRefusalText(denials) {
+    const named = denials.map((denial) => '"' + denial.tool + '"').join(", ");
+    const one = denials.length === 1;
+    return [
+        named + " " + (one ? "is" : "are") + " not granted to this bot.",
+        "This call was not performed.",
+        "Ask the person to grant " + (one ? "it" : "these tools") + " in OpenMausBot if they want " + (one ? "it" : "them") + " run.",
+    ].join(" ");
+}
+/** The unrecognized-shape refusal: names the meta-tool and what could not
+ * be read, and still points at the person rather than at any tool list. */
+export function connectorUnrecognizedText(invoked, reason) {
+    return [
+        "A " + invoked + " call arrived in a shape OpenMausBot could not read (" + reason + "), so it was not performed.",
+        "Send a well-formed call that names the tools to execute.",
+        "Ask the person to grant any tool this bot needs.",
+    ].join(" ");
+}

package/dist-server/server/container-computer.js

@@ -310,7 +310,7 @@ function statusProblem(status) {
     if (status.security === "unsafe")
         return "The existing Local VM is missing safety limits; recreate it";
     if (status.persistence === "unsafe")
-        return "The existing Local VM is missing its durable workspace; recreate it";
+        return "The existing Local VM is missing its durable folder; recreate it";
     if (status.container === "stopped")
         return "This desktop image cannot safely resume; recreate the Local VM";
     if (status.desktop_error)

package/dist-server/server/default-model-selection.js

@@ -37,3 +37,12 @@ export function selectDefaultModelSelection(instances, preferred, context = {})
     }
     return { instanceId: pick?.instanceId ?? "", model: pick?.models.default ?? "" };
 }
+/** Complete a new bot's selection with the workspace's new-bot effort. An
+ * explicit effort or model variant is the caller's choice and wins; an engine
+ * that does not offer the level keeps sending none rather than failing turn 1. */
+export function withNewBotEffort(selection, effort, offered) {
+    if (!effort || selection.effort !== undefined || selection.variant !== undefined || !offered?.includes(effort)) {
+        return selection;
+    }
+    return { ...selection, effort };
+}