openmausbot 0.1.77 → 0.1.79

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

@@ -1,3 +1,4 @@
+import * as chatterbox from "./chatterbox.js";
 import * as elevenlabs from "./elevenlabs.js";
 import * as systemVoices from "./system-voices.js";
 export class NoVoiceConfigured extends Error {
@@ -5,52 +6,73 @@ export class NoVoiceConfigured extends Error {
     // runs under `node --experimental-strip-types`, which is strip-ONLY, so a
     // parameter property is rejected at load time even though it typechecks
     reason;
-    constructor(reason) {
-        super(reason === "key"
-            ? "Add an ElevenLabs key in Settings on the computer to turn on voice."
-            : "Pick a voice in the agent profile.");
+    constructor(reason, hint) {
+        super(hint ??
+            (reason === "key"
+                ? "Add an ElevenLabs key in Settings on the computer to turn on voice."
+                : "Pick a voice in the agent profile."));
         this.reason = reason;
     }
 }
 export function voiceProvider(cfg) {
-    return cfg.tts?.provider === "system" ? "system" : "elevenlabs";
+    return cfg.tts?.provider === "system" || cfg.tts?.provider === "chatterbox" ? cfg.tts.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) {
-    return voiceProvider(cfg) === "system" ? systemVoices.systemVoicesAvailable() : Boolean(cfg.tts?.key);
+    const provider = voiceProvider(cfg);
+    if (provider === "system")
+        return systemVoices.systemVoicesAvailable();
+    if (provider === "chatterbox")
+        return Boolean(cfg.tts?.baseUrl?.trim());
+    return Boolean(cfg.tts?.key);
 }
 export function voiceConfigured(cfg) {
-    if (voiceProvider(cfg) === "system") {
+    const provider = voiceProvider(cfg);
+    if (provider === "system") {
         return systemVoices.systemVoicesAvailable() && Boolean(cfg.tts?.voice);
     }
+    if (provider === "chatterbox")
+        return Boolean(cfg.tts?.baseUrl?.trim() && cfg.tts?.voice);
     return Boolean(cfg.tts?.key && cfg.tts?.voice);
 }
 /** A per-bot voice is a complete choice too; it should not be blocked just
  * because the app-wide fallback has not been selected yet. */
 export function voiceReady(cfg, voiceId) {
-    if (voiceProvider(cfg) === "system") {
+    const provider = voiceProvider(cfg);
+    if (provider === "system") {
         return systemVoices.systemVoicesAvailable() && Boolean(voiceId || cfg.tts?.voice);
     }
+    if (provider === "chatterbox")
+        return Boolean(cfg.tts?.baseUrl?.trim() && (voiceId || cfg.tts?.voice));
     return Boolean(cfg.tts?.key && (voiceId || cfg.tts?.voice));
 }
 /** What the settings panel needs. Never includes the key — same write-only
- * rule as every other credential. */
+ * rule as every other credential. baseUrl and model are Chatterbox
+ * settings, not credentials, so they come back in full. */
 export function describeVoice(cfg) {
+    const provider = voiceProvider(cfg);
     return {
         configured: providerConfigured(cfg),
         ready: voiceConfigured(cfg),
         voice: cfg.tts?.voice ?? "",
-        provider: voiceProvider(cfg),
+        provider,
+        baseUrl: provider === "chatterbox" ? (cfg.tts?.baseUrl ?? "") : "",
+        model: provider === "chatterbox" ? (cfg.tts?.model ?? "") : "",
     };
 }
 export function verifyKey(key) {
     return elevenlabs.verifyKey(key);
 }
 export async function listVoices(cfg, run) {
-    if (voiceProvider(cfg) === "system")
+    const provider = voiceProvider(cfg);
+    if (provider === "system")
         return systemVoices.listSystemVoices(run);
+    if (provider === "chatterbox") {
+        const baseUrl = cfg.tts?.baseUrl?.trim();
+        return baseUrl ? chatterbox.listChatterboxVoices(baseUrl) : [];
+    }
     const key = cfg.tts?.key;
     if (!key)
         return [];
@@ -59,7 +81,8 @@ export async function listVoices(cfg, run) {
 /** Synthesize one utterance. Throws NoVoiceConfigured when there is nothing
  * to speak with, which the route turns into a 409 the client can explain. */
 export function speak(cfg, text, voiceId, run) {
-    if (voiceProvider(cfg) === "system") {
+    const provider = voiceProvider(cfg);
+    if (provider === "system") {
         const voice = voiceId || cfg.tts?.voice;
         // An injected runner is the cross-platform test seam for `/usr/bin/say`;
         // production calls omit it and remain strictly Darwin-gated.
@@ -69,6 +92,16 @@ export function speak(cfg, text, voiceId, run) {
             throw new NoVoiceConfigured("voice");
         return systemVoices.synthesizeSystem(text, voice, run);
     }
+    if (provider === "chatterbox") {
+        const baseUrl = cfg.tts?.baseUrl?.trim();
+        if (!baseUrl) {
+            throw new NoVoiceConfigured("key", "Add the address of your Chatterbox server in Settings on the computer to turn on voice.");
+        }
+        const voice = voiceId || cfg.tts?.voice;
+        if (!voice)
+            throw new NoVoiceConfigured("voice");
+        return chatterbox.synthesizeChatterbox(text, voice, baseUrl, cfg.tts?.model);
+    }
     const key = cfg.tts?.key;
     if (!key)
         throw new NoVoiceConfigured("key");

package/dist-server/server/workspace.js

@@ -16,6 +16,10 @@ import { redactSecretsInText } from "./redact.js";
 import { DATA_DIR } from "./config.js";
 export const WORKSPACES_DIR = join(DATA_DIR, "workspaces");
 export const TASK_WORKSPACES_DIR = join(DATA_DIR, "task-workspaces");
+/** MCP support does not imply native filesystem tools or a local working directory. */
+export function supportsWorkspaceFiles(driverKind) {
+    return !["grok", "openai-compat", "minimax", "boxAgent"].includes(driverKind);
+}
 /** Default task files are private to the thread, outside the bot's shared
  * memory folder. This is directory organization, not a shell sandbox. */
 export function ensureTaskWorkspace(botId, threadId) {
@@ -519,9 +523,15 @@ export function memorySystemPrompt(botId, opts = {}) {
     const memory = loadMemory(botId);
     const memoryFile = join(workspaceDir(botId), "MEMORY.md");
     const topicDir = join(workspaceDir(botId), "memory");
+    if (opts.fileTools === false && !opts.managedWrites) {
+        if (!memory)
+            return "";
+        return ` Your saved memory is supplied as context; this turn has no memory editing tools.\n\nYour memory (MEMORY.md):\n${memory.text}${memory.truncated ? " [Only the initial memory excerpt is visible.]" : ""}`;
+    }
     const writeGuidance = opts.managedWrites
         ? " This memory is shared across your independent threads. Use memory_update for every change to MEMORY.md, never direct file tools or whole-file overwrites." +
-            " Append new facts, or replace/remove an exact unique old_text passage. If it conflicts, read the current file and retry only your intended change."
+            " Append new facts, or replace/remove an exact unique old_text passage. If it conflicts, " +
+            (opts.fileTools === false ? "use session_search to find the current passage" : "read the current file") + " and retry only your intended change."
         : " When you learn something worth keeping, update it with your file tools; remove notes that turn out to be wrong.";
     const guidance = ` Your private long-term memory file is ${JSON.stringify(memoryFile)}.` +
         " It stays separate from a custom project working folder." +
@@ -533,7 +543,7 @@ export function memorySystemPrompt(botId, opts = {}) {
         return guidance;
     const truncatedNote = memory.truncated
         ? ` [MEMORY.md is ${memory.lines} lines and ${memory.bytes} bytes; only the first ${MEMORY_MAX_LINES} lines / ${MEMORY_MAX_BYTES} bytes are shown above and the rest is not visible to you. ${opts.managedWrites
-            ? "Consolidate it now with memory_update: replace or remove older entries, or move detail to a memory/<topic>.md file."
+            ? "Consolidate it now with memory_update: replace or remove older entries" + (opts.fileTools === false ? "." : ", or move detail to a memory/<topic>.md file.")
             : "Trim it with your file tools: merge or remove older entries, or move detail to a memory/<topic>.md file."}]`
         : "";
     return `${guidance}\n\nYour memory (MEMORY.md):\n${memory.text}${truncatedNote}`;

package/dist-server/shared/ask-question.js

@@ -100,6 +100,34 @@ export function askQuestionSummary(questions) {
     const rest = questions.length - 1;
     return rest > 0 ? `${first} (+${rest} more question${rest > 1 ? "s" : ""})` : first;
 }
+/** How many one-tap answers an `ask_user` card offers; the tool advertises
+ * "2-5 suggested answers". */
+export const MAX_CHOICES = 5;
+/**
+ * Flat labels from a bot-authored `ask_user` `choices` array.
+ *
+ * The tool schema says strings, but a model that has also seen Claude's
+ * AskUserQuestion will hand over `{ label, description }` rows instead
+ * (MiniMax M3 does). The label is the choice either way. Anything else is
+ * dropped: a non-string choice that reached the card was drawn as a React
+ * child, which React refuses, taking the whole chat page down with it.
+ */
+export function parseChoices(input, limit = MAX_CHOICES) {
+    if (!Array.isArray(input))
+        return undefined;
+    const choices = [];
+    const seen = new Set();
+    for (const raw of input) {
+        const label = typeof raw === "string" ? text(raw, MAX_LABEL) : isRecord(raw) ? text(raw.label, MAX_LABEL) : undefined;
+        if (!label || seen.has(label))
+            continue;
+        seen.add(label);
+        choices.push(label);
+        if (choices.length === limit)
+            break;
+    }
+    return choices.length ? choices : undefined;
+}
 /** Flat labels for clients that only know how to render a list of choices
  * (the phone companions, and any older desktop build). Only a single
  * question can be answered that way without losing which one was answered. */

package/dist-server/shared/computer-contention.js

@@ -0,0 +1,17 @@
+/** One wording for "a turn already owns this bot's cloud computer", shared
+ * because two sides have to agree on it: the server sends it with 409 when
+ * provision or sleep arrives mid-turn, and the Computer panel recognises it
+ * to show the neutral busy state instead of a fault.
+ *
+ * Kept here rather than spelled out at each site: the panel used to match
+ * the server's prose with its own regex, so a copy-edit on the server would
+ * have silently turned the busy state back into "Couldn't reach the
+ * computer" — the exact bug the panel fix exists to prevent, and one no
+ * test would have caught. */
+export const CLOUD_COMPUTER_BUSY_ERROR = "this bot's cloud computer is being used by an active turn — interrupt it first";
+/** True when an error message carries that refusal, however it was wrapped.
+ * A substring test, not equality: the message reaches the client as the
+ * server wrote it today, but a future wrapper must not break recognition. */
+export function isCloudComputerBusyMessage(message) {
+    return message.includes(CLOUD_COMPUTER_BUSY_ERROR);
+}

package/dist-server/shared/cron-label.js

@@ -0,0 +1,39 @@
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+const MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+/** Describe familiar presets; retain the exact expression for everything else.
+ * This is presentation only, never a second parser or source of scheduling truth. */
+export function cronScheduleLabel(schedule) {
+    const [minute, hour, day, month, weekday] = schedule.expression.trim().split(/\s+/);
+    let label = `Cron ${schedule.expression}`;
+    if (/^\d+$/.test(minute ?? "") && /^\d+$/.test(hour ?? "")) {
+        const time = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+        const monthDay = /^\d+$/.test(day ?? "") ? Number(day) : null;
+        if (weekday === "*" && month === "*") {
+            if (day === "*")
+                label = `Every day at ${time}`;
+            else if (day === "L")
+                label = `Monthly on the last day at ${time}`;
+            else if (monthDay !== null)
+                label = `Monthly on day ${monthDay} at ${time}`;
+        }
+        else if (weekday === "*" && /^\d+$/.test(month ?? "") && monthDay !== null) {
+            const name = MONTHS[Number(month) - 1];
+            if (name)
+                label = `Yearly on ${name} ${monthDay} at ${time}`;
+        }
+        else if (day === "*" && month === "*") {
+            if (weekday === "1-5" || weekday?.toUpperCase() === "MON-FRI")
+                label = `Every weekday at ${time}`;
+            else if (/^[0-7]$/.test(weekday ?? ""))
+                label = `Weekly on ${WEEKDAYS[Number(weekday) % 7]} at ${time}`;
+            else {
+                const nth = /^([0-7])#([1-5]|L)$/i.exec(weekday ?? "");
+                if (nth) {
+                    const order = nth[2].toUpperCase() === "L" ? "last" : ["", "first", "second", "third", "fourth", "fifth"][Number(nth[2])];
+                    label = `Monthly on the ${order} ${WEEKDAYS[Number(nth[1]) % 7]} at ${time}`;
+                }
+            }
+        }
+    }
+    return `${label} · ${schedule.timeZone}`;
+}

package/dist-server/shared/routine-schedule.js

@@ -0,0 +1,89 @@
+import { Cron } from "croner";
+const MAX_EXPRESSION_LENGTH = 256;
+const MAX_PREVIEW_RUNS = 1000;
+function cronCalculator(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Choose a valid cron schedule");
+    const input = value;
+    if (input.type !== "cron" || typeof input.expression !== "string")
+        throw new Error("Choose a valid cron schedule");
+    if (Object.keys(input).some(key => !["type", "expression", "timeZone"].includes(key))) {
+        throw new Error("Cron schedules accept only type, expression and timeZone; start/end dates and other restrictions are not supported");
+    }
+    const expression = input.expression.trim().replace(/\s+/g, " ");
+    if (expression.length > MAX_EXPRESSION_LENGTH || expression.split(" ").length !== 5 || expression.includes("@")) {
+        throw new Error("Cron must have five fields: minute hour day-of-month month weekday (no seconds, year, or macros)");
+    }
+    const timeZone = typeof input.timeZone === "string" ? input.timeZone.trim() : "";
+    // Intl also accepts numeric offsets in newer runtimes. Require a named zone
+    // so wall-clock schedules follow its daylight-saving rules instead.
+    if (timeZone.length > 128 || !(timeZone === "UTC" || /^[A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)+$/.test(timeZone))) {
+        throw new Error("Choose an IANA timezone such as America/New_York, Asia/Kolkata, or UTC");
+    }
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone }).format(0);
+    }
+    catch {
+        throw new Error("Choose a valid IANA timezone such as America/New_York, Asia/Kolkata, or UTC");
+    }
+    try {
+        // Date calculator only: no callback, name, or timer. RoutineManager owns
+        // dispatch, persistence, catch-up and cancellation. Croner bounds its
+        // five-field search at year 3000, including impossible calendar dates.
+        const cron = new Cron(expression, { timezone: timeZone, mode: "5-part", paused: true });
+        return { schedule: { type: "cron", expression, timeZone }, cron };
+    }
+    catch (error) {
+        throw new Error(`Invalid cron expression: ${error.message}`);
+    }
+}
+function calculationDate(after) {
+    const date = new Date(after);
+    if (!Number.isFinite(after) || !Number.isFinite(date.getTime()))
+        throw new Error("Choose a valid cron preview date");
+    return date;
+}
+function futureRuns(cron, after, count) {
+    const from = calculationDate(after);
+    // Croner resolves an ambiguous wall-clock time to its first occurrence.
+    // If the cursor is already in the second occurrence, its first candidate
+    // can therefore be in the past. Ask the same calculator for more candidates
+    // and discard those, rather than moving the scheduler cursor backwards.
+    // Minute precision bounds even a full-day historical timezone fold at 1440.
+    const maximum = count + 1440;
+    let requested = count;
+    while (true) {
+        const candidates = cron.nextRuns(requested, from);
+        const runs = [];
+        for (const date of candidates) {
+            const at = date.getTime();
+            if (!Number.isFinite(at))
+                throw new Error("The cron schedule produced an invalid date");
+            if (at > (runs.at(-1) ?? after))
+                runs.push(at);
+            if (runs.length === count)
+                return runs;
+        }
+        if (candidates.length < requested || requested === maximum)
+            return runs;
+        // Sparse schedules normally need just one more candidate. Grow only when
+        // needed, so a daily preview never scans years to skip one repeated hour.
+        requested = Math.min(maximum, requested * 2);
+    }
+}
+/** Normalize once at the trust boundary, rejecting impossible schedules. */
+export function normalizeCronSchedule(value, after = Date.now()) {
+    const { schedule, cron } = cronCalculator(value);
+    if (!futureRuns(cron, after, 1).length)
+        throw new Error("This cron expression has no future runs. Choose dates that exist.");
+    return schedule;
+}
+/** Strictly-future instants, shared by the scheduler, cards and calendar.
+ * Croner's DST policy is intentional: missing clock times advance through
+ * the gap, and repeated clock times use their first occurrence only. */
+export function nextCronRuns(schedule, after, count) {
+    if (!Number.isInteger(count) || count < 1 || count > MAX_PREVIEW_RUNS)
+        throw new Error("Choose between 1 and 1000 cron preview runs");
+    const { cron } = cronCalculator(schedule);
+    return futureRuns(cron, after, count);
+}

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

@@ -20,7 +20,7 @@ const task = z.object({
     key,
     title: z.string().max(2_000),
     createdAt: timestamp,
-    openedBy: z.object({ botId: key, name, at: timestamp }).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(),
     messages: z.array(message).max(100_000),

package/dist-server/vps-container-mcp.js

@@ -15187,10 +15187,17 @@ var appConfigSchema = external_exports.object({
   vps: vpsConfigSchema.optional(),
   /** Optional OpenCode key; persisted write-only and passed only to its child. */
   opencodeGo: external_exports.object({ apiKey: optionalText }).optional(),
-  /** Voice credentials and the selected voice id. `provider` picks the
-   * engine: "elevenlabs" (default; needs a key) or "system" (the Mac's
-   * built-in voices, no key). */
-  tts: external_exports.object({ key: optionalText, voice: optionalText, provider: external_exports.enum(["elevenlabs", "system"]).optional() }).optional(),
+  /** Voice settings and the selected voice id. `provider` picks the
+   * engine: "elevenlabs" (default; needs a key), "system" (the Mac's
+   * built-in voices, no key), or "chatterbox" (a local OpenAI-compatible
+   * Chatterbox server; `baseUrl` and `model` are settings, not secrets). */
+  tts: external_exports.object({
+    key: optionalText,
+    voice: optionalText,
+    provider: external_exports.enum(["elevenlabs", "system", "chatterbox"]).optional(),
+    baseUrl: external_exports.string().trim().max(2048).refine((value) => !value || /^https?:\/\//i.test(value), "the Chatterbox server address must start with http:// or https://").optional(),
+    model: optionalText
+  }).optional(),
   /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
   imageGen: external_exports.object({
     provider: external_exports.enum(["openai", "xai", "custom"]).optional(),
@@ -15249,7 +15256,6 @@ function resolveProxy(relative) {
 }
 var SPAWNED_PROXIES = {
   browser: resolveProxy("browser-proxy"),
-  computer: resolveProxy("computer-proxy"),
   localComputer: resolveProxy("local-computer-proxy"),
   permission: resolveProxy("permission-proxy"),
   containerMcp: resolveProxy("container-mcp"),

package/enterprise/server/index.js

@@ -14593,7 +14593,6 @@ function resolveProxy(relative) {
 }
 var SPAWNED_PROXIES = {
   browser: resolveProxy("browser-proxy"),
-  computer: resolveProxy("computer-proxy"),
   localComputer: resolveProxy("local-computer-proxy"),
   permission: resolveProxy("permission-proxy"),
   containerMcp: resolveProxy("container-mcp"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmausbot",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "description": "Run the OpenMausBot server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",