openmausbot 0.1.87 → 0.1.88

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

@@ -808,6 +808,66 @@ export async function containerComputerScreenshot(runner = sh, platform = proces
 }
 const screenshotStatusCache = new Map();
 const containerMcpPath = SPAWNED_PROXIES.containerMcp;
+const EXEC_DEFAULT_SECONDS = 60;
+const EXEC_MAX_SECONDS = 300;
+const EXEC_OUTPUT_LIMIT = 20_000;
+/** Keep the start and the end: a failure message is nearly always at the end. */
+export function clipExecOutput(text, limit = EXEC_OUTPUT_LIMIT) {
+    if (text.length <= limit)
+        return text;
+    const head = Math.floor(limit / 5);
+    return `${text.slice(0, head)}\n… ${text.length - limit} characters omitted …\n${text.slice(text.length - (limit - head))}`;
+}
+const defaultExecRunner = async (command, args, options) => {
+    const resolved = resolveCliSpawn(command, args);
+    try {
+        const { stdout, stderr } = await run(resolved.command, resolved.args, {
+            timeout: options.timeout,
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+            env: { ...process.env, PATH: augmentedPath() },
+        });
+        return { stdout, stderr, code: 0 };
+    }
+    catch (error) {
+        const failure = error;
+        // A non-zero exit still carries the output; anything else (runtime missing,
+        // client killed) is a real failure to run at all.
+        if (typeof failure.code === "number") {
+            return { stdout: failure.stdout ?? "", stderr: failure.stderr ?? "", code: failure.code };
+        }
+        throw Object.assign(new Error(failure.killed ? "the command client timed out" : failure.message ?? "could not run the command"), { status: 502 });
+    }
+};
+/** Run one shell command inside a Local VM as the desktop user, in its durable
+ * workspace, and return the exit code and text output. Bots use this instead of
+ * typing into a terminal window and reading screenshots. The limit is enforced
+ * inside the container so a runaway process is really stopped. */
+export async function containerExec(target, command, options = {}) {
+    if (!command.trim())
+        throw Object.assign(new Error("command is required"), { status: 400 });
+    if (command.length > 20_000)
+        throw Object.assign(new Error("command is too long"), { status: 400 });
+    if (options.timeoutSeconds !== undefined && !Number.isFinite(options.timeoutSeconds)) {
+        throw Object.assign(new Error("timeout_seconds must be finite"), { status: 400 });
+    }
+    const runtime = options.runtime ?? (await containerRuntimeStatus()).runtime;
+    if (!runtime)
+        throw Object.assign(new Error("No container runtime is available for the Local VM"), { status: 409 });
+    const seconds = Math.min(Math.max(Math.floor(options.timeoutSeconds ?? EXEC_DEFAULT_SECONDS), 1), EXEC_MAX_SECONDS);
+    const result = await (options.exec ?? defaultExecRunner)(runtime, [
+        "exec",
+        "-u", "cua",
+        "-w", VM_WORKSPACE_GUEST,
+        "-e", "HOME=/home/cua",
+        "-e", `DISPLAY=${DISPLAY}`,
+        target.containerName,
+        "timeout", "-k", "5", String(seconds),
+        "sh", "-lc", command,
+    ], { timeout: (seconds + 20) * 1000 });
+    const timedOut = result.code === 124 || result.code === 137;
+    return { exitCode: result.code, stdout: clipExecOutput(result.stdout), stderr: clipExecOutput(result.stderr), timedOut };
+}
 export function containerComputerMcp(runtime, control, target = SHARED_LOCAL_VM_TARGET) {
     return {
         command: process.execPath,

package/dist-server/server/contracts.js

@@ -17,6 +17,28 @@ export function isModelVariant(value) {
     return typeof value === "string" && value.length > 0 && value.length <= 256 &&
         value.trim() === value && !/\p{Cc}/u.test(value);
 }
+/** The picker label for a model id when the catalog row carries no display
+ * name: split on the word breaks the catalog treats as separators and
+ * capitalize each part ("gpt-5.4-mini" → "Gpt 5.4 Mini"). Each harness
+ * passes its own break class so existing labels stay byte-for-byte. */
+export function titleCaseModelId(id, wordBreaks) {
+    return id
+        .split(wordBreaks)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+/** A picker label that carries a second facet — a display name, a provider
+ * host — beside the model id, unless the facet is already what the id says.
+ * `redundantWhen` decides what counts as "already said" and `decorate` how
+ * the facet is appended, so every harness's labels stay exactly what they
+ * were while the shape is written once. */
+export function qualifiedModelLabel(id, qualifier, options = {}) {
+    const { redundantWhen = () => false, decorate = (facet) => ` — ${facet}` } = options;
+    if (!qualifier || redundantWhen(id, qualifier))
+        return id;
+    return `${id}${decorate(qualifier)}`;
+}
 let eventCounter = 0;
 export const newEventId = () => `ev-${Date.now().toString(36)}-${(eventCounter++).toString(36)}`;
 export const newId = () => crypto.randomUUID();

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

@@ -50,6 +50,7 @@ import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
 import { extractMcpImages } from "../../mcp-tool-images.js";
 import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
+import { sessionIdlePolicy } from "../session-idle.js";
 /** ACP vendors put the actionable cause in error.data while keeping the
  * JSON-RPC message generic. Only surface known text fields, never a response
  * body/config dump, and redact before bounding the displayed diagnostic. */
@@ -80,6 +81,9 @@ const INIT_TIMEOUT = envOr("OPENMAUS_ACP_INIT_TIMEOUT_MS", 300_000);
 const SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 300_000); // configureSession's per-request default
 const NEW_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_NEW_SESSION_TIMEOUT_MS", 300_000);
 const LOAD_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_LOAD_SESSION_TIMEOUT_MS", 120_000); // history replay on a long thread is slow
+/** ACP agents may compact their own history without telling the client;
+ * re-send the full prompt after this many bare turns as a backstop. */
+const ACP_PROMPT_RE_ANCHOR_TURNS = 8;
 // Read lazily (not at import) so a test can shorten the window. Unlike the
 // setup calls above, session/prompt legitimately streams for minutes, so a
 // wall-clock deadline would false-positive: this guard only trips when the
@@ -212,6 +216,24 @@ export function versionFromProbe(stdout, stderr) {
     const err = (stderr ?? "").trim().split(/\r\n|\n|\r/, 1)[0]?.trim() ?? "";
     return err || null;
 }
+/** The first dotted numeric triple in a version banner, or null when there is
+ * none. A wrapper that prints its own banner first still parses: the triple
+ * is the version wherever it appears. */
+export function parseVersionTriple(value) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(value);
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/** Whether `installed` compares at or above `floor`, componentwise. Every
+ * version floor in the tree is a dotted triple. */
+export function versionAtLeast(installed, floor) {
+    for (let i = 0; i < 3; i += 1) {
+        if (installed[i] !== floor[i])
+            return installed[i] > floor[i];
+    }
+    return true;
+}
 export function createAcpDriver(support) {
     const DRIVER_KIND = support.driverKind;
     const SOURCE = support.nativeSource;
@@ -274,11 +296,7 @@ export function createAcpDriver(support) {
             // contract prompts the live session instead of paying the handshake
             // again. An idle session closes after SESSION_IDLE_MS of quiet.
             const sessions = new Map();
-            const configuredIdleMinimum = Number(process.env.OMB_ACP_SESSION_IDLE_MIN_MS);
-            const sessionIdleMinimum = Number.isFinite(configuredIdleMinimum) && configuredIdleMinimum > 0
-                ? configuredIdleMinimum
-                : 10_000;
-            const SESSION_IDLE_MS = Math.max(sessionIdleMinimum, Number(process.env.OMB_ACP_SESSION_IDLE_MS) || 10 * 60_000);
+            const { idleMs: SESSION_IDLE_MS } = sessionIdlePolicy("ACP");
             const closeSession = (threadId, why) => {
                 const session = sessions.get(threadId);
                 if (!session || session.closing)
@@ -1320,7 +1338,7 @@ export function createAcpDriver(support) {
                         let pendingSplitReceipt = null;
                         if (halves.stable !== null) {
                             const receiptKey = JSON.stringify([threadId, sessionId]);
-                            const composed = splitSessionPrompt(halves.stable, halves.volatile, readPromptSplitReceipt(DRIVER_KIND, receiptKey), promptTurn.system, promptTurn.text, Boolean(turn.mentionTurn));
+                            const composed = splitSessionPrompt(halves.stable, halves.volatile, readPromptSplitReceipt(DRIVER_KIND, receiptKey), promptTurn.system, promptTurn.text, Boolean(turn.mentionTurn), ACP_PROMPT_RE_ANCHOR_TURNS);
                             promptInput = { ...promptTurn, system: "", text: composed.text };
                             pendingSplitReceipt = { key: receiptKey, receipt: composed.receipt };
                         }

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

@@ -1,3 +1,4 @@
+import { titleCaseModelId } from "../../contracts.js";
 import { execCli } from "../../procs.js";
 import { createAcpDriver } from "./core.js";
 /** Translate an argv `--model` slug into the id this ACP session will accept.
@@ -86,13 +87,8 @@ function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function labelFor(id, explicit) {
-    if (explicit?.trim())
-        return explicit.trim();
-    return id
-        .split(/[-_./]+/g)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ");
+    const trimmed = explicit?.trim();
+    return trimmed || titleCaseModelId(id, /[-_./]+/);
 }
 function pushModel(options, seen, id, label, custom = false) {
     if (!SLUG.test(id) || seen.has(id))

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

@@ -16,8 +16,8 @@
 // options set over the wire (session/set_model, session/set_mode), which is
 // why both live in configureSession() below and NOT in spawnArgs.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { userHome } from "../../env-path.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 // FACTORY_HOME_OVERRIDE replaces the HOME the CLI resolves, NOT the data root:
@@ -34,7 +34,7 @@ import { createAcpDriver } from "./core.js";
 // out. Names read from the 0.196.0 binary.
 const AUTH_FILES = ["auth.v2.file", "auth.v2.loginkeychain", "auth.v2.keyring"];
 function authFilePaths(env) {
-    const home = env.FACTORY_HOME_OVERRIDE || env.HOME || homedir();
+    const home = env.FACTORY_HOME_OVERRIDE || userHome(env);
     return AUTH_FILES.map((name) => join(home, ".factory", name));
 }
 const INJECT_ID_PREFIX = "custom:openmausbot-";
@@ -42,9 +42,6 @@ export function droidInjectId(host, model) {
     const safe = `${host}-${model}`.replace(/[^a-zA-Z0-9._+-]+/g, "-").replace(/-+/g, "-");
     return `${INJECT_ID_PREFIX}${safe}`;
 }
-function factoryHome(env) {
-    return env.FACTORY_HOME_OVERRIDE || env.HOME || env.USERPROFILE || homedir();
-}
 /** Upsert a BYOK custom model so session/set_model can reach the local host. */
 export function ensureDroidInjectModel(modelId, env = process.env) {
     const inject = decodeInjectId(modelId);
@@ -54,7 +51,7 @@ export function ensureDroidInjectModel(modelId, env = process.env) {
     if (!host)
         return modelId;
     const id = droidInjectId(inject.host, inject.model);
-    const dir = join(factoryHome(env), ".factory");
+    const dir = join(env.FACTORY_HOME_OVERRIDE || userHome(env), ".factory");
     mkdirSync(dir, { recursive: true });
     const path = join(dir, "settings.json");
     let settings = {};
@@ -105,7 +102,7 @@ export function applyDroidLocalAuthEnv(env, modelId) {
     env.FACTORY_API_KEY = "openmausbot-local";
 }
 function readSettings(env) {
-    return JSON.parse(readFileSync(join(factoryHome(env), ".factory", "settings.json"), "utf8"));
+    return JSON.parse(readFileSync(join(env.FACTORY_HOME_OVERRIDE || userHome(env), ".factory", "settings.json"), "utf8"));
 }
 async function resolveModels(env) {
     let catalog = MODELS;

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

@@ -26,8 +26,8 @@
 // the ACP flag + auth method ids follow the published Gemini CLI ACP contract
 // and should be re-verified end-to-end once the CLI is present.
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { userHome } from "../../env-path.js";
 import { createAcpDriver } from "./core.js";
 // Prefer an explicit key method, then personal OAuth, then Vertex — but fall
 // back to whatever the CLI advertises so a new method id still works.
@@ -37,9 +37,9 @@ const AUTH_PREFERENCE = ["gemini-api-key", "oauth-personal", "vertex-ai"];
  * an enterprise licence may still redeem. A stale consumer credential —
  * the common case since 2026-06-18 — reads as not signed in, which is the
  * truthful answer for an engine that would fail its first turn anyway. */
-function liveOauthCredential() {
+function liveOauthCredential(env) {
     try {
-        const creds = JSON.parse(readFileSync(join(homedir(), ".gemini", "oauth_creds.json"), "utf8"));
+        const creds = JSON.parse(readFileSync(join(userHome(env), ".gemini", "oauth_creds.json"), "utf8"));
         if (typeof creds.access_token !== "string" || creds.access_token.trim().length === 0)
             return false;
         const hasRefresh = typeof creds.refresh_token === "string" && creds.refresh_token.trim().length > 0;
@@ -62,7 +62,7 @@ const nonBlank = (value) => Boolean(value?.trim());
 export function geminiIsAuthenticated(env) {
     return (nonBlank(env.GEMINI_API_KEY) ||
         nonBlank(env.GOOGLE_API_KEY) ||
-        (existsSync(join(homedir(), ".gemini", "oauth_creds.json")) && liveOauthCredential()));
+        (existsSync(join(userHome(env), ".gemini", "oauth_creds.json")) && liveOauthCredential(env)));
 }
 /** Gemini CLI's approval modes, passed through: `--approval-mode auto_edit`
  * approves file edits, `--yolo` approves everything; Gemini has no

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

@@ -4,8 +4,8 @@
 // The generic protocol runtime lives in acp/core.ts; this file is only the
 // per-harness quirks. Verified against grok 1.0.0.
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { harnessHome } from "../../env-path.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 export const STATIC_GROK_MODELS = {
@@ -17,11 +17,6 @@ export const STATIC_GROK_MODELS = {
     ],
 };
 const SLUG = /^[a-z0-9][a-z0-9._-]*$/i;
-function grokHome(env) {
-    if (env.GROK_HOME)
-        return env.GROK_HOME;
-    return join(env.HOME || env.USERPROFILE || homedir(), ".grok");
-}
 function unquote(raw) {
     const value = raw.trim();
     if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
@@ -32,7 +27,7 @@ function unquote(raw) {
 /** Local slugs from ~/.grok/config.toml, plus the cloud defaults.
  *  `grok -m <slug>` already accepts these; the picker just didn't list them. */
 export function readGrokModelCatalog(env = process.env) {
-    const path = join(grokHome(env), "config.toml");
+    const path = join(env.GROK_HOME || harnessHome("grok", env), "config.toml");
     let text = "";
     try {
         text = readFileSync(path, "utf8");
@@ -114,7 +109,7 @@ export function ensureGrokInjectSlug(modelId, env = process.env) {
     const host = localHost(inject.host);
     if (!host)
         return modelId;
-    const path = join(grokHome(env), "config.toml");
+    const path = join(env.GROK_HOME || harnessHome("grok", env), "config.toml");
     let text = "";
     try {
         text = readFileSync(path, "utf8");
@@ -258,7 +253,7 @@ const support = {
     // an unauthenticated CLI is a user action, not something to paper over.
     pickAuthMethod: (methods) => (methods.some((m) => m.id === "cached_token") ? "cached_token" : null),
     authFailure: "fail",
-    isAuthenticated: () => existsSync(join(homedir(), ".grok", "auth.json")),
+    isAuthenticated: (env) => existsSync(join(harnessHome("grok", env), "auth.json")),
     // `--append-system-prompt`/`--rules` are accepted by the CLI but do NOT
     // reach the agent-stdio system prompt (verified against 1.0.0), so the
     // persona is prepended codex-style.

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

@@ -9,6 +9,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
+import { harnessHome } from "../../env-path.js";
 import { resolveCli } from "../../procs.js";
 import { decodeInjectId, hostApiKey, INJECT_SEP, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
@@ -25,9 +26,6 @@ export function bindHermesScreenshotCompat(env, modelId) {
     env[HERMES_OPENMAUS_SCREENSHOT_COMPAT] = "1";
     env[HERMES_OPENMAUS_SCREENSHOT_COMPAT_MODEL] = inject.model;
 }
-function hermesHome(env) {
-    return env.HERMES_HOME || join(env.HOME || env.USERPROFILE || homedir(), ".hermes");
-}
 function quoteYaml(value) {
     if (/^[\w./:+-]+$/.test(value))
         return value;
@@ -69,7 +67,7 @@ export function ensureHermesInjectProvider(modelId, env = process.env) {
     const host = localHost(inject.host);
     if (!host)
         return modelId;
-    const dir = hermesHome(env);
+    const dir = env.HERMES_HOME || harnessHome("hermes", env);
     mkdirSync(dir, { recursive: true });
     const path = join(dir, "config.yaml");
     let text = "";
@@ -199,7 +197,7 @@ function hermesConfigDefault(text) {
  * catalog exactly as it was for local-only setups.
  */
 export function hermesConfiguredModel(env = process.env) {
-    const dir = hermesHome(env);
+    const dir = env.HERMES_HOME || harnessHome("hermes", env);
     let secrets = "";
     try {
         secrets = readFileSync(join(dir, ".env"), "utf8");

package/dist-server/server/drivers/acp/opencode-go.js

@@ -6,6 +6,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
+import { titleCaseModelId } from "../../contracts.js";
 import { execCli } from "../../procs.js";
 const STATIC_MODELS = {
     default: "opencode/x-preview-f-free",
@@ -21,11 +22,7 @@ let lastSuccessfulCatalog = null;
 const MODEL_PROBE_TTL_MS = 30_000;
 const modelProbeCache = new Map();
 function labelForModel(id) {
-    return id
-        .split(/[-_.]+/g)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ");
+    return titleCaseModelId(id, /[-_.]+/);
 }
 function providerLabel(id) {
     if (id === "opencode")

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

@@ -3,30 +3,20 @@
 // Custom and are written into ~/.qwen/settings.json modelProviders.
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { qualifiedModelLabel } from "../../contracts.js";
+import { harnessHome } from "../../env-path.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
-function qwenHome(env) {
-    const home = process.platform === "win32"
-        ? env.USERPROFILE || env.HOME || homedir()
-        : env.HOME || env.USERPROFILE || homedir();
-    return join(home, ".qwen");
-}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function qwenModelLabel(id, name) {
-    if (!name || name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()))
-        return id;
-    return `${id} — ${name}`;
-}
 const PROTOCOLS = new Set(["openai", "anthropic", "gemini", "vertex-ai"]);
 function readQwenRoutes(env) {
     let settings;
     try {
-        settings = JSON.parse(readFileSync(join(qwenHome(env), "settings.json"), "utf8"));
+        settings = JSON.parse(readFileSync(join(harnessHome("qwen", env), "settings.json"), "utf8"));
     }
     catch {
         return [];
@@ -102,7 +92,11 @@ function readQwenRoutes(env) {
 /** Public metadata only. Use Qwen's provider-qualified ACP selectors, not raw model IDs. */
 export function readQwenModelCatalog(env = process.env) {
     const options = readQwenRoutes(env).map(({ id, model, label, provider }) => ({
-        id, label: qwenModelLabel(model, label), custom: true, provider,
+        id,
+        label: qualifiedModelLabel(model, label, {
+            redundantWhen: (id, name) => name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()),
+        }),
+        custom: true, provider,
     }));
     return { default: options[0]?.id ?? "", options };
 }
@@ -117,7 +111,7 @@ export function ensureQwenInjectModel(modelId, env = process.env) {
     const host = localHost(inject.host);
     if (!host)
         return modelId;
-    const dir = qwenHome(env);
+    const dir = harnessHome("qwen", env);
     mkdirSync(dir, { recursive: true });
     const path = join(dir, "settings.json");
     let settings = {};