openmausbot 0.1.55

package/dist-server/server/graceful-shutdown.js

@@ -0,0 +1,24 @@
+/** Build one idempotent shutdown callback for process signals. Cleanup jobs
+ * run together, but a wedged provider cannot keep the desktop child alive
+ * forever. The browser capability clear is one of these jobs, so a normal
+ * server stop does not leave a turn bearer usable until its absolute TTL. */
+export function createGracefulShutdown({ cleanup, exit, timeoutMs = 6_000, }) {
+    let started = false;
+    return () => {
+        if (started)
+            return;
+        started = true;
+        let timer;
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(resolve, timeoutMs);
+            timer.unref?.();
+        });
+        const settled = Promise.allSettled(cleanup.map((job) => Promise.resolve().then(job)))
+            .then(() => undefined);
+        void Promise.race([settled, deadline]).finally(() => {
+            if (timer)
+                clearTimeout(timer);
+            exit(0);
+        });
+    };
+}

package/dist-server/server/group-goal-run.js

@@ -0,0 +1,124 @@
+// Odd by design: coordinator/worker alternation must always leave the final
+// bounded turn to the coordinator for an honest completion decision.
+export const GROUP_GOAL_MAX_TURNS = 13;
+export const GROUP_GOAL_CONTROL_OPEN = "<openmaus-goal>";
+export const GROUP_GOAL_CONTROL_CLOSE = "</openmaus-goal>";
+/** Turn-scoped events normally identify themselves. A coordinator completion
+ * can omit that field after its guard was already bound by turn.started; keep
+ * the bound identity so its public transcript message still settles cleanly. */
+export function groupGoalCompletionTurnId(eventTurnId, boundTurnId) {
+    return eventTurnId ?? boundTurnId;
+}
+const bounded = (value, max) => typeof value === "string" ? value.trim().slice(0, max) : "";
+function visibleCoordinatorText(text) {
+    let visible = text;
+    for (;;) {
+        const closeAt = visible.indexOf(GROUP_GOAL_CONTROL_CLOSE);
+        if (closeAt < 0)
+            break;
+        const openAt = visible.lastIndexOf(GROUP_GOAL_CONTROL_OPEN, closeAt);
+        if (openAt < 0) {
+            visible = `${visible.slice(0, closeAt)}${visible.slice(closeAt + GROUP_GOAL_CONTROL_CLOSE.length)}`;
+            continue;
+        }
+        visible = `${visible.slice(0, openAt)}${visible.slice(closeAt + GROUP_GOAL_CONTROL_CLOSE.length)}`;
+    }
+    // A truncated final envelope is private protocol too. Keep the prose that
+    // preceded it, but never expose a half-written marker or JSON fragment.
+    const danglingOpen = visible.indexOf(GROUP_GOAL_CONTROL_OPEN);
+    if (danglingOpen >= 0)
+        visible = visible.slice(0, danglingOpen);
+    return visible.replaceAll(GROUP_GOAL_CONTROL_CLOSE, "").trim();
+}
+/** Keep the orchestration envelope out of the human transcript while still
+ * accepting ordinary prose before it. The last complete envelope wins: a
+ * quoted example earlier in the reply cannot accidentally steer the run. */
+export function parseGroupGoalDecision(text) {
+    const closeAt = text.lastIndexOf(GROUP_GOAL_CONTROL_CLOSE);
+    const openAt = closeAt < 0 ? -1 : text.lastIndexOf(GROUP_GOAL_CONTROL_OPEN, closeAt);
+    if (openAt < 0 || closeAt < 0)
+        return { visibleText: visibleCoordinatorText(text), decision: null };
+    const visibleText = visibleCoordinatorText(text);
+    const payload = text.slice(openAt + GROUP_GOAL_CONTROL_OPEN.length, closeAt).trim();
+    try {
+        const raw = JSON.parse(payload);
+        const status = raw.status;
+        const detail = bounded(raw.detail, 500);
+        if (status === "continue") {
+            const next = bounded(raw.next, 100);
+            const instruction = bounded(raw.instruction, 2_000);
+            if (!next || !instruction)
+                return { visibleText, decision: null };
+            return {
+                visibleText,
+                decision: { status, next, instruction, ...(detail ? { detail } : {}) },
+            };
+        }
+        if (status === "completed" || status === "needs-input" || status === "blocked") {
+            if (!detail)
+                return { visibleText, decision: null };
+            return { visibleText, decision: { status, detail } };
+        }
+    }
+    catch {
+        // A malformed control envelope is a safe pause, never permission to keep
+        // an autonomous loop running on a guess.
+    }
+    return { visibleText, decision: null };
+}
+/** Explicit room lead wins. Otherwise prefer an in-room Chief, then the
+ * first active member. A goal run never recruits somebody outside the room. */
+export function selectGroupGoalCoordinator(members, responder) {
+    const active = members.filter((member) => !member.hidden);
+    if (responder.kind === "member") {
+        const explicit = active.find((member) => member.id === responder.botId);
+        if (explicit)
+            return explicit;
+    }
+    return active.find((member) => member.chiefOfStaff) ?? active[0] ?? null;
+}
+/** Resolve a model-selected teammate without letting fuzzy or duplicate
+ * names choose the wrong person. IDs always work; names work only if unique. */
+export function resolveGroupGoalMember(reference, members) {
+    const wanted = reference.trim().replace(/^@/, "").toLocaleLowerCase();
+    if (!wanted)
+        return null;
+    const active = members.filter((member) => !member.hidden);
+    const idMatch = active.find((member) => member.id.toLocaleLowerCase() === wanted);
+    if (idMatch)
+        return idMatch;
+    const nameMatches = active.filter((member) => member.name.toLocaleLowerCase() === wanted);
+    return nameMatches.length === 1 ? nameMatches[0] : null;
+}
+export function groupGoalCoordinatorInstructions(args) {
+    const roster = args.members
+        .filter((member) => !member.hidden)
+        .map((member) => `${member.name} (${member.id})`)
+        .join(", ");
+    return [
+        "You are the lead coordinator for a bounded team goal run.",
+        `Goal: ${args.goal}`,
+        `Available room members: ${roster}.`,
+        `This is team turn ${args.turn} of ${args.maxTurns}; ${args.remainingTurns} turn(s) remain after this one.`,
+        ...(args.note ? [`Harness note: ${args.note}`] : []),
+        "Use the conversation as the progress ledger. Decide whether the goal is genuinely complete, needs the human, is blocked, or needs one named teammate next.",
+        "Do not continue merely to generate discussion. Do not claim completion unless the requested deliverable or answer is present in the conversation.",
+        "Write a brief human-facing update or final answer, then end with exactly one private control envelope on its own line.",
+        `${GROUP_GOAL_CONTROL_OPEN}{"status":"continue","next":"Exact member id from the roster","instruction":"Concrete next assignment","detail":"Short progress note"}${GROUP_GOAL_CONTROL_CLOSE}`,
+        `Or use status "completed", "needs-input", or "blocked" with a non-empty "detail" and omit next/instruction.`,
+        "Never mention, quote, or explain the control envelope in your human-facing text.",
+    ].join("\n");
+}
+export function groupGoalWorkerInstructions(args) {
+    return [
+        `You are a specialist contributing to a bounded team goal run led by ${args.coordinatorName}.`,
+        `Goal: ${args.goal}`,
+        `Your assignment: ${args.assignment}`,
+        `This is team turn ${args.turn} of ${args.maxTurns}.`,
+        "Do the assigned work now and put concrete results, evidence, or a clear blocker in your reply.",
+        `Address your result to ${args.coordinatorName}. Do not invent a new orchestration protocol or emit an openmaus-goal control envelope.`,
+    ].join("\n");
+}
+export function groupGoalAssignmentKey(memberId, instruction) {
+    return `${memberId}:${instruction.trim().toLocaleLowerCase().replace(/\s+/g, " ")}`;
+}

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

@@ -0,0 +1,86 @@
+// Fan-in event bus — port of upstream's ProviderService fan-in +
+// EventNdjsonLogger tee, minus Effect. Every adapter's event stream merges
+// into one bus; each event is stamped with its providerInstanceId, teed to
+// a per-thread canonical NDJSON log (the debugging trick both upstream and
+// agentcal lean on), and delivered to subscribers (the SSE endpoint and
+// the server-side message folder).
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { EVENTS_DIR } from "../config.js";
+import { redactSecrets } from "../redact.js";
+import { newId } from "../contracts.js";
+const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
+export class EventBus {
+    listeners = new Set();
+    unsubscribes = [];
+    pendingLogWarnings = new Map();
+    appendLog;
+    constructor(appendLog = appendFileSync) {
+        this.appendLog = appendLog;
+    }
+    attach(instances) {
+        for (const instance of instances) {
+            const unsub = instance.adapter.onEvent((event) => {
+                // hard invariant borrowed from correlateRuntimeEventWithInstance:
+                // an adapter may only emit events for its own driver kind
+                if (event.provider !== instance.driverKind) {
+                    console.error(`bus: dropped cross-driver event from ${instance.instanceId}`);
+                    return;
+                }
+                this.publish({ ...event, providerInstanceId: instance.instanceId });
+            });
+            this.unsubscribes.push(unsub);
+        }
+    }
+    publish(event) {
+        const pendingWarning = this.pendingLogWarnings.get(event.threadId);
+        const persistedEvents = pendingWarning ? [pendingWarning, redactSecrets(event)] : [redactSecrets(event)];
+        try {
+            // the canonical log is a file people paste into bug reports; scrub
+            // credential-shaped content (tool titles, request summaries, reply
+            // text) the same way the native tee does
+            this.appendLog(join(EVENTS_DIR, `${event.threadId}.ndjson`), persistedEvents.map((entry) => JSON.stringify(entry)).join("\n") + "\n", { mode: 0o600 });
+            if (pendingWarning)
+                this.pendingLogWarnings.delete(event.threadId);
+        }
+        catch (error) {
+            // Never feed this warning back through publish(): that would retry the
+            // same failed write and recurse. Deliver it once for this outage, then
+            // persist the same marker before the first event written after recovery.
+            if (!pendingWarning) {
+                const warning = {
+                    eventId: newId(),
+                    provider: event.provider,
+                    providerInstanceId: event.providerInstanceId,
+                    threadId: event.threadId,
+                    createdAt: new Date().toISOString(),
+                    turnId: event.turnId,
+                    type: "runtime.error",
+                    message: INCOMPLETE_LOG_MESSAGE,
+                };
+                this.pendingLogWarnings.set(event.threadId, warning);
+                console.error("bus: canonical event log write failed", error);
+                this.deliver(warning);
+            }
+        }
+        this.deliver(event);
+    }
+    deliver(event) {
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(event);
+            }
+            catch (e) {
+                console.error("bus: listener threw", e);
+            }
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    detachAll() {
+        for (const unsub of this.unsubscribes.splice(0))
+            unsub();
+    }
+}

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

@@ -0,0 +1,217 @@
+// Provider instance registry — port of upstream's ProviderInstanceRegistryLive
+// behavior, minus Effect: config map → live instances; unknown driver or
+// config-decode failure becomes an UNAVAILABLE SHADOW SNAPSHOT instead of a
+// startup failure (that behavior is what makes settings forward/backward
+// compatible — do not remove it); dispose tears an instance down without
+// touching its siblings.
+import { findCliCandidates } from "../env-path.js";
+/** The `cli` field off a driver's default config, when it has one — the
+ * placeholder an override input shows when nothing is set. */
+function cliDefaultOf(driver) {
+    if (!driver)
+        return undefined;
+    try {
+        const cfg = driver.defaultConfig();
+        return typeof cfg?.cli === "string" ? cfg.cli : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Raw `config.cli` straight from disk — shadow snapshots can't decode, so
+ * this is the only faithful way to echo back what was configured. */
+function cliOfRaw(raw) {
+    const cli = raw?.cli;
+    return typeof cli === "string" && cli ? cli : undefined;
+}
+export class ProviderRegistry {
+    byId = new Map();
+    /** decoded per-instance `cli` overrides, for describe() — drivers spawn
+     * from their own config; this map only reports what was configured */
+    cliByInstance = new Map();
+    driversByKind;
+    constructor(drivers) {
+        this.driversByKind = new Map(drivers.map((d) => [d.driverKind, d]));
+    }
+    async load(configs) {
+        for (const [instanceId, entry] of Object.entries(configs)) {
+            const driver = this.driversByKind.get(entry.driver);
+            if (!driver) {
+                this.byId.set(instanceId, {
+                    instanceId,
+                    shadow: {
+                        instanceId,
+                        driverKind: entry.driver,
+                        displayName: entry.displayName,
+                        cli: cliOfRaw(entry.config),
+                        shadow: true,
+                        reason: `unknown driver "${entry.driver}" — kept as configured, unavailable here`,
+                    },
+                });
+                continue;
+            }
+            try {
+                const config = entry.config === undefined ? driver.defaultConfig() : driver.decodeConfig(entry.config);
+                // Override detection is on the RAW config, never the decoded one:
+                // decodeConfig fills in the driver default ("claude", "codex", …),
+                // so reading `cli` there would flag every instance as overridden.
+                const rawCli = cliOfRaw(entry.config);
+                if (rawCli)
+                    this.cliByInstance.set(instanceId, rawCli);
+                const live = await driver.create({
+                    instanceId,
+                    displayName: entry.displayName ?? driver.metadata.displayName,
+                    environment: entry.environment ?? {},
+                    enabled: entry.enabled ?? true,
+                    config,
+                });
+                this.byId.set(instanceId, { instanceId, live });
+            }
+            catch (e) {
+                this.byId.set(instanceId, {
+                    instanceId,
+                    shadow: {
+                        instanceId,
+                        driverKind: entry.driver,
+                        displayName: entry.displayName ?? driver.metadata.displayName,
+                        cli: cliOfRaw(entry.config),
+                        shadow: true,
+                        reason: e instanceof Error ? e.message : String(e),
+                    },
+                });
+            }
+        }
+    }
+    get(instanceId) {
+        return this.byId.get(instanceId)?.live ?? null;
+    }
+    /** The configured executable for instance-scoped maintenance actions.
+     * This deliberately comes from the registry/config, never an HTTP body. */
+    cliTarget(instanceId) {
+        const entry = this.byId.get(instanceId);
+        if (!entry)
+            return null;
+        const driverKind = entry.shadow?.driverKind ?? entry.live.driverKind;
+        const driver = this.driversByKind.get(driverKind);
+        return {
+            driverKind,
+            cli: this.cliByInstance.get(instanceId) ?? entry.shadow?.cli ?? cliDefaultOf(driver) ?? null,
+        };
+    }
+    entries() {
+        return [...this.byId.values()];
+    }
+    instances() {
+        return [...this.byId.values()].flatMap((e) => (e.live ? [e.live] : []));
+    }
+    async refreshModels(instanceId) {
+        const instance = this.get(instanceId);
+        if (!instance)
+            return false;
+        await instance.refreshModels?.();
+        return true;
+    }
+    async installRuntime(instanceId) {
+        const instance = this.get(instanceId);
+        if (!instance?.installRuntime)
+            return false;
+        await instance.installRuntime();
+        return true;
+    }
+    async startAuthentication(instanceId) {
+        const instance = this.get(instanceId);
+        return instance?.startAuthentication ? instance.startAuthentication() : null;
+    }
+    async completeAuthentication(instanceId, flowId, callbackUrl) {
+        const instance = this.get(instanceId);
+        if (!instance?.completeAuthentication)
+            return false;
+        await instance.completeAuthentication(flowId, callbackUrl);
+        return true;
+    }
+    async cancelAuthentication(instanceId) {
+        const instance = this.get(instanceId);
+        if (!instance?.cancelAuthentication)
+            return false;
+        await instance.cancelAuthentication();
+        return true;
+    }
+    /** instance snapshots for the model picker: id, driver, models, health */
+    async describe() {
+        // Multiple instances may share a driver. Scan each default binary once
+        // per response instead of repeating filesystem work for every row.
+        const candidatesByName = new Map();
+        const candidatesFor = (driver) => {
+            const name = cliDefaultOf(driver);
+            if (!name)
+                return [];
+            const cached = candidatesByName.get(name);
+            if (cached)
+                return cached;
+            const found = findCliCandidates(name);
+            candidatesByName.set(name, found);
+            return found;
+        };
+        return Promise.all(this.entries().map(async (entry) => {
+            const driver = this.driversByKind.get(entry.shadow?.driverKind ?? entry.live.driverKind);
+            if (entry.shadow) {
+                return {
+                    instanceId: entry.instanceId,
+                    driverKind: entry.shadow.driverKind,
+                    displayName: entry.shadow.displayName ?? entry.shadow.driverKind,
+                    snapshot: { state: "unavailable", reason: entry.shadow.reason },
+                    models: { default: "", options: [] },
+                    capabilities: { computerMcp: false, agentsMcp: false, localComputerMcp: false },
+                    // an unknown driver has no driver record, hence no install path
+                    access: driver?.metadata.access ?? "subscription",
+                    install: driver?.install,
+                    cli: entry.shadow.cli,
+                    cliDefault: cliDefaultOf(driver),
+                    // a shadow is exactly the "your CLI is broken, pick another"
+                    // case where the detected-path dropdown matters most
+                    cliCandidates: candidatesFor(driver),
+                };
+            }
+            const inst = entry.live;
+            let snapshot;
+            try {
+                snapshot = await inst.snapshot();
+            }
+            catch (e) {
+                snapshot = { state: "unavailable", reason: e instanceof Error ? e.message : String(e) };
+            }
+            return {
+                instanceId: inst.instanceId,
+                driverKind: inst.driverKind,
+                displayName: inst.displayName ?? inst.driverKind,
+                snapshot,
+                models: inst.models,
+                capabilities: {
+                    computerMcp: inst.adapter.capabilities.computerMcp === true,
+                    agentsMcp: inst.adapter.capabilities.agentsMcp === true,
+                    composioMcp: inst.adapter.capabilities.composioMcp === true,
+                    phoneMcp: inst.adapter.capabilities.phoneMcp === true,
+                    browserMcp: inst.adapter.capabilities.browserMcp === true,
+                    images: inst.adapter.capabilities.images === true,
+                    effortLevels: inst.adapter.capabilities.effortLevels,
+                    queueing: inst.adapter.capabilities.queueing === true,
+                    localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
+                    approvalReview: inst.reviewPermission !== undefined,
+                },
+                access: driver?.metadata.access ?? "subscription",
+                install: driver?.install,
+                cli: this.cliByInstance.get(inst.instanceId),
+                cliDefault: cliDefaultOf(driver),
+                // every copy of the driver's default binary on the augmented PATH —
+                // the dropdown's "detected" entries. Snapshotted per describe() so a
+                // newly installed CLI shows up on the next refresh.
+                cliCandidates: candidatesFor(driver),
+            };
+        }));
+    }
+    async disposeAll() {
+        await Promise.allSettled(this.instances().map((i) => i.dispose()));
+        this.byId.clear();
+        this.cliByInstance.clear();
+    }
+}