openmausbot 0.1.87 → 0.1.88

package/dist-server/server/drivers/session-idle.js

@@ -0,0 +1,29 @@
+// One session-idle policy for every pooled harness process. The Claude
+// driver and the ACP core grew byte-identical copies of this computation
+// with different env prefixes; the policy lives here so the default, the
+// floor, and the env names cannot drift apart again.
+const DEFAULT_IDLE_MS = 10 * 60_000;
+const MINIMUM_IDLE_MS = 10_000;
+/** setTimeout treats anything above 2^31-1 ms as 1 ms, so a larger delay
+ *  would close the session immediately instead of much later. */
+const MAX_TIMER_MS = 2_147_483_647;
+function usableMilliseconds(raw) {
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 && value <= MAX_TIMER_MS ? value : null;
+}
+/** The idle policy for one harness. The per-harness names that preceded the
+ *  unified ones (OMB_CLAUDE_SESSION_IDLE_*, OMB_ACP_SESSION_IDLE_*) win when
+ *  both are set, so a harness-specific override keeps working alongside a
+ *  global OMB_SESSION_IDLE_MS / OMB_SESSION_IDLE_MIN_MS; the unified names
+ *  are the default for harnesses that did not set their own. A delay that is
+ *  not a positive finite number of at most 2^31-1 ms is validated away before
+ *  the floor applies — the old arithmetic coerced Infinity and larger values
+ *  into an immediately-firing 1 ms timer. The floor is the greater of the
+ *  built-in ten seconds and any configured minimum, so a per-harness minimum
+ *  can raise the floor but never lower it, and it applies to whatever delay
+ *  wins. */
+export function sessionIdlePolicy(driverPrefix, env = process.env) {
+    const minimumMs = Math.max(MINIMUM_IDLE_MS, usableMilliseconds(env[`OMB_${driverPrefix}_SESSION_IDLE_MIN_MS`] ?? env.OMB_SESSION_IDLE_MIN_MS) ?? 0);
+    const configured = usableMilliseconds(env[`OMB_${driverPrefix}_SESSION_IDLE_MS`] ?? env.OMB_SESSION_IDLE_MS) ?? DEFAULT_IDLE_MS;
+    return { idleMs: Math.max(minimumMs, configured), minimumMs };
+}

package/dist-server/server/env-path.js

@@ -41,6 +41,7 @@ function knownDirs() {
         join(home, ".volta", "bin"),
         join(home, ".bun", "bin"),
         join(home, ".asdf", "shims"),
+        join(home, ".local", "share", "mise", "shims"), // mise installer
         join(home, ".deno", "bin"),
         join(home, "bin"),
         ...nvmBinDirs(),
@@ -144,6 +145,20 @@ export function resetPathCacheForTests() {
     loginShellPath = null;
     registeredDirs.length = 0;
 }
+/** The user's home directory as this platform defines it. Windows keeps the
+ * real profile in USERPROFILE; a HOME that leaks in from a POSIX-flavored
+ * shell is not where Windows CLIs keep their state, so USERPROFILE wins there
+ * and HOME wins everywhere else. */
+export function userHome(env = process.env) {
+    return process.platform === "win32"
+        ? env.USERPROFILE || env.HOME || homedir()
+        : env.HOME || env.USERPROFILE || homedir();
+}
+/** `<user home>/.<name>` — the per-harness state directory every CLI keeps
+ * (`.qwen`, `.grok`, `.codex`…), Windows-correct everywhere. */
+export function harnessHome(name, env = process.env) {
+    return join(userHome(env), `.${name}`);
+}
 /** Every `name` binary on the augmented PATH as absolute paths, in PATH
  * order (first = what a bare name would run). Used by the Engines panel's
  * "detected" dropdown and the /api/cli-candidates endpoint. A path-ish

package/dist-server/server/guarded-requests.js

@@ -54,7 +54,7 @@ export function requestSourceForCard(messages, messageId) {
     return undefined;
 }
 export function requestNeedsInput(message) {
-    return Boolean((message.card?.requestId && !message.card.answered && !message.card.dismissed) ||
+    return Boolean((message.card?.requestId && !message.card.answered && !message.card.dismissed && !message.card.expired) ||
         (message.connector && !message.connector.dismissed && !message.connector.resumed && message.connector.status !== "connected") ||
-        (message.secret && !message.secret.provided && !message.secret.dismissed));
+        (message.secret && !message.secret.provided && !message.secret.dismissed && !message.secret.superseded));
 }

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

@@ -0,0 +1,46 @@
+// What a bot gains or loses when its default engine (instanceId, hence
+// driver) changes. Two per-driver facts decide it: whether the driver mounts
+// the agents tool catalog at all (adapter capabilities.agentsMcp — a bot on
+// a driver without it is never even told about the team tools), and which
+// approval levels the destination driver implements. Turn-scoped catalog
+// flags are identical on both sides of a switch, so the comparison below
+// uses one envelope profile and lets the per-driver capability decide the
+// delta; the tool names themselves come from the real catalog, so this
+// never drifts from what a turn is actually shown.
+import { APPROVAL_MODES, supportsApprovalMode } 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. */
+const ENVELOPE = {
+    externalRuntime: false,
+    coordinating: true,
+    ownThreadCreation: true,
+    skillAuthoring: true,
+    sharedComputers: true,
+    voiceNotes: true,
+    botId: "",
+};
+/** Extra card lines for an engine switch, empty when nothing changes. */
+export function harnessCapabilityLines(from, to) {
+    if (!from || !to)
+        return [];
+    const lines = [];
+    if (from.agentsMcp !== to.agentsMcp) {
+        const names = availableTools(ENVELOPE).map((tool) => tool.name);
+        const coordination = ["coordinate_bots", "ask_bot", "delegate_bot"].filter((name) => names.includes(name));
+        lines.push(to.agentsMcp
+            ? "Gains peer coordination and the other team tools: " + names.length + " tools including " + coordination.join(", ") + "."
+            : "Loses peer coordination and every team tool: " + names.length + " tools including " + coordination.join(", ") + " go away.");
+    }
+    if (from.driverKind !== to.driverKind) {
+        const lost = APPROVAL_MODES.filter((mode) => supportsApprovalMode(from.driverKind, mode) && !supportsApprovalMode(to.driverKind, mode));
+        const gained = APPROVAL_MODES.filter((mode) => !supportsApprovalMode(from.driverKind, mode) && supportsApprovalMode(to.driverKind, mode));
+        if (lost.length)
+            lines.push("Loses approval levels: " + lost.join(", ") + ".");
+        if (gained.length)
+            lines.push("Gains approval levels: " + gained.join(", ") + ".");
+    }
+    return lines;
+}