openmausbot 0.1.76 → 0.1.77

package/dist-server/server/agent-tool-policy.js

@@ -7,6 +7,7 @@
 export const READ_ONLY_AGENT_TOOL_NAMES = new Set([
     "list_bots",
     "list_team_setup",
+    "list_shared_computers",
     "list_rooms",
     "list_threads",
     "check_delegation",

package/dist-server/server/browser-live.js

@@ -564,6 +564,9 @@ export class BrowserLive {
     closeForSession(session) { for (const viewer of this.viewers.values())
         if (viewer.session === session)
             this.close(viewer); }
+    closeForOwner(owner) { for (const viewer of this.viewers.values())
+        if (viewer.owner === owner)
+            this.close(viewer); }
     closeForBot(botId) { for (const viewer of this.viewers.values())
         if (viewer.botId === botId)
             this.close(viewer); }

package/dist-server/server/config.js

@@ -208,6 +208,10 @@ const featureConfigSchema = z.object({
     /** Experimental built-in browser. Off until explicitly enabled; each bot
      * also has its own switch. */
     browser: z.boolean().optional(),
+    /** Opt-in computer sharing (a desktop lending folders, a terminal or
+     * computer control to a workspace). Off until explicitly enabled; there is
+     * no Settings toggle — see sharedComputersEnabled. */
+    sharedComputers: z.boolean().optional(),
 });
 /** First-run progress. Kept in the workspace config rather than a browser so
  * it survives cleared site data and is shared by every paired client. Hint
@@ -435,6 +439,18 @@ export function showToolCallsEnabled(cfg) {
 export function builtInBrowserEnabled(cfg) {
     return cfg.features?.browser === true;
 }
+/** Opt-in computer sharing: the routes, the agent tools, the advertised
+ * capability and the desktop connector. Off unless an explicit `true` turns
+ * it on, because the reviewed feature still has open security holes (a
+ * read-only folder grant could be escalated to a shell).
+ *
+ * Deliberately NOT a Settings toggle: this is a maintainer-only escape hatch
+ * for an unfinished feature, not a user preference. Someone who needs it
+ * enables it by hand in `~/.openmausbot/config.json`
+ * (`{"features": {"sharedComputers": true}}`) and restarts the server. */
+export function sharedComputersEnabled(cfg) {
+    return cfg.features?.sharedComputers === true;
+}
 /** Config sections no provider driver reads. A write that touches only
  * these must not rebuild the fleet: rebuilding disposes every engine child
  * and reloads it, seconds of work that would also interrupt in-flight

package/dist-server/server/drivers/acp/core.js

@@ -35,7 +35,7 @@ import { supportsApprovalMode } from "../../../shared/approval-mode.js";
 // packaged server dir entirely. See server/proxy-paths.ts.
 const COMPUTER_PROXY_PATH = SPAWNED_PROXIES.computer;
 import { appendNative } from "../native.js";
-import { commandSummary } from "../../tool-summary.js";
+import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
 import { SPAWNED_PROXIES } from "../../proxy-paths.js";
 const envOr = (key, fallback) => Number(process.env[key] ?? fallback);
 const INIT_TIMEOUT = envOr("OPENMAUS_ACP_INIT_TIMEOUT_MS", 300_000);
@@ -620,6 +620,7 @@ export function createAcpDriver(support) {
                                 itemId: u.toolCallId,
                                 title: String(u.rawInput?.command ?? u.title ?? "tool").slice(0, 80),
                                 summary: commandSummary(u.rawInput),
+                                input: toolDetailPreview(u.rawInput),
                             });
                             break;
                         }
@@ -631,6 +632,7 @@ export function createAcpDriver(support) {
                                     itemType: "tool",
                                     itemId: u.toolCallId,
                                     ok: u.status !== "failed",
+                                    output: toolDetailPreview(u.rawOutput ?? u.content),
                                 });
                             }
                             break;

package/dist-server/server/drivers/agents-proxy.js

@@ -43,6 +43,9 @@ const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
 const TOKEN = process.env.OMB_COMMS_TOKEN ?? "";
 const DEPTH = Number(process.env.OMB_TURN_DEPTH ?? "0") || 0;
 const SKILL_AUTHORING_ENABLED = process.env.OMB_SKILL_AUTHORING_ENABLED === "1";
+// Opt-in computer sharing (server features.sharedComputers). Off unless the
+// harness says "1", the same way skill authoring is gated above.
+const SHARED_COMPUTERS_ENABLED = process.env.OMB_SHARED_COMPUTERS_ENABLED === "1";
 const MAX_CREATED_PER_TURN = 4;
 let createdThisTurn = 0;
 // Same spirit as MAX_CREATED_PER_TURN above and MAX_QUEUED_PER_THREAD in
@@ -343,6 +346,20 @@ const ROUTINE_FIELDS_SCHEMA = {
     },
 };
 const TOOLS = [
+    {
+        name: "list_shared_computers",
+        description: "List online desktop computers explicitly shared with this workspace, and their allowed folders/capabilities. These are the user's computers, not this server. An offline or unshared computer cannot be accessed. Folder paths use opaque folder IDs and relative paths.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "shared_computer",
+        description: "Use a desktop explicitly shared by the user. Discover computer_id and folder_id with list_shared_computers. list_files/read_file/write_file are confined to chosen folders; paths are relative. read_file returns sha256; overwriting requires expected_sha256. Binary files support base64 encoding. run_command requires a SEPARATE unrestricted terminal grant. computer_tools lists the native computer-control tools; computer_call invokes one with arguments and needs a SEPARATE computer-control grant. Never substitute the server's filesystem when this desktop is offline. Actions are not retried automatically; inspect an uncertain outcome before retrying.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {
+                computer_id: { type: "string" }, action: { type: "string", enum: ["list_files", "read_file", "write_file", "run_command", "computer_tools", "computer_call"] },
+                folder_id: { type: "string" }, path: { type: "string" }, content: { type: "string" }, encoding: { type: "string", enum: ["utf8", "base64"] }, expected_sha256: { type: "string" },
+                command: { type: "string" }, tool_name: { type: "string" }, arguments: { type: "object", additionalProperties: true },
+            }, required: ["computer_id", "action"] },
+    },
     {
         name: "list_room_targets",
         description: "Discover actual OpenMausBot teammates and rooms in your allowed teams. Works in a normal bot conversation too; no room is required. Returns bot and room IDs, roles and working folders, never other conversations' history. Use these bots, not native coding helpers with similar names, when the user asks their team to work together.",
@@ -753,15 +770,30 @@ const SKILL_TOOL_NAMES = new Set(["skills_list", "skill_manage"]);
 const AUTHORING_TOOLS = SKILL_AUTHORING_ENABLED
     ? TOOLS
     : TOOLS.filter((tool) => !SKILL_TOOL_NAMES.has(tool.name));
+// A workspace with computer sharing off refuses the routes behind these two,
+// so they must not be advertised at all: a model that sees a tool it cannot
+// use spends turns discovering that.
+const SHARED_COMPUTER_TOOL_NAMES = new Set(["list_shared_computers", "shared_computer"]);
+const SHAREABLE_TOOLS = SHARED_COMPUTERS_ENABLED
+    ? AUTHORING_TOOLS
+    : AUTHORING_TOOLS.filter((tool) => !SHARED_COMPUTER_TOOL_NAMES.has(tool.name));
 // One teamwork path in room turns; keep all unrelated integrations available.
 // Ordinary direct chats use this same bounded coordinator. Goal-owned turns
 // retain their independent loop and cannot start a second coordinator.
 const ROOM_ONLY_TOOLS = new Set(["list_room_targets", "coordinate_bots"]);
 const ROOM_REPLACED_TOOLS = new Set(["ask_bot", "delegate_bot", "check_delegation", "wait_delegation", "start_thread", "send_to_thread", "wait_thread"]);
 const COORDINATING = process.env.OMB_ROOM_TURN === "1";
+const OWN_THREAD_CREATION = process.env.OMB_OWN_THREAD_CREATION === "1";
 const AVAILABLE_TOOLS = COORDINATING
-    ? AUTHORING_TOOLS.filter(tool => !ROOM_REPLACED_TOOLS.has(tool.name))
-    : AUTHORING_TOOLS.filter(tool => !ROOM_ONLY_TOOLS.has(tool.name));
+    ? SHAREABLE_TOOLS.filter(tool => !ROOM_REPLACED_TOOLS.has(tool.name) || (tool.name === "start_thread" && OWN_THREAD_CREATION))
+        .map(tool => tool.name === "start_thread" ? {
+        ...tool,
+        description: "Open a separate job on yourself with its own history and run, without switching the person's selected conversation. Use only when the user requests independent jobs (for example one review per pull request). Give a short specific title and complete instructions; you can open at most five per turn. This is not a teammate handoff: use coordinate_bots for teammates and their automatic replies. Self-opened jobs cannot recursively open more jobs. If refused, do not retry; explain what remains.",
+        inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties,
+                bot_id: { type: "string", enum: [BOT_ID], description: "Leave out, or use your own bot ID. For teammates use coordinate_bots." },
+            } },
+    } : tool)
+    : SHAREABLE_TOOLS.filter(tool => !ROOM_ONLY_TOOLS.has(tool.name));
 const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
 const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
 const rpcErr = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
@@ -1089,6 +1121,9 @@ async function callTool(name, args) {
             };
         }
         const toBotId = typeof args.bot_id === "string" ? args.bot_id.trim() : "";
+        if (COORDINATING && toBotId && toBotId !== BOT_ID) {
+            return { text: "Use coordinate_bots for teammates; start_thread only opens a separate job on yourself.", isError: true };
+        }
         const folder = typeof args.folder === "string" ? args.folder.trim() : "";
         const body = { fromBotId: BOT_ID, fromThreadId: THREAD_ID, title, message, depth: DEPTH };
         if (toBotId)
@@ -1550,6 +1585,27 @@ async function handle(msg) {
             if (!AVAILABLE_TOOLS.some((t) => t.name === name))
                 return rpcErr(id, -32602, `Unknown tool: ${name}`);
             try {
+                // Second lock. With sharing off the tool is not in AVAILABLE_TOOLS, so
+                // a call is already refused above as an unknown tool — the same answer
+                // a build without the feature gives. This keeps the handler itself
+                // refusing if that list is ever assembled differently.
+                if (SHARED_COMPUTER_TOOL_NAMES.has(name) && !SHARED_COMPUTERS_ENABLED) {
+                    textResult(id, "Computer sharing is turned off in this workspace. There are no shared computers to use.", true);
+                    return;
+                }
+                if (name === "list_shared_computers") {
+                    textResult(id, JSON.stringify(await api("/api/internal/shared-computers")));
+                    return;
+                }
+                if (name === "shared_computer") {
+                    const response = await api("/api/internal/shared-computers", { method: "POST", body: JSON.stringify(params.arguments ?? {}) });
+                    const result = response.result;
+                    if (Array.isArray(result?.content))
+                        ok(id, result);
+                    else
+                        textResult(id, JSON.stringify(result));
+                    return;
+                }
                 const { text, isError } = await callTool(name, (params.arguments ?? {}));
                 textResult(id, text, isError);
             }

package/dist-server/server/drivers/boxagent.js

@@ -64,7 +64,7 @@ export const BoxAgentDriver = {
             const model = turn.model || MODELS.default;
             const prompt = [
                 turn.system,
-                "You are working on your own cloud computer — its desktop, Chrome, and shell are yours.",
+                "You are working on the assigned cloud computer — use its desktop, Chrome, and shell within the access described above.",
                 "",
                 turn.text,
             ]

package/dist-server/server/drivers/claude.js

@@ -21,7 +21,7 @@ import { ClaudeLoginController } from "./claude-login-auth.js";
 import { computerProxyEnv } from "../container-computer.js";
 import { gateServer, resultBudget } from "../mcp-gate-config.js";
 import { newEventId, newId } from "../contracts.js";
-import { askInputSummary, commandSummary } from "../tool-summary.js";
+import { askInputSummary, commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { applyClaudeInject, decodeInjectId, mergeLocalInject, probeLocalInjects, resolveInjectId, } from "./local-inject.js";
 import { appendNative } from "./native.js";
@@ -1396,6 +1396,7 @@ export const ClaudeDriver = {
                                     itemId: b.id,
                                     title: b.name,
                                     summary: commandSummary(b.input),
+                                    input: toolDetailPreview(b.input),
                                 });
                             }
                         }
@@ -1415,7 +1416,7 @@ export const ClaudeDriver = {
                     case "user":
                         for (const b of Array.isArray(o.message?.content) ? o.message.content : []) {
                             if (b.type === "tool_result") {
-                                emit({ ...base(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b.tool_use_id, ok: !b.is_error });
+                                emit({ ...base(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b.tool_use_id, ok: !b.is_error, output: toolDetailPreview(b.content) });
                             }
                         }
                         break;

package/dist-server/server/drivers/codex.js

@@ -22,7 +22,7 @@ import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
 import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
-import { commandSummary } from "../tool-summary.js";
+import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
 import { codexAccountEmail } from "./codex-identity.js";
@@ -799,6 +799,7 @@ export const CodexDriver = {
                                     itemId: item.id,
                                     title,
                                     summary: item.type === "commandExecution" ? commandSummary({ command: item.command }) : undefined,
+                                    input: toolDetailPreview(item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "mcpToolCall" ? item.arguments : item.type === "fileChange" ? item.changes : item.query),
                                 });
                             }
                             break;
@@ -839,6 +840,7 @@ export const CodexDriver = {
                                     itemType: "tool",
                                     itemId: item.id,
                                     ok: item.status !== "failed" && item.status !== "declined",
+                                    output: toolDetailPreview(item.type === "commandExecution" ? { output: item.aggregatedOutput, exitCode: item.exitCode } : item.type === "mcpToolCall" ? item.error ?? item.result : item.type === "fileChange" ? item.changes : item.action),
                                 });
                             }
                             else if (item.type === "reasoning") {

package/dist-server/server/drivers/pi.js

@@ -28,6 +28,7 @@ import { computerProxyEnv } from "../container-computer.js";
 import { augmentedPath } from "../env-path.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { SPAWNED_PROXIES } from "../proxy-paths.js";
+import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { EFFORT_LEVELS, newEventId, newId } from "../contracts.js";
 import { decodeInjectId, encodeInjectId, hostApiKey, localHost, mergeLocalInject, } from "./local-inject.js";
 import { appendNative } from "./native.js";
@@ -610,6 +611,8 @@ export const PiDriver = {
                             itemType: "tool",
                             itemId: evt.toolCallId,
                             title: String(evt.toolName ?? "tool").slice(0, 80),
+                            summary: commandSummary(evt.args),
+                            input: toolDetailPreview(evt.args),
                         });
                         return;
                     }
@@ -620,6 +623,7 @@ export const PiDriver = {
                             itemType: "tool",
                             itemId: evt.toolCallId,
                             ok: !evt.isError,
+                            output: toolDetailPreview(evt.result),
                         });
                         return;
                     }

package/dist-server/server/enterprise.js

@@ -27,6 +27,40 @@ const layerSchema = z.object({
 });
 const DEFAULT_DIR = join(SERVER_ROOT, "..", "enterprise");
 let current = { edition: "oss", features: [] };
+let workspaceAccessFactory;
+export function hostedWorkspaceConfigured(env = process.env) {
+    return env.OMB_ADMIN_URL !== undefined || env.OMB_ADMIN_WORKSPACE !== undefined || env.OMB_ADMIN_MEMBERSHIP !== undefined;
+}
+/** Validate the operator's complete hosted configuration before any session
+ * can delegate membership authority. A partial setting is never standalone. */
+export function hostedWorkspaceConfiguration(env = process.env) {
+    try {
+        const origin = (raw) => {
+            if (!raw || raw !== raw.trim())
+                throw new Error("missing origin");
+            const url = new URL(raw);
+            if (url.protocol !== "https:" || (raw !== url.origin && raw !== `${url.origin}/`))
+                throw new Error("invalid origin");
+            return url;
+        };
+        if (!/^[a-z][a-z0-9-]{1,30}$/.test(env.OMB_ADMIN_WORKSPACE ?? ""))
+            return null;
+        if (env.OMB_ADMIN_MEMBERSHIP !== undefined && !["local", "portal"].includes(env.OMB_ADMIN_MEMBERSHIP))
+            return null;
+        return { admin: origin(env.OMB_ADMIN_URL), tenant: origin(env.OMB_PUBLIC_URL), workspace: env.OMB_ADMIN_WORKSPACE, portalMembership: env.OMB_ADMIN_MEMBERSHIP === "portal" };
+    }
+    catch {
+        return null;
+    }
+}
+/** No enterprise import or portal dependency enters the core bundle. A
+ * configured server without this hook must refuse hosted access, not fall
+ * back to legacy email or QR credentials. */
+export function createWorkspaceAccess(options) {
+    if (!hostedWorkspaceConfigured(options.env))
+        return null;
+    return workspaceAccessFactory?.({ ...options, entitled: () => entitled("admin") }) ?? null;
+}
 function oss(notice) {
     current = notice ? { edition: "oss", features: [], notice } : { edition: "oss", features: [] };
     return current;
@@ -34,6 +68,7 @@ function oss(notice) {
 /** Resolve the edition once at startup. Never throws: a broken layer or key
  * degrades to the open-source edition with a notice that says what to fix. */
 export async function loadEnterpriseLayer(options = {}) {
+    workspaceAccessFactory = undefined;
     const dir = options.dir ?? process.env.OMB_ENTERPRISE_DIR ?? DEFAULT_DIR;
     const licenseKey = options.licenseKey ?? process.env.OMB_LICENSE_KEY;
     // Source in a checkout, a compiled bundle in an image: same convention as proxy-paths.ts.
@@ -43,6 +78,9 @@ export async function loadEnterpriseLayer(options = {}) {
     }
     try {
         const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href));
+        const access = Reflect.get(Object(loaded), "createWorkspaceAccess");
+        if (typeof access === "function")
+            workspaceAccessFactory = access;
         const register = Reflect.get(Object(loaded), "register");
         if (typeof register !== "function")
             throw new Error(`${entry} does not export register()`);

package/dist-server/server/environment.js

@@ -99,6 +99,9 @@ export function environmentDescriptor(input) {
         version: serverVersion(),
         capabilities: {
             remoteSessions: true,
+            // Never advertise a protocol this server would refuse: the routes are
+            // gone unless features.sharedComputers is on, so the capability is too.
+            ...(input.sharedComputers === true ? { sharedComputers: true } : {}),
             selfUpdate: input.desktopManaged ? "desktop-managed" : "operator",
             emailSignIn: input.emailSignIn === true,
         },

package/dist-server/server/fleet-agent.js

@@ -6,9 +6,8 @@
 import { appendFileSync, chmodSync, existsSync, mkdirSync, rmSync } from "node:fs";
 import { createServer } from "node:http";
 import { dirname } from "node:path";
-import { defaultFleetDeps, executePlan, loadRegistry, planFleetAction } from "./fleet-cli.js";
-import { assertSlug, fleetLayout, workspaceDataDir } from "./fleet.js";
-import { readUsage, summarizeUsage } from "./usage-ledger.js";
+import { defaultFleetDeps, executePlan, loadRegistry, markProvisioningFailed, planFleetAction } from "./fleet-cli.js";
+import { assertSlug, fleetLayout, fleetUser, openRouterModelIds, workspaceDataDir } from "./fleet.js";
 const MAX_BODY = 256 * 1024;
 function readBody(req) {
     return new Promise((resolve, reject) => {
@@ -35,11 +34,23 @@ function readBody(req) {
 const strings = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : []);
 const text = (value) => (typeof value === "string" && value.trim() ? value.trim() : undefined);
 const number = (value) => (typeof value === "number" && Number.isFinite(value) ? value : undefined);
-/** This month's totals from a workspace's own ledger, read as root. */
-export function workspaceUsage(layout, slug, now) {
-    const from = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
-    const total = summarizeUsage(readUsage(workspaceDataDir(layout, slug), { from, to: now }), "bot").total;
-    return { month: now.toISOString().slice(0, 7), turns: total.turns, costUsd: total.costUsd, billableUsd: total.billableUsd };
+const models = (value) => {
+    try {
+        return openRouterModelIds(value);
+    }
+    catch (error) {
+        throw Object.assign(error, { status: 400 });
+    }
+};
+/** Only bounded, unprivileged aggregates cross back into the root process. */
+export function workspaceUsage(layout, slug, now, deps) {
+    const month = now.toISOString().slice(0, 7);
+    try {
+        return { month, ...deps.usage(workspaceDataDir(layout, slug), fleetUser(slug), now) };
+    }
+    catch {
+        return { month, turns: null, costUsd: null, billableUsd: null, unavailable: true };
+    }
 }
 export function createFleetAgent(options) {
     const deps = options.deps ?? defaultFleetDeps();
@@ -59,7 +70,7 @@ export function createFleetAgent(options) {
             /* the audit line must never fail the action it records */
         }
     };
-    const act = async (input) => {
+    const runAction = async (input) => {
         const log = [];
         const errors = [];
         const io = { log: (line) => log.push(line), error: (line) => errors.push(line) };
@@ -71,10 +82,32 @@ export function createFleetAgent(options) {
             audit({ action: input.action, slug: input.slug, ok: false, error: error instanceof Error ? error.message : String(error) });
             return { status: 400, body: { error: error instanceof Error ? error.message : String(error) } };
         }
-        const code = await executePlan(steps, deps, io);
+        let code = 1;
+        try {
+            code = await executePlan(steps, deps, io);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+        if (code !== 0) {
+            try {
+                markProvisioningFailed(input, deps);
+            }
+            catch {
+                errors.push("could not record the failed provisioning; inspect the reserved workspace before recovery");
+            }
+        }
         audit({ action: input.action, slug: input.slug, ok: code === 0, ...(input.email ? { email: input.email } : {}) });
         return code === 0 ? { status: 200, body: { ok: true, log } } : { status: 500, body: { error: errors[0] ?? "the step failed", log: [...log, ...errors] } };
     };
+    // Planning reads the registry too: serialize the entire read/modify/execute
+    // sequence, not just the subprocesses, so ports and updates cannot collide.
+    let mutationTail = Promise.resolve();
+    const act = (input) => {
+        const result = mutationTail.then(() => runAction(input));
+        mutationTail = result.catch(() => { });
+        return result;
+    };
     const handle = async (req, res) => {
         const url = new URL(req.url ?? "/", "http://fleet");
         const method = req.method ?? "GET";
@@ -87,10 +120,13 @@ export function createFleetAgent(options) {
                 return send(200, { ok: true });
             if (method === "GET" && url.pathname === "/workspaces") {
                 const registry = loadRegistry(layout, deps);
+                const statusOnly = url.searchParams.get("statusOnly") === "true";
                 const workspaces = [];
                 for (const workspace of Object.values(registry.workspaces).sort((a, b) => a.slug.localeCompare(b.slug))) {
-                    const live = (await deps.run(["systemctl", "is-active", `openmausbot@${workspace.slug}.service`])).output.trim() || "unknown";
-                    workspaces.push({ ...workspace, live, usage: workspaceUsage(layout, workspace.slug, now()) });
+                    const live = workspace.status === "running" || workspace.status === "suspended"
+                        ? (await deps.run(["systemctl", "is-active", `openmausbot@${workspace.slug}.service`])).output.trim() || "unknown"
+                        : workspace.status;
+                    workspaces.push(statusOnly ? { slug: workspace.slug, live } : { ...workspace, live, usage: workspaceUsage(layout, workspace.slug, now(), deps) });
                 }
                 return send(200, { domain: registry.domain, operator: registry.operator ?? null, workspaces });
             }
@@ -99,6 +135,9 @@ export function createFleetAgent(options) {
                 const result = await act({
                     ...base(), action: "create", slug: text(body.slug), admins: strings(body.admins), members: strings(body.members),
                     cap: number(body.cap), memory: text(body.memory), brandJson: text(body.brandJson), anthropicKey: text(body.anthropicKey),
+                    portalUrl: text(body.portalUrl), anthropicUrl: text(body.anthropicUrl),
+                    openrouterKey: text(body.openrouterKey), openrouterUrl: text(body.openrouterUrl),
+                    openrouterModels: body.openrouterModels === undefined ? undefined : models(body.openrouterModels), openrouterDefault: body.openrouterDefault === true,
                 });
                 return send(result.status, result.body);
             }
@@ -106,11 +145,16 @@ export function createFleetAgent(options) {
                 const result = await act({ ...base(), action: "upgrade" });
                 return send(result.status, result.body);
             }
-            const match = /^\/workspaces\/([a-z0-9-]+)(?:\/(users|suspend|resume))?$/.exec(url.pathname);
+            const match = /^\/workspaces\/([a-z0-9-]+)(?:\/(users|providers|suspend|resume))?$/.exec(url.pathname);
             if (match) {
                 const slug = match[1];
                 assertSlug(slug);
                 const sub = match[2];
+                if (method === "POST" && sub === "providers") {
+                    const body = await readBody(req);
+                    const result = await act({ ...base(), action: "providers", slug, openrouterModels: models(body.models) });
+                    return send(result.status, result.body);
+                }
                 if (method === "POST" && sub === "users") {
                     const body = await readBody(req);
                     const action = body.action === "remove" ? "remove" : body.action === "add" ? "add" : undefined;