openmausbot 0.1.97 → 0.1.98

package/dist-server/server/drivers/device-auth.js

@@ -0,0 +1,342 @@
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { deviceSignInPrompt } from "../../shared/device-sign-in.js";
+import { killCliTree, spawnCli } from "../procs.js";
+const MAX_OUTPUT = 16_384;
+// Two configured instances can use the same on-disk login. Only the auth
+// operation is exclusive: normal turns are not blocked by this lock.
+const authenticatingHomes = new Set();
+/** The real path of a credential home, so two spellings of one home share
+ * one sign-in lock. A missing tail keeps its name under its real parent. */
+export function canonicalPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        const parent = dirname(path);
+        return parent === path ? path : join(canonicalPath(parent), basename(path));
+    }
+}
+/** A fixed login command, not a remotely accessible terminal. CLI output
+ * stays in bounded private memory; only a device page and code are exposed. */
+export class DeviceAuthController {
+    flow = null;
+    command = null;
+    disposed = false;
+    spec;
+    options;
+    constructor(spec, options) {
+        this.spec = spec;
+        this.options = options;
+    }
+    /** The credential home the lock is held on, for this environment. */
+    home(env, action) {
+        const { homeEnv, homeDir, product } = this.spec;
+        const home = env.HOME || env.USERPROFILE || homedir();
+        const named = env[homeEnv];
+        if (!isAbsolute(home) || (named && !isAbsolute(named))) {
+            throw new Error(`Use an absolute HOME and ${homeEnv} path for this server's ${product} provider before ${action}.`);
+        }
+        return { home, homeKey: canonicalPath(resolve(named || join(home, homeDir))) };
+    }
+    async start() {
+        const { product, account, status } = this.spec;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing in.");
+        if (this.flow?.status.phase === "waiting") {
+            if (this.flow.ready)
+                return { ...this.flow.status, phase: "waiting" };
+            throw new Error(`A ${account} sign-in is already starting. Please wait for the code.`);
+        }
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing in.");
+        const env = this.options.environment();
+        const { home, homeKey } = this.home(env, "signing in");
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error(`A ${account} sign-in is already running for this server account. Finish or cancel it before starting another.`);
+        }
+        authenticatingHomes.add(homeKey);
+        return new Promise((resolveStart, reject) => {
+            const flow = {
+                status: {
+                    phase: "waiting", flowId: randomUUID(), authorizationUrl: null,
+                    expiresAt: new Date(Date.now() + (this.options.lifetimeMs ?? 15 * 60_000)).toISOString(),
+                },
+                child: null, ready: false, resolve: resolveStart, reject, homeKey,
+                startupTimer: setTimeout(() => this.finish(flow, "failed", `${product} did not provide a sign-in code in time. Check the server connection and update ${product}, then try again.`), this.options.startupTimeoutMs ?? 30_000),
+                expiryTimer: setTimeout(() => this.finish(flow, "expired", `The ${account} sign-in code expired. Start sign-in again.`), this.options.lifetimeMs ?? 15 * 60_000),
+            };
+            flow.startupTimer.unref();
+            flow.expiryTimer.unref();
+            this.flow = flow;
+            const login = () => this.run(flow, [...this.spec.loginArgs], env, home, (loginCode, loginOutput) => {
+                if (loginCode !== 0 || !flow.ready) {
+                    this.finish(flow, "failed", this.spec.failure(loginOutput));
+                    return;
+                }
+                // A successful command is not enough: confirm the sign-in the way
+                // this client's bots will find it, with the same executable and
+                // environment.
+                flow.startupTimer = setTimeout(() => this.finish(flow, "failed", `${product} finished sign-in but could not confirm the account. Refresh Settings and try again.`), this.options.startupTimeoutMs ?? 30_000);
+                flow.startupTimer.unref();
+                this.confirm(flow, env, home, (signedIn) => this.finish(flow, signedIn ? "succeeded" : "failed", `${product} finished sign-in but did not confirm a ${account} account. Refresh Settings and try again.`));
+            }, true);
+            // Never overwrite a working login just because Connect was clicked twice.
+            if (!status) {
+                login();
+                return;
+            }
+            this.run(flow, [...status.args], env, home, (code, output) => {
+                const state = status.read(code, output);
+                if (state === "signed-in")
+                    this.finish(flow, "succeeded");
+                else if (state === "other")
+                    this.finish(flow, "failed", `${product} already has a different sign-in method on this server. Ask the server administrator to review it before changing accounts.`);
+                else if (state === "signed-out")
+                    login();
+                else
+                    this.finish(flow, "failed", `${product} could not confirm the existing sign-in on this server. Update ${product} and check its login status before trying again.`);
+            });
+        });
+    }
+    async get(flowId) {
+        if (!flowId || this.flow?.status.flowId !== flowId)
+            throw new Error("This sign-in is no longer available. Start sign-in again.");
+        return { ...this.flow.status };
+    }
+    async cancel() {
+        if (this.flow?.status.phase === "waiting")
+            this.finish(this.flow, "cancelled", `${this.spec.account} sign-in cancelled.`);
+        await this.flow?.stopping;
+        if (this.flow?.terminationFailed)
+            throw new Error(this.flow.status.message);
+        if (this.command && !await this.stopChild(this.command)) {
+            throw new Error(`${this.spec.product} could not be stopped on this server. Ask the server administrator to stop the account command before trying again.`);
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+        await this.cancel();
+        this.flow = null;
+    }
+    /** Remove the sign-in the CLI stores for this server account so a
+     * different account can connect. A sign-in in progress is never pulled
+     * away underneath the browser completing it. */
+    async signOut() {
+        const { product, account, status, logoutArgs } = this.spec;
+        if (!status || !logoutArgs)
+            throw new Error(`Signing out of ${account} is not available from here.`);
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        if (this.flow?.status.phase === "waiting")
+            throw new Error(`Finish or cancel the ${account} sign-in in progress before signing out.`);
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        const env = this.options.environment();
+        const { home, homeKey } = this.home(env, "signing out");
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error(`A ${account} sign-in is running for this server account. Finish or cancel it before signing out.`);
+        }
+        authenticatingHomes.add(homeKey);
+        try {
+            const before = await this.exec([...status.args], env, home);
+            const state = status.read(before.code, before.output);
+            if (state === "signed-out")
+                return;
+            if (state !== "signed-in") {
+                throw new Error(`${product} did not confirm a ${account} sign-in. Other authentication methods will not be removed; ask the server administrator to check the account.`);
+            }
+            const logout = await this.exec([...logoutArgs], env, home);
+            if (logout.code !== 0)
+                throw new Error(`${product} could not remove the sign-in on this server. Check the server's ${product} installation and try again.`);
+            // The command's own report is not enough: confirm with the same status
+            // check that decides whether bots may run on this account.
+            const after = await this.exec([...status.args], env, home);
+            if (status.read(after.code, after.output) !== "signed-out") {
+                throw new Error(`${product} still reports a sign-in on this server. Update ${product} and check its login status before trying again.`);
+            }
+        }
+        finally {
+            // If the OS cannot stop a command, it may still change credentials.
+            // Keep the home reserved until that exact child actually exits.
+            const child = this.command;
+            if (child && child.exitCode === null && child.signalCode === null) {
+                child.once("close", () => authenticatingHomes.delete(homeKey));
+            }
+            else
+                authenticatingHomes.delete(homeKey);
+        }
+    }
+    /** After a login command succeeded: the status command when the CLI has
+     * one, else the stored sign-in a turn checks for. */
+    confirm(flow, env, home, done) {
+        const status = this.spec.status;
+        if (status) {
+            this.run(flow, [...status.args], env, home, (code, output) => done(status.read(code, output) === "signed-in"));
+            return;
+        }
+        let signedIn = false;
+        try {
+            signedIn = this.spec.signedIn?.(env) === true;
+        }
+        catch { /* unreadable: not signed in */ }
+        done(signedIn);
+    }
+    startFailure(error) {
+        const { product, install } = this.spec;
+        return error.code === "ENOENT"
+            ? `${product} is not installed on this server. ${install}`
+            : `${product} could not start on this server. Check the configured CLI path and its executable permissions.`;
+    }
+    /** One bounded, non-interactive command. Its output stays here; callers
+     * see an exit code and a status-line match, never the text. */
+    exec(args, env, cwd) {
+        const { product } = this.spec;
+        return new Promise((resolveExec, rejectExec) => {
+            if (this.disposed) {
+                rejectExec(new Error("This provider was removed. Refresh Settings before signing out."));
+                return;
+            }
+            let child;
+            try {
+                child = spawnCli(this.options.cli, args, { env: { ...env, NO_COLOR: "1" }, cwd, stdio: ["pipe", "pipe", "pipe"] });
+            }
+            catch {
+                rejectExec(new Error(`${product} could not start on this server. Install or update the configured ${product} CLI, then try again.`));
+                return;
+            }
+            this.command = child;
+            child.stdin.end();
+            let output = "";
+            const receive = (chunk) => {
+                if (output.length < MAX_OUTPUT)
+                    output += chunk.toString("utf8").slice(0, MAX_OUTPUT - output.length);
+            };
+            child.stdout.on("data", receive);
+            child.stderr.on("data", receive);
+            // A hung CLI must not hold the credential-home lock forever.
+            const timer = setTimeout(() => {
+                void this.stopChild(child).catch(() => false).then((stopped) => {
+                    if (!stopped)
+                        rejectExec(new Error(`${product} could not be stopped on this server. Ask the server administrator to stop the account command before trying again.`));
+                });
+            }, this.options.startupTimeoutMs ?? 30_000);
+            timer.unref();
+            child.once("error", (error) => {
+                clearTimeout(timer);
+                rejectExec(new Error(this.startFailure(error)));
+            });
+            child.once("close", (code) => {
+                clearTimeout(timer);
+                if (this.command === child)
+                    this.command = null;
+                resolveExec({ code, output: stripVTControlCharacters(output) });
+            });
+        });
+    }
+    run(flow, args, env, cwd, done, parsePrompt = false) {
+        const { product, provider } = this.spec;
+        if (flow.status.phase !== "waiting")
+            return;
+        let child;
+        try {
+            child = spawnCli(this.options.cli, args, { env: { ...env, NO_COLOR: "1" }, cwd, stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch {
+            this.finish(flow, "failed", `${product} could not start on this server. Install or update the configured ${product} CLI, then try again.`);
+            return;
+        }
+        flow.child = child;
+        child.stdin.end();
+        let output = "";
+        const receive = (chunk) => {
+            if (flow.status.phase !== "waiting")
+                return;
+            if (output.length + chunk.length > MAX_OUTPUT) {
+                this.finish(flow, "failed", `${product} returned an unexpected sign-in response. Update the server's ${product} CLI and try again.`);
+                return;
+            }
+            output += chunk.toString("utf8");
+            const prompt = parsePrompt && !flow.ready ? deviceSignInPrompt(provider, stripVTControlCharacters(output)) : null;
+            if (prompt) {
+                flow.status = { ...flow.status, ...prompt };
+                flow.ready = true;
+                clearTimeout(flow.startupTimer);
+                flow.resolve({ ...flow.status, phase: "waiting" });
+            }
+        };
+        child.stdout.on("data", receive);
+        child.stderr.on("data", receive);
+        child.once("error", (error) => this.finish(flow, "failed", this.startFailure(error)));
+        child.once("close", (code) => {
+            if (flow.child === child)
+                flow.child = null;
+            if (flow.status.phase === "waiting")
+                done(code, stripVTControlCharacters(output));
+            output = "";
+        });
+    }
+    finish(flow, phase, message) {
+        const { product, account } = this.spec;
+        if (flow.status.phase !== "waiting")
+            return;
+        clearTimeout(flow.startupTimer);
+        clearTimeout(flow.expiryTimer);
+        flow.status = {
+            phase, flowId: flow.status.flowId, authorizationUrl: null, expiresAt: null,
+            ...(phase !== "succeeded" && message ? { message } : {}),
+        };
+        if (!flow.ready) {
+            if (phase === "succeeded")
+                flow.resolve({ ...flow.status, phase });
+            else
+                flow.reject(new Error(message ?? `${account} sign-in did not finish.`));
+        }
+        flow.stopping = this.stopChild(flow.child).catch(() => false).then((stopped) => {
+            const release = () => authenticatingHomes.delete(flow.homeKey);
+            if (stopped) {
+                release();
+                return;
+            }
+            flow.terminationFailed = true;
+            flow.status = { ...flow.status, phase: "failed", message: `${product} could not be stopped on this server. Ask the server administrator to stop the login process before trying again.` };
+            // Retain the credential-home lock until the OS actually reports exit.
+            const child = flow.child;
+            if (!child || child.exitCode !== null || child.signalCode !== null)
+                release();
+            else
+                child.once("close", release);
+        });
+        if (phase === "succeeded")
+            void this.options.onAuthenticated?.().catch(() => { });
+    }
+    async stopChild(child) {
+        if (!child || await killCliTree(child, this.options.terminateTimeoutMs ?? 1500))
+            return true;
+        // A broken CLI may ignore SIGTERM. Do not leave a stale device flow able
+        // to write credentials after the user cancelled it.
+        if (process.platform !== "win32" && child.pid) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }
+        else
+            child.kill("SIGKILL");
+        await new Promise((resolveStop) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return resolveStop();
+            const timer = setTimeout(resolveStop, 1500);
+            timer.unref();
+            child.once("close", () => { clearTimeout(timer); resolveStop(); });
+        });
+        return child.exitCode !== null || child.signalCode !== null;
+    }
+}

package/dist-server/server/drivers/openai-chat.js

@@ -11,6 +11,7 @@ import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, object } from "
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { classifyContinuable, writeTurnHandoff } from "../turn-continuation.js";
+import { KEY_REJECTED_REASON, keyRejected, noteKeyAccepted, noteKeyRejected, rejectsKey } from "../key-rejections.js";
 /** The message of a JSON error body a provider returned with HTTP 200.
  *  MiniMax reports auth, balance, and parameter failures as `base_resp`. */
 function providerError(json) {
@@ -182,6 +183,8 @@ export function createOpenAIChatRuntime(options) {
             });
             if (!response.ok) {
                 const body = await response.text().catch(() => "");
+                if (rejectsKey(response.status, body))
+                    noteKeyRejected(options.apiUrl, options.apiKey);
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
@@ -193,6 +196,7 @@ export function createOpenAIChatRuntime(options) {
                 }
                 throw new Error(message);
             }
+            noteKeyAccepted(options.apiUrl, options.apiKey);
             if (!stream || response.headers.get("content-type")?.includes("application/json")) {
                 const json = await response.json();
                 if (onUsage) {
@@ -462,7 +466,7 @@ export function createOpenAIChatRuntime(options) {
                 if (!parsed.ok)
                     throw new Error(parsed.error);
                 const scope = parsed.scope;
-                tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse, scope);
+                tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse, scope, turn.mcpCallTimeoutMs);
                 const questionAllowed = options.tools !== false && allowsTool(scope, { kind: "native", name: ASK_USER_TOOL });
                 let optionalQuestionOnly = questionAllowed && tools.definitions.length === 0;
                 // The runtime's one built-in tool rides the same list: ask_user is
@@ -791,9 +795,13 @@ export function createOpenAIChatRuntime(options) {
             return options.models();
         },
         ...(options.refreshModels ? { refreshModels: options.refreshModels } : {}),
-        snapshot: async () => options.apiKey
-            ? { state: "available", authenticated: true, version: null, ...(options.billing ? { billing: options.billing } : {}) }
-            : { state: "unavailable", reason: options.unavailableReason },
+        snapshot: async () => {
+            if (!options.apiKey)
+                return { state: "unavailable", reason: options.unavailableReason };
+            if (keyRejected(options.apiUrl, options.apiKey))
+                return { state: "available", authenticated: false, reason: KEY_REJECTED_REASON, version: null };
+            return { state: "available", authenticated: true, version: null, ...(options.billing ? { billing: options.billing } : {}) };
+        },
         adapter: {
             provider: options.driverKind,
             capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,

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

@@ -9,15 +9,28 @@ import { dirname } from "node:path";
 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) {
+export function readBody(req) {
     return new Promise((resolve, reject) => {
-        let text = "";
+        const chunks = [];
+        let bytes = 0;
+        let tooLarge = false;
         req.on("data", (chunk) => {
-            text += chunk.toString("utf8");
-            if (text.length > MAX_BODY)
-                reject(Object.assign(new Error("request too large"), { status: 413 }));
+            if (tooLarge)
+                return;
+            bytes += chunk.length;
+            if (bytes > MAX_BODY) {
+                // Keep draining so the 413 can still be sent, but stop holding bytes.
+                tooLarge = true;
+                chunks.length = 0;
+                return reject(Object.assign(new Error("request too large"), { status: 413 }));
+            }
+            chunks.push(chunk);
         });
         req.on("end", () => {
+            if (tooLarge)
+                return;
+            // Decode once: a character split across two chunks stays whole.
+            const text = Buffer.concat(chunks).toString("utf8");
             if (!text.trim())
                 return resolve({});
             try {

package/dist-server/server/harness/http.js

@@ -20,7 +20,7 @@ export function json(res, status, body) {
 }
 export function readBody(req, limit = 1_000_000) {
     return new Promise((resolve, reject) => {
-        let data = "";
+        const chunks = [];
         let bytes = 0;
         let done = false;
         const fail = (status, msg) => {
@@ -40,11 +40,14 @@ export function readBody(req, limit = 1_000_000) {
                 // receiving the useful 413 response.
                 return fail(413, "body too large");
             }
-            data += c;
+            chunks.push(typeof c === "string" ? Buffer.from(c) : c);
         });
         req.on("end", () => {
             if (done)
                 return;
+            // Decode once, after the last chunk: a character split across two
+            // chunks turns into U+FFFD when each chunk is decoded on its own.
+            const data = Buffer.concat(chunks).toString("utf8");
             let body;
             try {
                 body = data ? JSON.parse(data) : {};

package/dist-server/server/harness/registry.js

@@ -35,6 +35,9 @@ export class ProviderRegistry {
     /** decoded per-instance `cli` overrides, for describe() — drivers spawn
      * from their own config; this map only reports what was configured */
     cliByInstance = new Map();
+    /** What describe() last read of each live instance. A turn's start checks
+     * a thread's own engine against it without waiting on that engine's CLI. */
+    lastSnapshots = new Map();
     driversByKind;
     /** Where Settings-driven npm installs go; the data directory by default. */
     enginesBaseDir;
@@ -100,6 +103,16 @@ export class ProviderRegistry {
     get(instanceId) {
         return this.byId.get(instanceId)?.live ?? null;
     }
+    /** The snapshot describe() last read of this live instance; absent before
+     * the first read, or for an instance that is not live. */
+    lastSnapshot(instanceId) {
+        return this.byId.get(instanceId)?.live ? this.lastSnapshots.get(instanceId) : undefined;
+    }
+    /** How the instance's driver is presented and paid for (EngineAccess). */
+    access(instanceId) {
+        const entry = this.byId.get(instanceId);
+        return entry ? this.driversByKind.get(entry.shadow?.driverKind ?? entry.live.driverKind)?.metadata.access ?? "subscription" : undefined;
+    }
     /** The configured executable for instance-scoped maintenance actions.
      * This deliberately comes from the registry/config, never an HTTP body. */
     cliTarget(instanceId) {
@@ -211,6 +224,10 @@ export class ProviderRegistry {
             catch (e) {
                 snapshot = { state: "unavailable", reason: e instanceof Error ? e.message : String(e) };
             }
+            // Only while this is still the live instance: a reload may have
+            // replaced it during the read.
+            if (this.byId.get(inst.instanceId)?.live === inst)
+                this.lastSnapshots.set(inst.instanceId, snapshot);
             return {
                 instanceId: inst.instanceId,
                 driverKind: inst.driverKind,
@@ -256,11 +273,13 @@ export class ProviderRegistry {
         await Promise.allSettled(this.instances().map((i) => i.dispose()));
         this.byId.clear();
         this.cliByInstance.clear();
+        this.lastSnapshots.clear();
     }
     async dispose(instanceId) {
         const entry = this.byId.get(instanceId);
         this.byId.delete(instanceId);
         this.cliByInstance.delete(instanceId);
+        this.lastSnapshots.delete(instanceId);
         await entry?.live?.dispose();
     }
 }

package/dist-server/server/harness-capabilities.js

@@ -9,10 +9,12 @@
 // never drifts from what a turn is actually shown.
 import { APPROVAL_MODES, supportsApprovalMode as driverKindSupportsApprovalMode } from "../shared/approval-mode.js";
 import { availableTools } from "./drivers/agents-catalog.js";
-/** The widest turn the harness can build: every optional integration on and
- * a coordinating (room) turn, where the room-only coordination tools exist.
- * Both sides of a comparison get the same profile; only the driver's own
- * capability can differ. */
+/** The widest turn the harness can build: every optional integration on, a
+ * Chief of Staff (the only role shown the Chief-only tools) and a
+ * coordinating (room) turn, where the room-only coordination tools exist.
+ * So the count is an upper bound, not one bot's catalog. Both sides of a
+ * comparison get the same profile; only the driver's own capability can
+ * differ. */
 const ENVELOPE = {
     externalRuntime: false,
     coordinating: true,
@@ -22,6 +24,7 @@ const ENVELOPE = {
     voiceNotes: true,
     // Not a tool it adds: a Cloud home only hides its Local VM shell.
     cloudHome: false,
+    chief: true,
     botId: "",
 };
 /** Extra card lines for an engine switch, empty when nothing changes. */

package/dist-server/server/hosted-models.js

@@ -138,12 +138,14 @@ export function hostedModelPolicy(dataDirectory, env = process.env) {
                 const previousDefault = bot.modelSelection;
                 const nextDefault = select(previousDefault);
                 for (const task of store.tasks(bot.id)) {
+                    // A thread without a model of its own follows the bot onto its
+                    // assigned model; a thread's own model is moved onto one itself.
                     const current = task.modelSelection ?? previousDefault;
                     const next = select(current);
                     const changed = JSON.stringify(next) !== JSON.stringify(current);
                     if (changed || changedRoute)
                         store.patchTask(bot.id, task.threadId, {
-                            modelSelection: next, resumeCursors: {}, lastInstanceId: undefined, rewound: true,
+                            ...(task.modelSelection ? { modelSelection: next } : {}), resumeCursors: {}, lastInstanceId: undefined, rewound: true,
                             lastContextModel: undefined, appliedCompactionId: undefined,
                         });
                 }