openmausbot 0.1.86 → 0.1.87

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

@@ -70,19 +70,21 @@ function sameDriverFileIdentity(expected, actual) {
 }
 function decodeLegacyDescriptor(value, platform) {
     const supportedPlatform = legacyPlatform(platform);
-    if (!supportedPlatform || !value || value.mode === "unavailable" || typeof value.mcpCommand !== "string") {
+    if (!supportedPlatform || !value ||
+        !(value.mode === "embedded" || (supportedPlatform === "darwin" && value.mode === "standalone")) ||
+        (Object.hasOwn(value, "status") && value.status !== "ready") ||
+        typeof value.socketPath !== "string" || !value.socketPath ||
+        typeof value.mcpCommand !== "string" || !value.mcpCommand.trim()) {
         return null;
     }
-    if (value.mcpArgs !== undefined && !Array.isArray(value.mcpArgs))
+    if (!Array.isArray(value.mcpArgs) || value.mcpArgs[0] !== "mcp")
         return null;
-    if (value.mcpEnv !== undefined &&
-        (!value.mcpEnv || typeof value.mcpEnv !== "object" || Array.isArray(value.mcpEnv))) {
+    if (!value.mcpEnv || typeof value.mcpEnv !== "object" || Array.isArray(value.mcpEnv))
         return null;
-    }
-    const args = value.mcpArgs ?? ["mcp"];
+    const args = value.mcpArgs;
     if (!args.every((arg) => typeof arg === "string"))
         return null;
-    const env = value.mcpEnv ?? {};
+    const env = value.mcpEnv;
     if (!Object.values(env).every((entry) => typeof entry === "string"))
         return null;
     return {
@@ -288,31 +290,78 @@ function validateLegacyDescriptorRuntime(descriptorFile, platform, { uid = proce
         return false;
     }
 }
+/** An older fallback cannot override a present but unavailable, malformed, or
+ * unreadable descriptor at a more specific location. */
+function firstPresentCuaDescriptor(candidates) {
+    for (const file of new Set(candidates)) {
+        try {
+            lstatSync(file);
+            return file;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return file;
+        }
+    }
+    return null;
+}
 export function readCuaConnection({ platform = process.platform, userData = process.env.OMB_USER_DATA, home = homedir(), validateLinuxRuntime = validateLinuxDescriptorRuntime, validateLegacyRuntime = validateLegacyDescriptorRuntime, } = {}) {
     const candidates = userData ? [join(userData, "cua-connection.json")] : [];
-    if (platform === "darwin") {
-        // Legacy/dev fallback. Packaged Electron passes its exact userData path.
+    if (platform === "darwin" && !userData) {
+        // Legacy/dev fallback only when Electron did not provide its exact path.
         for (const directory of ["OpenMausBot", "openmausbot", "OpenGrokBot", "opengrokbot"]) {
             candidates.push(join(home, "Library", "Application Support", directory, "cua-connection.json"));
         }
     }
-    for (const file of new Set(candidates)) {
-        try {
+    const file = firstPresentCuaDescriptor(candidates);
+    if (!file)
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        if (platform === "linux") {
+            const decoded = decodeLinuxDescriptor(raw);
+            if (decoded && validateLinuxRuntime(file, raw))
+                return decoded;
+        }
+        else {
+            const decoded = decodeLegacyDescriptor(raw, platform);
+            if (decoded && validateLegacyRuntime(file, platform))
+                return decoded;
+        }
+    }
+    catch {
+        // Missing, invalid, tampered, or stale descriptors are unavailable.
+    }
+    return null;
+}
+/** An unavailable descriptor is diagnostic only. It never becomes a connection
+ * and only a private, well-formed macOS/Windows descriptor may supply text. */
+export function readCuaUnavailableReason({ platform = process.platform, userData = process.env.OMB_USER_DATA, home = homedir(), } = {}) {
+    if (!legacyPlatform(platform))
+        return null;
+    const candidates = userData ? [join(userData, "cua-connection.json")] : [];
+    if (platform === "darwin" && !userData) {
+        for (const directory of ["OpenMausBot", "openmausbot", "OpenGrokBot", "opengrokbot"]) {
+            candidates.push(join(home, "Library", "Application Support", directory, "cua-connection.json"));
+        }
+    }
+    const file = firstPresentCuaDescriptor(candidates);
+    if (!file)
+        return null;
+    try {
+        if (validateLegacyDescriptorRuntime(file, platform)) {
             const raw = JSON.parse(readFileSync(file, "utf8"));
-            if (platform === "linux") {
-                const decoded = decodeLinuxDescriptor(raw);
-                if (decoded && validateLinuxRuntime(file, raw))
-                    return decoded;
-            }
-            else {
-                const decoded = decodeLegacyDescriptor(raw, platform);
-                if (decoded && validateLegacyRuntime(file, platform))
-                    return decoded;
+            if (raw && typeof raw === "object" && !Array.isArray(raw) &&
+                Object.keys(raw).length === 2 &&
+                raw.mode === "unavailable") {
+                const reason = raw.reason;
+                if (typeof reason === "string" && reason.trim() && reason.length <= 2_000)
+                    return reason.trim();
             }
         }
-        catch {
-            // Missing, invalid, tampered, or stale descriptors are unavailable.
-        }
+    }
+    catch {
+        // No usable diagnostic; the caller still refuses computer control.
     }
     return null;
 }

package/dist-server/server/managed-desktop.js

@@ -20,7 +20,7 @@ const identitySchema = z.object({ portalOrigin: z.string().max(2048), organizati
 const PROVIDER_IDS = ["anthropic", "openai", "openrouter"];
 const signature = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const expiredMessage = "Company access has ended. Reconnect your organization or explicitly choose a personal model; personal billing will not be used automatically.";
-export const LICENSE_EXPIRED_MESSAGE = "Your organisation's OpenMaus Admin licence has expired. Contact your admin.";
+export const LICENSE_EXPIRED_MESSAGE = "Your organization's OpenMaus Admin license has expired. Contact your admin.";
 /** Validate only messages received over Electron's private utility-parent port.
  * Never expose this input to renderer HTTP or merge it into saved AppConfig.
  */

package/dist-server/server/mcp-bridge.js

@@ -36,14 +36,14 @@ import { createToolListNormalizer } from "./mcp-tool-schema.js";
 // stdin/stdout/stderr resets the window.
 export const BRIDGE_INACTIVITY_MS = 45_000;
 const PROBE_TIMEOUT_MS = 10_000;
-/** Run the liveness command; alive means "exited 0 within the timeout". The
- * probe is its own short-lived process, so it cannot inherit the wedged
- * connection it is diagnosing. */
-export function runLivenessProbe(probe, timeoutMs = PROBE_TIMEOUT_MS) {
+/** Run the liveness command; alive means "exited 0 within the timeout". A
+ * separate bounded command checks the transport without waiting for an
+ * answer on the possibly wedged MCP stream. */
+export function runLivenessProbe(probe, timeoutMs = PROBE_TIMEOUT_MS, env) {
     return new Promise((resolve) => {
         const child = spawn(probe.command, probe.args, {
             shell: false,
-            env: { ...process.env, PATH: augmentedPath() },
+            env: env ?? { ...process.env, PATH: augmentedPath() },
             stdio: ["ignore", "ignore", "ignore"],
         });
         const timer = setTimeout(() => {
@@ -265,7 +265,7 @@ export function runMcpBridge(options) {
         const liveness = options.liveness;
         watchdog = createInactivityWatchdog({
             inactivityMs: BRIDGE_INACTIVITY_MS,
-            probe: () => runLivenessProbe(liveness),
+            probe: () => runLivenessProbe(liveness, PROBE_TIMEOUT_MS, options.env),
             onDead: () => {
                 process.stderr.write(`${options.label} transport went silent and stopped answering liveness probes; ending the bridge\n`);
                 process.exitCode = 1;

package/dist-server/server/new-bot-defaults.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { profilePatchSchema, fitsOnOneLine } from "./bot-profile.js";
+import { EFFORT_LEVELS } from "../shared/wire.js";
+import { isModelVariant } from "./contracts.js";
+import { normalizeCronSchedule } from "../shared/routine-schedule.js";
+const strings = (max, length) => z.array(z.string().max(length)).max(max);
+const clock = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
+const weekdays = z.array(z.number().int().min(0).max(6)).min(1).max(7);
+const timestamp = z.number().int().nonnegative().max(8_640_000_000_000_000);
+export const botDefaultModelSchema = z.object({
+    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(),
+}).strict().refine(value => value.effort === undefined || value.variant === undefined, "choose either a model variant or an effort level");
+// Preferences only. Consent flags, live grants, bot IDs and execution state
+// cannot be stored here and therefore cannot be replayed as permission grants.
+export const botDefaultsProfileSchema = profilePatchSchema.extend({
+    name: z.string().max(100).refine(fitsOnOneLine, "name must fit on one line").optional(),
+    section: z.string().trim().max(60).optional(),
+    color: z.enum(["green", "blue", "red", "orange", "purple", "cyan", "pink", "yellow", "teal", "coral"]).optional(),
+    mascotExpression: z.string().max(60).nullable().optional(),
+    modelSelection: botDefaultModelSchema.optional(),
+    computer: z.enum(["cloud", "vm", "local", "browser", "off"]).nullable().optional(),
+    cloudBackend: z.enum(["box", "vps"]).optional(),
+    autoStartVps: z.boolean().optional(),
+    cwd: z.string().max(4096).nullable().optional(),
+    approvalMode: z.enum(["ask", "auto", "full", "custom"]).optional(),
+    alwaysAllow: strings(200, 500).optional(),
+    chiefOfStaff: z.boolean().optional(),
+    managedSections: strings(100, 60).optional(),
+    approvePeerComms: z.boolean().optional(),
+    peers: strings(1000, 100).nullable().optional(),
+    composio: z.boolean().optional(),
+    browser: z.boolean().optional(),
+    browserProfile: z.string().max(100).nullable().optional(),
+    mcpServers: strings(100, 100).nullable().optional(),
+    parkDirectMessages: z.boolean().optional(),
+}).strict();
+const scheduleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("once"), at: timestamp }).strict(),
+    z.object({ type: z.literal("daily"), time: clock, weekdays }).strict(),
+    z.object({
+        type: z.literal("interval"), everyMinutes: z.number().int().min(5).max(1440), anchorAt: timestamp,
+        weekdays: weekdays.nullable().optional(),
+        window: z.object({ start: clock, end: clock }).strict().nullable().optional(),
+        endsAt: timestamp.nullable().optional(),
+    }).strict(),
+    z.object({ type: z.literal("cron"), expression: z.string().max(256), timeZone: z.string().max(128) }).strict(),
+]).superRefine((value, ctx) => {
+    if (value.type === "cron") {
+        try {
+            normalizeCronSchedule(value);
+        }
+        catch (error) {
+            ctx.addIssue({ code: "custom", message: String(error) });
+        }
+    }
+    if (value.type === "interval" && value.window) {
+        const minutes = (time) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
+        if (minutes(value.window.end) - minutes(value.window.start) < value.everyMinutes) {
+            ctx.addIssue({ code: "custom", message: "The interval must fit inside its time window" });
+        }
+    }
+});
+export const botRoutineTemplateSchema = z.object({
+    name: z.string().trim().min(1).max(80), prompt: z.string().trim().min(1).max(20_000),
+    schedule: scheduleSchema, enabled: z.boolean().optional(),
+    runOn: z.enum(["maus", "cloud"]).optional(),
+    durationMinutes: z.number().int().min(5).max(240).optional(),
+    timeoutMinutes: z.number().min(1).max(1440).nullable().optional(),
+    overlap: z.enum(["skip", "queue"]).optional(),
+    attachments: z.array(z.object({
+        id: z.string().min(1).max(200), kind: z.enum(["file", "image"]),
+        name: z.string().min(1).max(255), path: z.string().min(1).max(4096), size: z.number().nonnegative(),
+    }).strict()).max(50).optional(),
+}).strict();
+export const botSkillTemplateSchema = z.object({
+    name: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(64),
+    description: z.string().max(1024),
+    warnings: strings(100, 2000).default([]),
+    source: z.string().min(1).max(2000),
+    text: z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Skill exceeds 256 KiB"),
+    enabled: z.boolean(),
+}).strict();
+export const newBotDefaultsSchema = z.object({
+    profile: botDefaultsProfileSchema.default({}),
+    memory: z.record(z.string().regex(/^(?:MEMORY\.md|memory\/[a-zA-Z0-9_-]+\.md)$/), z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Memory file exceeds 256 KiB"))
+        .refine(value => Object.keys(value).length <= 100, "At most 100 memory files").default({}),
+    skills: z.array(botSkillTemplateSchema).max(100).default([]),
+    routines: z.array(botRoutineTemplateSchema).max(100).default([]),
+}).strict().refine(value => Buffer.byteLength(JSON.stringify(value), "utf8") <= 900_000, "Bot defaults must fit within 900 KB");
+/** Explicit values (including empty values) win. A resolved renderer draft
+ * opts out so deleted fields and template extras are not restored on POST. */
+export function resolveBotCreationDefaults(saved, body) {
+    if (body.useDefaults !== undefined && typeof body.useDefaults !== "boolean") {
+        throw Object.assign(new Error("useDefaults must be true or false"), { status: 400 });
+    }
+    const template = newBotDefaultsSchema.parse(body.useDefaults === false ? {} : saved ?? {});
+    const checked = botDefaultsProfileSchema.safeParse(body.settings === undefined ? {} : body.settings);
+    if (!checked.success)
+        throw Object.assign(new Error(checked.error.message), { status: 400 });
+    const explicit = checked.data;
+    const profile = { ...template.profile, ...explicit };
+    for (const key of ["name", "title", "description", "modelSelection", "section"]) {
+        if (Object.hasOwn(body, key))
+            Object.assign(profile, { [key]: key === "section" && body[key] === null ? "" : body[key] });
+    }
+    const resolved = botDefaultsProfileSchema.safeParse(profile);
+    if (!resolved.success)
+        throw Object.assign(new Error(resolved.error.message), { status: 400 });
+    if (!resolved.data.name?.trim())
+        delete resolved.data.name;
+    return { ...template, profile: resolved.data };
+}