openmausbot 0.1.86 → 0.1.87

package/dist-server/server/drivers/prompt-split.js

@@ -0,0 +1,87 @@
+// The stable/volatile prompt split, shared by the drivers that deliver it.
+// The stable half is everything that must stay byte-identical for a
+// provider's cached prefix (or a spawned CLI's session contract) to
+// survive; the volatile half (memory, mentions, outstanding teammate
+// work, recent work) legitimately changes mid-conversation and reaches
+// the model inside the turn that changed it, after the cacheable prefix.
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "../config.js";
+import { writeFileAtomic } from "../atomic.js";
+/** Read the split off a turn. Both halves must be present: a driver that
+ * receives only the unsplit system field was called through a path that
+ * never split it. */
+export function promptHalves(turn) {
+    const { systemStable, systemVolatile } = turn;
+    if (typeof systemStable !== "string" || typeof systemVolatile !== "string") {
+        return { stable: null, volatile: "" };
+    }
+    return { stable: systemStable, volatile: systemVolatile };
+}
+export const VOLATILE_CONTEXT_NOTE_PREFIX = "Context from OpenMausBot updated since this conversation started; it replaces any earlier copy:";
+export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation (memory, mentions, outstanding teammate work) have been cleared; the standing instructions still apply.";
+/** The labelled block that carries a changed volatile half inside a user
+ * turn. A half that is empty and always was needs no note; one that was
+ * cleared announces the removal so the model stops relying on it. */
+export function volatileContextNote(volatile, hadVolatile) {
+    const text = volatile.trim();
+    if (text)
+        return VOLATILE_CONTEXT_NOTE_PREFIX + "\n\n" + text;
+    return hadVolatile ? VOLATILE_CONTEXT_CLEARED_NOTE : "";
+}
+/** Prepend a delivered note to the turn text: the one composition shape
+ * every split-aware driver uses. */
+export function withContextNote(note, text) {
+    if (!note)
+        return text;
+    return text ? note + "\n\n" + text : note;
+}
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const EMPTY_FINGERPRINT = digest("");
+export function promptSplitFingerprints(stable, volatile) {
+    return { stable: digest(stable), volatile: digest(volatile) };
+}
+const receiptPath = (scope, key) => join(DATA_DIR, "prompt-split", digest(JSON.stringify([scope, key])) + ".json");
+/** Which halves a native session (an ACP session id, a pi session file)
+ * last carried. Unknown - never tracked, or tracked before this file
+ * existed - reads as null, and the caller re-delivers the full prompt
+ * once. */
+export function readPromptSplitReceipt(scope, key) {
+    try {
+        const raw = JSON.parse(readFileSync(receiptPath(scope, key), "utf8"));
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+            const record = raw;
+            if (typeof record.stable === "string" && typeof record.volatile === "string") {
+                return { stable: record.stable, volatile: record.volatile };
+            }
+        }
+    }
+    catch {
+        /* a missing or corrupt receipt is simply unknown */
+    }
+    return null;
+}
+export function writePromptSplitReceipt(scope, key, receipt) {
+    mkdirSync(join(DATA_DIR, "prompt-split"), { recursive: true });
+    writeFileAtomic(receiptPath(scope, key), JSON.stringify(receipt), { mode: 0o600 });
+}
+/** Compose the prompt for a session that persists its own history (ACP
+ * agents, pi): the full system block rides only when this native session
+ * has not carried it - or carried a different one, which re-delivers the
+ * current copy the way a pre-split turn always did - and a changed
+ * volatile half rides as a labelled note. Otherwise the turn text goes
+ * through bare, so an ordinary memory write neither appends a second copy
+ * of the prompt to the session nor re-prices its cached prefix.
+ * perTurnVolatile marks a turn whose volatile half describes this very
+ * turn (a mention): its note is delivered even when the text is unchanged. */
+export function splitSessionPrompt(stable, volatile, previous, fullSystem, text, perTurnVolatile = false) {
+    const receipt = promptSplitFingerprints(stable, volatile);
+    if (previous === null || previous.stable !== receipt.stable) {
+        return { text: fullSystem ? fullSystem + "\n\n" + text : text, receipt };
+    }
+    const note = previous.volatile === receipt.volatile && !perTurnVolatile
+        ? ""
+        : volatileContextNote(volatile, previous.volatile !== EMPTY_FINGERPRINT);
+    return { text: withContextNote(note, text), receipt };
+}

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/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/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 {