openmausbot 0.1.91 → 0.1.92

package/dist-server/server/config.js

@@ -19,6 +19,9 @@ const optionalText = z.string().optional();
 const SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
 const LEGACY_BROWSER_PROFILE_ID = /^[A-Za-z0-9_-]{1,40}$/;
 const BROWSER_PROFILE_ID = /^[a-z0-9_-]{1,40}$/;
+/** Fish Audio speech models (`tts.fishModel`). `s2.1-pro-free` is Fish's
+ * free developer tier; an unset model means `s2.1-pro`. */
+export const FISH_TTS_MODELS = ["s2.1-pro", "s2.1-pro-free"];
 export const DEFAULT_ROOM_TURN_TIMEOUT_MINUTES = 5;
 export const MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
 export const MAX_ROOM_TURN_TIMEOUT_MINUTES = 1_440;
@@ -36,6 +39,11 @@ export const DEFAULT_LOCAL_VM_MODE = "shared";
 export const DEFAULT_LOCAL_VM_MAX_INSTANCES = 2;
 export const MIN_LOCAL_VM_MAX_INSTANCES = 1;
 export const MAX_LOCAL_VM_MAX_INSTANCES = 8;
+/** Idle window before a Local VM's disposable container is recycled. The
+ * default keeps the historical 8-hour window for existing configs. */
+export const DEFAULT_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 480;
+export const MIN_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 5;
+export const MAX_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 1_440;
 export function isValidSshAlias(value) {
     return typeof value === "string" && SSH_ALIAS.test(value);
 }
@@ -112,6 +120,12 @@ const localVmConfigSchema = z.object({
         .min(MIN_LOCAL_VM_MAX_INSTANCES)
         .max(MAX_LOCAL_VM_MAX_INSTANCES)
         .optional(),
+    idleTimeoutMinutes: z
+        .number()
+        .int()
+        .min(MIN_LOCAL_VM_IDLE_TIMEOUT_MINUTES)
+        .max(MAX_LOCAL_VM_IDLE_TIMEOUT_MINUTES)
+        .optional(),
 });
 /** A named, shareable browser session ("Work", "Client A"). The id names a
  * durable Electron partition; user-controlled characters never reach it. */
@@ -302,6 +316,10 @@ const onboardingConfigSchema = z.object({
     version: z.number().int().min(0).max(1000).optional(),
     reelSeen: z.boolean().optional(),
     hintsSeen: z.array(z.string().trim().min(1).max(60)).max(100).optional(),
+    /** OMB Cloud home only: when a bot's turn first finished on this machine
+     * (cloud-home.ts firstCloudTurnPatch). Written by the server, read by the
+     * Cloud's setup checklist. */
+    firstTurnAt: z.string().trim().max(40).optional(),
 }).strict();
 const instanceConfigSchema = z.object({
     driver: z.string().min(1),
@@ -314,6 +332,7 @@ const instanceConfigSchema = z.object({
     ]).optional(),
     environment: z.record(z.string(), z.string()).optional(),
     enabled: z.boolean().optional(),
+    access: z.enum(["subscription", "custom", "api"]).optional(),
     config: z.json().optional(),
 });
 const instanceConfigMapSchema = z.record(z.string(), instanceConfigSchema);
@@ -373,7 +392,12 @@ const appConfigSchema = z.object({
     /** 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
      * personal-login OAuth token. */
-    anthropic: z.object({ key: optionalText, url: optionalText }).optional(),
+    anthropic: z.object({ key: optionalText, url: optionalText, everyClaudeBot: z.boolean().optional() }).optional(),
+    /** OpenAI's own API key, for the `openai` instance only. Codex keeps its
+     * own ChatGPT or API login and never reads this. */
+    openai: z.object({ key: optionalText }).optional(),
+    /** OpenRouter key, for the `openrouter` instance only. */
+    openrouter: z.object({ key: optionalText }).optional(),
     /** Monthly spend limit for the whole workspace, against the cost engines
      * report to the usage ledger. Enforced only with the `budgets` entitlement. */
     budgets: z
@@ -412,8 +436,8 @@ const appConfigSchema = z.object({
     opencodeGo: z.object({ apiKey: optionalText }).optional(),
     /** Voice settings and the selected voice id. `provider` picks the
      * engine: "elevenlabs" (default; needs `key`), "fish" (needs its own
-     * `fishKey`), "system" (the Mac's built-in voices, no key), or
-     * "xai" (Grok TTS, reusing `xai.key`), or
+     * `fishKey`; `fishModel` picks its speech model), "system" (the Mac's
+     * built-in voices, no key), "xai" (Grok TTS, reusing `xai.key`), or
      * "chatterbox" (a local OpenAI-compatible Chatterbox server; `baseUrl`
      * and `model` are settings, not secrets). Cloud keys stay separate so
      * switching providers never overwrites or misuses the other key. */
@@ -429,6 +453,7 @@ const appConfigSchema = z.object({
             .refine((value) => !value || /^https?:\/\//i.test(value), "the Chatterbox server address must start with http:// or https://")
             .optional(),
         model: optionalText,
+        fishModel: z.enum(FISH_TTS_MODELS).optional(),
     }).optional(),
     /** The decision model (server/decider): a fast classifier that picks
      * things for bots, starting with who answers a room message. `key` is
@@ -638,6 +663,9 @@ export function localVmMode(cfg) {
 export function localVmMaxInstances(cfg) {
     return cfg.localVm?.maxInstances ?? DEFAULT_LOCAL_VM_MAX_INSTANCES;
 }
+export function localVmIdleTimeoutMinutes(cfg) {
+    return cfg.localVm?.idleTimeoutMinutes ?? DEFAULT_LOCAL_VM_IDLE_TIMEOUT_MINUTES;
+}
 /** On by default; only an explicit `false` (the Settings toggle, or a legacy
  * `skillRecorder: false` carried over at startup) switches it off. */
 export function skillAuthoringEnabled(cfg) {
@@ -867,6 +895,12 @@ export function loadConfig() {
         cfg.anthropic.key = process.env.OMB_ANTHROPIC_API_KEY;
     if (process.env.OMB_ANTHROPIC_API_URL !== undefined)
         cfg.anthropic.url = process.env.OMB_ANTHROPIC_API_URL;
+    cfg.openai = { ...cfg.openai };
+    if (process.env.OMB_OPENAI_API_KEY !== undefined)
+        cfg.openai.key = process.env.OMB_OPENAI_API_KEY;
+    cfg.openrouter = { ...cfg.openrouter };
+    if (process.env.OMB_OPENROUTER_API_KEY !== undefined)
+        cfg.openrouter.key = process.env.OMB_OPENROUTER_API_KEY;
     cfg.openaiCompat = { ...cfg.openaiCompat };
     if (process.env.OPENAI_COMPAT_API_KEY !== undefined)
         cfg.openaiCompat.key = process.env.OPENAI_COMPAT_API_KEY;
@@ -929,6 +963,8 @@ export function syncCredentialEnv(patch) {
         [patch.mistral?.key, "MISTRAL_API_KEY"],
         [patch.anthropic?.key, "OMB_ANTHROPIC_API_KEY"],
         [patch.openaiCompat?.key, "OPENAI_COMPAT_API_KEY"],
+        [patch.openai?.key, "OMB_OPENAI_API_KEY"],
+        [patch.openrouter?.key, "OMB_OPENROUTER_API_KEY"],
         [patch.composio?.apiKey, "COMPOSIO_API_KEY"],
         [patch.box?.token, "BOX_TOKEN"],
         [patch.opencodeGo?.apiKey, "OPENCODE_API_KEY"],
@@ -977,6 +1013,8 @@ export const WORKSPACE_CREDENTIAL_ENV = [
     "OMB_HOSTED_MODELS",
     "OPENAI_COMPAT_API_KEY",
     "OPENAI_COMPAT_URL",
+    "OMB_OPENAI_API_KEY",
+    "OMB_OPENROUTER_API_KEY",
     "BOX_TOKEN",
     "OPENCODE_API_KEY",
     "OMB_TTS_KEY",
@@ -1073,7 +1111,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", "mistral", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
+    for (const key of ["xai", "anthropic", "mistral", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
@@ -1259,13 +1297,63 @@ export function persistableInstanceConfigs(cfg) {
     }
     return map;
 }
+/** Claude Code variables that choose where a turn goes and how it signs in.
+ * An instance that sets any of them (a router, a gateway, a cloud platform)
+ * owns that routing and credential pair outright. */
+const CLAUDE_ROUTING_ENV = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+/** Whether a Claude instance brings its own endpoint or credential. The
+ * workspace Anthropic key must never reach it: the key would be sent as
+ * x-api-key to that instance's host (a third-party router), or would
+ * silently re-route its turns to the workspace URL. */
+export function claudeInstanceOwnsRouting(environment) {
+    return CLAUDE_ROUTING_ENV.some((key) => typeof environment?.[key] === "string" && environment[key] !== "");
+}
+const sameUrl = (a, b) => a.trim().replace(/\/+$/u, "") === b.trim().replace(/\/+$/u, "");
+/** Whether an instance brings its own endpoint or credential, so the
+ * workspace key for its driver must never reach it: that key would be sent
+ * to the instance's own host (a third-party router or proxy). The same rule
+ * as a Claude router instance, for the API-key engines. An instance on the
+ * workspace's own endpoint with nothing of its own still gets the key. */
+export function instanceOwnsRouting(cfg, entry, routingDefaults) {
+    const config = typeof entry.config === "object" && entry.config !== null && !Array.isArray(entry.config)
+        ? entry.config
+        : {};
+    const own = (value) => typeof value === "string" && value.trim() !== "";
+    const ownUrl = (...workspace) => own(config.url)
+        && !workspace.some((url) => url !== undefined && sameUrl(config.url, url));
+    const compatKeyEnv = routingDefaults?.apiKeyEnv ?? "OPENAI_COMPAT_API_KEY";
+    switch (entry.driver) {
+        case "claudeAgent":
+            return claudeInstanceOwnsRouting(entry.environment);
+        case "openai-compat":
+            return own(config.key) || own(entry.environment?.OPENAI_COMPAT_API_KEY)
+                || own(entry.environment?.[compatKeyEnv])
+                || (own(config.apiKeyEnv) && config.apiKeyEnv !== compatKeyEnv)
+                || ownUrl(routingDefaults?.url || cfg.openaiCompat?.url || process.env.OPENAI_COMPAT_URL || "https://openrouter.ai/api/v1");
+        case "mistral":
+            return own(entry.environment?.MISTRAL_API_KEY) || ownUrl("https://api.mistral.ai/v1");
+        case "grok":
+            return own(entry.environment?.XAI_API_KEY) || (own(config.apiKeyEnv) && config.apiKeyEnv !== "XAI_API_KEY")
+                || ownUrl("https://api.x.ai/v1", cfg.xai?.url);
+        default:
+            return false;
+    }
+}
 /** The credential env instanceConfigs() injects for one driver at runtime.
  * Each secret goes only to the driver that actually reads it: the API-key
  * Grok driver reads XAI_API_KEY, the Computer driver reads BOX_TOKEN, and
  * OpenCode reads OPENCODE_API_KEY. Every other engine brings its own
  * login, so handing it a key it never uses would only put that key in the
  * environment of an unrelated child process. */
-function injectedEnvironment(cfg, driver) {
+function injectedEnvironment(cfg, instanceId, driver) {
     const environment = new Map();
     if (driver === "mistral" && cfg.mistral?.key)
         environment.set("MISTRAL_API_KEY", cfg.mistral.key);
@@ -1274,14 +1362,33 @@ function injectedEnvironment(cfg, driver) {
     // The workspace Anthropic key reaches Claude Code as the variable it
     // reads, carried in the instance environment so the driver can tell a
     // deliberate workspace key from one riding along in the parent's env.
-    if (driver === "claudeAgent" && cfg.anthropic?.key)
+    // By default it runs only the `claudeApi` instance, so signed-in Claude
+    // bots stay on their plan; `everyClaudeBot` (the pre-split behaviour, and
+    // what a hosted workspace seeded with only a key relies on) runs every
+    // other Claude instance on it too.
+    const anthropicHere = driver === "claudeAgent" && Boolean(cfg.anthropic?.key)
+        && (cfg.anthropic?.everyClaudeBot === false ? instanceId === CLAUDE_API_INSTANCE : instanceId !== CLAUDE_API_INSTANCE);
+    if (anthropicHere)
         environment.set("ANTHROPIC_API_KEY", cfg.anthropic.key);
-    if (driver === "claudeAgent" && cfg.anthropic?.key && cfg.anthropic.url)
+    if (anthropicHere && cfg.anthropic.url)
         environment.set("ANTHROPIC_BASE_URL", cfg.anthropic.url);
-    if (driver === "openai-compat" && cfg.openaiCompat?.key)
-        environment.set("OPENAI_COMPAT_API_KEY", cfg.openaiCompat.key);
-    if (driver === "openai-compat" && cfg.openaiCompat?.url)
-        environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
+    // OpenAI and OpenRouter have their own instances and keys; the workspace
+    // OpenAI-compatible key and URL belong to every other openai-compat
+    // instance ("Other" in Settings).
+    if (driver === "openai-compat" && instanceId === OPENAI_API_INSTANCE) {
+        if (cfg.openai?.key)
+            environment.set("OMB_OPENAI_API_KEY", cfg.openai.key);
+    }
+    else if (driver === "openai-compat" && instanceId === OPENROUTER_API_INSTANCE) {
+        if (cfg.openrouter?.key)
+            environment.set("OMB_OPENROUTER_API_KEY", cfg.openrouter.key);
+    }
+    else {
+        if (driver === "openai-compat" && cfg.openaiCompat?.key)
+            environment.set("OPENAI_COMPAT_API_KEY", cfg.openaiCompat.key);
+        if (driver === "openai-compat" && cfg.openaiCompat?.url)
+            environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
+    }
     // driverKind "boxAgent" and env BOX_TOKEN keep their historical names.
     // Only the person's own token: without one the driver itself falls back
     // to Cloud Pro's included token, which never enters an environment map.
@@ -1291,6 +1398,28 @@ function injectedEnvironment(cfg, driver) {
         environment.set("OPENCODE_API_KEY", cfg.opencodeGo.apiKey);
     return environment;
 }
+/** One instance per pasted provider key, each running only on its own key.
+ * They sit in the picker's "API keys" group and stay hidden until their key
+ * is saved (unavailable without one). */
+export const OPENAI_API_INSTANCE = "openai";
+export const OPENROUTER_API_INSTANCE = "openrouter";
+export const XAI_API_INSTANCE = "xaiApi";
+export const CLAUDE_API_INSTANCE = "claudeApi";
+const API_KEY_FLEET = {
+    [OPENAI_API_INSTANCE]: {
+        driver: "openai-compat", displayName: "OpenAI", access: "api", icon: { kind: "preset", preset: "openai" },
+        config: { url: "https://api.openai.com/v1", apiKeyEnv: "OMB_OPENAI_API_KEY", catalog: "openai" },
+    },
+    [CLAUDE_API_INSTANCE]: {
+        driver: "claudeAgent", displayName: "Claude (API key)", access: "api", icon: { kind: "preset", preset: "anthropic" },
+        config: { requireApiKey: true },
+    },
+    [XAI_API_INSTANCE]: { driver: "grok", displayName: "xAI", access: "api", icon: { kind: "preset", preset: "xai" } },
+    [OPENROUTER_API_INSTANCE]: {
+        driver: "openai-compat", displayName: "OpenRouter", access: "api", icon: { kind: "preset", preset: "openrouter" },
+        config: { url: "https://openrouter.ai/api/v1", apiKeyEnv: "OMB_OPENROUTER_API_KEY" },
+    },
+};
 // Default fleet: one instance per built-in driver (upstream
 // defaultInstanceIdForDriver — instanceId defaults to the driver kind).
 // Config-file keys are injected as per-instance environment so drivers
@@ -1318,11 +1447,13 @@ export function instanceConfigs(cfg) {
         cursor: { driver: "cursorAgent" },
         claude: { driver: "claudeAgent" },
         codex: { driver: "codex" },
+        chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         antigravity: { driver: "antigravityAgent" },
         opencodeGo: { driver: "opencodeGo" },
         computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        ...API_KEY_FLEET,
         qwen: { driver: "qwenAgent" },
         hermes: { driver: "hermesAgent" },
         pi: { driver: "piAgent" },
@@ -1336,9 +1467,11 @@ export function instanceConfigs(cfg) {
     // never see. Custom-only engines stay in CUSTOM_ONLY so a one-off test map
     // is not expanded, matching the claude/grok/codex product-fleet probe.
     const PRODUCT_FLEET_ADDITIONS = {
+        chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         cursor: { driver: "cursorAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        ...API_KEY_FLEET,
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;
@@ -1352,6 +1485,22 @@ export function instanceConfigs(cfg) {
                 map[id] = { ...entry };
         }
     }
+    // A saved `instances` map (any engine edit persists the whole fleet) keeps
+    // these entries without their built-in routing. Re-apply it on every load
+    // so the OpenAI and OpenRouter instances can never fall back to the shared
+    // OpenAI-compatible key and URL; saved fields still win.
+    for (const [id, builtIn] of Object.entries(API_KEY_FLEET)) {
+        const saved = map[id];
+        if (!saved || saved.driver !== builtIn.driver)
+            continue;
+        const savedConfig = typeof saved.config === "object" && saved.config !== null && !Array.isArray(saved.config) ? saved.config : {};
+        map[id] = { ...builtIn, ...saved, config: { ...builtIn.config, ...savedConfig } };
+    }
+    if (map.chatgpt?.driver === "codex" && !map.chatgpt.config?.cli) {
+        const cli = map.codex?.config?.cli;
+        if (typeof cli === "string" && cli)
+            map.chatgpt = { ...map.chatgpt, config: { ...map.chatgpt.config, cli } };
+    }
     for (const [id, sourceEntry] of Object.entries(map)) {
         // instanceConfigs() builds a transient runtime map. Never mutate the
         // caller's persisted entries while injecting workspace defaults: doing so
@@ -1359,14 +1508,25 @@ export function instanceConfigs(cfg) {
         const entry = { ...sourceEntry };
         map[id] = entry;
         const environment = { ...entry.environment };
-        for (const [key, value] of injectedEnvironment(cfg, entry.driver))
-            environment[key] = value;
+        // Main's rule: an instance that brought its own key or host gets no
+        // workspace credential. Built-in per-provider routing is a default,
+        // not an override, but saved custom routing on those IDs still owns its
+        // credential rather than receiving the workspace's provider key.
+        const builtIn = API_KEY_FLEET[id];
+        const routingDefaults = builtIn?.driver === entry.driver
+            ? builtIn.config
+            : undefined;
+        const ownsRouting = instanceOwnsRouting(cfg, entry, routingDefaults);
+        if (!ownsRouting) {
+            for (const [key, value] of injectedEnvironment(cfg, id, entry.driver))
+                environment[key] = value;
+        }
         entry.environment = environment;
         // The driver URL is configuration, not a credential. Environment is
         // intentionally not consulted by ProviderRegistry when it decodes a
         // driver's config, so carry the workspace default into the transient
         // instance map while preserving a per-instance override.
-        if (entry.driver === "openai-compat" && cfg.openaiCompat) {
+        if (entry.driver === "openai-compat" && cfg.openaiCompat && id !== OPENAI_API_INSTANCE && id !== OPENROUTER_API_INSTANCE) {
             const defaults = {};
             if (cfg.openaiCompat.url)
                 defaults.url = cfg.openaiCompat.url;

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

@@ -408,7 +408,7 @@ export function cuaExecArgs(args, options = {}) {
         ...args,
     ];
 }
-export async function containerComputerStatus(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET) {
+export async function containerComputerStatus(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET, options = {}) {
     const status = emptyStatus(platform, target);
     const runtimeStatus = await containerRuntimeStatus(runner, platform);
     status.available = runtimeStatus.available;
@@ -475,7 +475,8 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
     catch {
         // No container with this name.
     }
-    const canProbe = status.container === "running" &&
+    const canProbe = options.probeDesktop !== false &&
+        status.container === "running" &&
         status.imageMatches &&
         status.managed &&
         status.network === "loopback" &&

package/dist-server/server/desktop-viewer-targets.js

@@ -0,0 +1,26 @@
+import { desktopViewerUrl } from "./routes/desktop-viewer.js";
+export const viewerTargetId = (target) => `local/${target.key.replace(":", "-")}`;
+/** Native owner windows keep the existing direct viewer and cookie isolation. */
+export function localVmViewerStatus(status, auth) {
+    return auth.kind === "loopback" ? status : {
+        ...status,
+        viewer_url: status.viewer_url ? desktopViewerUrl(viewerTargetId({ key: status.target_key })) : "",
+    };
+}
+export function localDesktopTarget(target, deps) {
+    return {
+        key: target.key,
+        async resolve() {
+            const status = await deps.status(target);
+            if (!status.managed || !status.imageMatches || status.network !== "loopback" || status.container !== "running"
+                || !status.viewer_url) {
+                throw Object.assign(new Error("Local VM unavailable"), { status: 409 });
+            }
+            return {
+                port: status.viewer_port ?? 0,
+                password: new URLSearchParams(new URL(status.viewer_url).hash.slice(1)).get("password"),
+                touch: () => deps.touch(target),
+            };
+        },
+    };
+}