openmausbot 0.1.86 → 0.1.88

package/dist-server/server/fleet.js

@@ -250,7 +250,7 @@ export function initPlan(input) {
         ...(input.operator ? [{ kind: "run", argv: ["systemctl", "enable", "--now", "openmausbot-fleet.service"], why: `start the fleet agent for ${input.operator}` }] : []),
         { kind: "run", argv: ["systemctl", "reload", "caddy"], why: "start serving the workspaces folder" },
         { kind: "note", text: `point *.${registry.domain} at this server (a wildcard A/AAAA record); each workspace gets its own certificate when created` },
-        ...(input.operator ? [{ kind: "note", text: `the workspace running as ${input.operator} can now manage workspaces from Settings → Workspaces` }] : []),
+        ...(input.operator ? [{ kind: "note", text: `the installation running as ${input.operator} can now manage installations from Settings → Installations` }] : []),
     ];
     return { steps, registry };
 }

package/dist-server/server/group-thread-usage.js

@@ -0,0 +1,103 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+const finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+const valid = (row) => Boolean(row && typeof row.threadId === "string" && typeof row.botId === "string" && typeof row.at === "string" && Number.isFinite(Date.parse(row.at)) && finite(row.input) && finite(row.output));
+function addRow(totals, row) {
+    const summary = totals.get(row.threadId) ?? { usage: { input: 0, output: 0, costUsd: null, turns: 0, cachedInput: 0 }, lastAt: -Infinity };
+    const total = summary.usage;
+    const input = Math.trunc(row.input), output = Math.trunc(row.output);
+    const cached = finite(row.cachedInput) ? Math.min(input, Math.trunc(row.cachedInput)) : undefined;
+    total.input += input;
+    total.output += output;
+    total.turns++;
+    if (cached === undefined)
+        delete total.cachedInput;
+    else if (total.cachedInput !== undefined)
+        total.cachedInput += cached;
+    if (finite(row.costUsd))
+        total.costUsd = (total.costUsd ?? 0) + row.costUsd;
+    const at = Date.parse(row.at);
+    if (at >= summary.lastAt) {
+        summary.lastAt = at;
+        total.lastTurn = { input, output, ...(cached === undefined ? {} : { cachedInput: cached }), costUsd: finite(row.costUsd) ? row.costUsd : null };
+        total.lastSpeaker = { botId: row.botId, name: typeof row.botName === "string" && row.botName ? row.botName : row.botId };
+    }
+    totals.set(row.threadId, summary);
+}
+/** Cache per-month/per-thread summaries, not the complete ledger in memory. */
+export class GroupUsageReader {
+    files = new Map();
+    signature = "";
+    totals = new Map();
+    dataDir;
+    constructor(dataDir) { this.dataDir = dataDir; }
+    /** Refresh only at startup or after ledger persistence, never on an SSE lookup. */
+    refresh() {
+        const dir = join(this.dataDir, "usage");
+        let names;
+        try {
+            names = readdirSync(dir).filter(name => /^\d{4}-\d{2}\.jsonl$/.test(name)).sort();
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            names = [];
+        }
+        const files = names.map(name => {
+            const stat = statSync(join(dir, name));
+            return { name, stamp: `${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}:${stat.ino}` };
+        });
+        const signature = JSON.stringify(files);
+        if (signature !== this.signature) {
+            const next = new Map();
+            for (const { name, stamp } of files) {
+                let entry = this.files.get(name);
+                if (entry?.stamp !== stamp) {
+                    const totals = new Map();
+                    for (const line of readFileSync(join(dir, name), "utf8").split("\n")) {
+                        try {
+                            const row = JSON.parse(line);
+                            if (valid(row))
+                                addRow(totals, row);
+                        }
+                        catch { /* incomplete or damaged row */ }
+                    }
+                    entry = { stamp, totals };
+                }
+                next.set(name, entry);
+            }
+            const summaries = new Map();
+            for (const entry of next.values()) {
+                for (const [threadId, part] of entry.totals) {
+                    const total = summaries.get(threadId);
+                    if (!total)
+                        summaries.set(threadId, structuredClone(part));
+                    else {
+                        total.usage.input += part.usage.input;
+                        total.usage.output += part.usage.output;
+                        total.usage.turns += part.usage.turns;
+                        if (total.usage.cachedInput === undefined || part.usage.cachedInput === undefined)
+                            delete total.usage.cachedInput;
+                        else
+                            total.usage.cachedInput += part.usage.cachedInput;
+                        if (part.usage.costUsd !== null)
+                            total.usage.costUsd = (total.usage.costUsd ?? 0) + part.usage.costUsd;
+                        if (part.lastAt >= total.lastAt) {
+                            total.lastAt = part.lastAt;
+                            total.usage.lastTurn = part.usage.lastTurn;
+                            total.usage.lastSpeaker = part.usage.lastSpeaker;
+                        }
+                    }
+                }
+            }
+            const totals = new Map([...summaries].map(([id, value]) => [id, value.usage]));
+            this.files = next;
+            this.totals = totals;
+            this.signature = signature;
+        }
+    }
+    forThread(threadId) {
+        const usage = this.totals.get(threadId);
+        return usage ? structuredClone(usage) : undefined;
+    }
+}

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/registry.js

@@ -228,6 +228,7 @@ export class ProviderRegistry {
                     modelVariants: inst.adapter.capabilities.modelVariants === true,
                     queueing: inst.adapter.capabilities.queueing === true,
                     localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
+                    cloudComputerMcp: inst.adapter.capabilities.cloudComputerMcp === true,
                     approvalReview: inst.reviewPermission !== undefined,
                 },
                 access: driver?.metadata.access ?? "subscription",

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;
+}

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

@@ -21,7 +21,7 @@ export function hostedModelPolicy(dataDirectory, env = process.env) {
         return null;
     const hosted = hostedWorkspaceConfiguration(env);
     if (!hosted?.portalMembership || env.OMB_DESKTOP_PARENT === "1" || !/^omb_workspace_[A-Za-z0-9_-]{43}$/.test(env.OMB_HOSTED_MODEL_TOKEN ?? "")) {
-        throw new Error("Hosted model access requires complete portal-managed workspace configuration.");
+        throw new Error("Hosted model access requires complete portal-managed configuration.");
     }
     let catalog;
     try {