openmausbot 0.1.90 → 0.1.92

package/dist-server/server/cloud-secrets.js

@@ -0,0 +1,65 @@
+// The OMB Cloud home's secrets, and how the server gets them
+// (docs/cloud-pro.md). This module imports nothing but node:fs, so the
+// server can read them before anything else it loads can start a process
+// (cloud-secrets-boot.ts, the server's first import).
+import { closeSync, readFileSync } from "node:fs";
+/** The Cloud home's secrets: the signing secret and the included services'
+ * relay tokens (server/included-services.ts). The Admin sets them as Fly app
+ * secrets, which reach the machine as the launcher's environment; the
+ * launcher never puts them in a child's environment, because
+ * /proc/<pid>/environ keeps a process's starting environment for anything
+ * running as the same user to read. It hands them to the server over an
+ * inherited pipe instead (CLOUD_SECRETS_FD_ENV names its descriptor). */
+export const CLOUD_HOME_SECRET_KEYS = ["OMB_CLOUD_BOOTSTRAP_SECRET", "OMB_CLOUD_BOAT_TOKEN", "OMB_CLOUD_VOICE_TOKEN", "OMB_CLOUD_DECIDER_TOKEN"];
+export const CLOUD_SECRETS_FD_ENV = "OMB_CLOUD_SECRETS_FD";
+/** The secrets present in an environment (the launcher's). */
+export function cloudHomeSecrets(env) {
+    return Object.fromEntries(CLOUD_HOME_SECRET_KEYS.flatMap((key) => env[key] ? [[key, env[key]]] : []));
+}
+/** An environment with no Cloud home secret in it. */
+export function withoutCloudSecrets(env) {
+    const kept = { ...env };
+    for (const key of CLOUD_HOME_SECRET_KEYS)
+        delete kept[key];
+    return kept;
+}
+function invalid(why) {
+    throw new Error(`Cloud home configuration is invalid: ${why}.`);
+}
+/** At server startup: the secrets the launcher handed over its pipe (read
+ * to the end and closed, so no child inherits it), or none when the server
+ * was started another way and reads its environment as before. Only the
+ * known secret names are taken. */
+export function takeCloudSecrets(env = process.env) {
+    const named = env[CLOUD_SECRETS_FD_ENV];
+    if (named === undefined)
+        return {};
+    delete env[CLOUD_SECRETS_FD_ENV];
+    const fd = Number(named);
+    if (!Number.isInteger(fd) || fd < 3 || fd > 1024)
+        invalid(`${CLOUD_SECRETS_FD_ENV} must name an inherited descriptor`);
+    let raw;
+    try {
+        raw = readFileSync(fd, "utf8");
+    }
+    catch {
+        invalid("the Cloud home's secrets could not be read from the launcher");
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch { /* already closed */ }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        parsed = null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        invalid("the Cloud home's secrets from the launcher are not readable");
+    const record = parsed;
+    return Object.fromEntries(CLOUD_HOME_SECRET_KEYS.flatMap((key) => typeof record[key] === "string" && record[key] ? [[key, record[key]]] : []));
+}

package/dist-server/server/config.js

@@ -14,10 +14,14 @@ import { PROVIDER_ICON_PRESETS, providerIconError } from "../shared/provider-ico
 import { isRemoteMcpServer, parseStoredMcpServer } from "./mcp-registry.js";
 import { parseJson, schemaIssue } from "./schema.js";
 import { CLOUD_SEAT_IDLE_STOP_MS } from "./cloud-overflow.js";
+import { cloudHomeConfigured } from "./cloud-home.js";
 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;
@@ -35,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);
 }
@@ -111,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. */
@@ -301,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),
@@ -313,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);
@@ -372,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
@@ -411,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. */
@@ -428,6 +453,25 @@ 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
+     * write-only like every credential; `baseUrl` points at a Jev-compatible
+     * server instead of TypeSafe's (an operator setting with no UI); `jobs`
+     * switches each decision on or off. Not `decisions`: that section is the
+     * authorization log's retention. */
+    decider: z.object({
+        enabled: z.boolean().optional(),
+        provider: z.enum(["jev", "off"]).optional(),
+        key: optionalText,
+        baseUrl: z
+            .string()
+            .trim()
+            .max(2048)
+            .refine((value) => !value || /^https?:\/\//i.test(value), "the decision model address must start with http:// or https://")
+            .optional(),
+        jobs: z.object({ roomRouting: z.boolean().optional() }).optional(),
     }).optional(),
     /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
     imageGen: z.object({
@@ -619,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) {
@@ -645,9 +692,13 @@ export function routinesInConversationEnabled(cfg) {
     return cfg.features?.routinesInConversation === true;
 }
 /** Workspace-level gate for the experimental built-in browser. A bot's own
- * switch sits under it, so either can withhold the browser. */
-export function builtInBrowserEnabled(cfg) {
-    return cfg.features?.browser === true;
+ * switch sits under it, so either can withhold the browser. Off until the
+ * desktop's first-run welcome turns it on. A Cloud home (cloud-home.ts)
+ * skips that welcome, ships the browser in its image and has no other screen
+ * of its own, so there it is on unless the person switched it off. */
+export function builtInBrowserEnabled(cfg, env = process.env) {
+    const chosen = cfg.features?.browser;
+    return chosen === undefined ? cloudHomeConfigured(env) : chosen === true;
 }
 /** Opt-in computer sharing: the routes, the agent tools, the advertised
  * capability and the desktop connector. Off unless an explicit `true` turns
@@ -723,6 +774,8 @@ export const FLEET_NEUTRAL_KEYS = new Set([
     "profile",
     "language",
     "tts",
+    // no engine reads it: the harness asks it before a turn starts
+    "decider",
     "imageGen",
     "vps",
     "rooms",
@@ -842,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;
@@ -871,6 +930,9 @@ export function loadConfig() {
         cfg.tts.voice = presetVoice;
     if (process.env.OMB_FISH_AUDIO_API_KEY !== undefined)
         cfg.tts.fishKey = process.env.OMB_FISH_AUDIO_API_KEY;
+    cfg.decider = { ...cfg.decider };
+    if (process.env.OMB_JEV_API_KEY !== undefined)
+        cfg.decider.key = process.env.OMB_JEV_API_KEY;
     cfg.imageGen = { ...cfg.imageGen };
     if (process.env.OMB_OPENAI_IMAGE_KEY !== undefined)
         cfg.imageGen.key = process.env.OMB_OPENAI_IMAGE_KEY;
@@ -901,11 +963,14 @@ 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"],
         [patch.tts?.key, "OMB_TTS_KEY"],
         [patch.tts?.fishKey, "OMB_FISH_AUDIO_API_KEY"],
+        [patch.decider?.key, "OMB_JEV_API_KEY"],
         [patch.imageGen?.key, "OMB_OPENAI_IMAGE_KEY"],
         [patch.imageGen?.customApiKey, "OMB_CUSTOM_IMAGE_KEY"],
     ];
@@ -948,14 +1013,23 @@ 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",
     "OMB_FISH_AUDIO_API_KEY",
+    "OMB_JEV_API_KEY",
     "OMB_OPENAI_IMAGE_KEY",
     "OMB_CUSTOM_IMAGE_KEY",
     "COMPOSIO_API_KEY",
     "OMB_COMPOSIO_BROKER_TOKEN",
+    // Cloud Pro's included Boat, voice and decision relay tokens
+    // (included-services.ts), used only in-process by the Boat, voice and
+    // decider modules.
+    "OMB_CLOUD_BOAT_TOKEN",
+    "OMB_CLOUD_VOICE_TOKEN",
+    "OMB_CLOUD_DECIDER_TOKEN",
     // Harness-private filesystem hints are not credentials themselves, but
     // exposing them to a shell-capable agent points straight at app-owned
     // state. The built-in browser master is delivered privately in memory.
@@ -1037,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", "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;
@@ -1223,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);
@@ -1238,21 +1362,64 @@ 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.
     if (driver === "boxAgent" && cfg.box?.token)
         environment.set("BOX_TOKEN", cfg.box.token);
     if (driver === "opencodeGo" && cfg.opencodeGo?.apiKey)
         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
@@ -1280,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" },
@@ -1298,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;
@@ -1314,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
@@ -1321,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" &&