openmausbot 0.1.96 → 0.1.98

package/dist-server/server/drivers/pi.js

@@ -40,6 +40,12 @@ const DRIVER_KIND = "piAgent";
 const PI_ARGS = ["--mode", "rpc", "--no-session"];
 const PI_MODEL_UPDATE_ARGS = ["update", "--models", "--no-approve"];
 const NODE_ENV_FLAG = { ELECTRON_RUN_AS_NODE: "1" };
+/** omp's RPC transport caps one frame at 1 MiB and only chunks oversized
+ *  frames after the client negotiates protocol 2. Sent before the first
+ *  command on every spawn: stdin order guarantees the declaration lands
+ *  before the response to that command is encoded, and vanilla pi has no
+ *  handshake frame to wait for, so nobody gates on a reply. */
+const PI_NEGOTIATE_FRAME = { id: "negotiate", type: "negotiate_protocol", protocolVersion: 2 };
 /** After this many bare turns on one pi session the full prompt rides
  * again even without a compaction event: any history rewrite the events
  * miss (an older pi, a missed line) still loses at most this many turns
@@ -135,12 +141,26 @@ export function buildMcpServers(turn) {
     }
     return Object.keys(servers).length ? servers : null;
 }
+/** One decoded frame → catalog, or null when it is not a successful
+ *  `get_available_models` response. Every option is `custom` (pi is BYOK)
+ *  and id is the `provider/modelId` composite the picker and `set_model`
+ *  both use. */
+function piCatalogFromFrame(frame, fallbackDefault) {
+    const res = frame;
+    if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
+        return null;
+    const options = [];
+    for (const m of res.data?.models ?? []) {
+        if (!m?.provider || !m?.id)
+            continue;
+        const id = `${m.provider}/${m.id}`;
+        options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+    }
+    return { default: fallbackDefault || (options[0]?.id ?? ""), options };
+}
 /** Pure parser: turn a `get_available_models` stdout blob into a catalog.
- *  Every option is `custom` (pi is BYOK) and id is the `provider/modelId`
- *  composite the picker and `set_model` both use. Exported for the test. */
+ *  Exported for the test. */
 export function parsePiCatalog(stdout, fallbackDefault = "") {
-    const options = [];
-    let def = fallbackDefault;
     for (const line of stdout.split("\n")) {
         if (!line.trim())
             continue;
@@ -151,20 +171,142 @@ export function parsePiCatalog(stdout, fallbackDefault = "") {
         catch {
             continue;
         }
-        const res = msg;
-        if (res?.type !== "response" || res.command !== "get_available_models" || !res.success)
-            continue;
-        for (const m of res.data?.models ?? []) {
-            if (!m?.provider || !m?.id)
-                continue;
-            const id = `${m.provider}/${m.id}`;
-            options.push({ id, label: m.name ?? m.id, custom: true, provider: m.provider });
+        const catalog = piCatalogFromFrame(msg, fallbackDefault);
+        if (catalog)
+            return catalog;
+    }
+    return { default: fallbackDefault, options: [] };
+}
+/** omp's RPC v2 splits any frame larger than 1 MiB into base64 `rpc_chunk`
+ *  pieces: one `chunkId`/`count`/`byteLength` for the whole frame, a
+ *  sequential `index`, and `data` carrying one piece. Reassembles one
+ *  logical frame at a time; any inconsistency drops the partial sequence so
+ *  a corrupt stream can never feed a half-built frame to the parser.
+ *  Exported for the test. */
+export class PiRpcChunks {
+    /** omp's advertised cap on one reassembled frame. */
+    static MAX_BYTES = 64 * 1024 * 1024;
+    /** omp's cap on one decoded piece, which also bounds the piece count. */
+    static MAX_PIECE_BYTES = 256 * 1024;
+    static MAX_COUNT = PiRpcChunks.MAX_BYTES / PiRpcChunks.MAX_PIECE_BYTES;
+    chunkId = null;
+    count = 0;
+    byteLength = 0;
+    bytes = 0;
+    parts = [];
+    /** Feed one `rpc_chunk`; returns the reassembled frame when the last
+     *  piece arrives, or null while the sequence is incomplete or broken. */
+    accept(message) {
+        const { chunkId, index, count, byteLength, data } = message;
+        if (typeof chunkId !== "string" || chunkId.length === 0 || typeof data !== "string" ||
+            // Bound the base64 before decoding it, so an oversized piece is
+            // rejected without allocating its bytes.
+            data.length === 0 || data.length > Math.ceil(PiRpcChunks.MAX_PIECE_BYTES / 3) * 4 ||
+            !Number.isInteger(index) || !Number.isInteger(count) || !Number.isInteger(byteLength) ||
+            index < 0 || count < 2 || count > PiRpcChunks.MAX_COUNT ||
+            index >= count ||
+            byteLength < 0 || byteLength > PiRpcChunks.MAX_BYTES) {
+            this.reset();
+            return null;
+        }
+        if (chunkId !== this.chunkId) {
+            // A new sequence may only start at index 0; a different chunkId
+            // mid-sequence means the previous one can never complete.
+            if (index !== 0) {
+                this.reset();
+                return null;
+            }
+            this.chunkId = chunkId;
+            this.count = count;
+            this.byteLength = byteLength;
+            this.parts = [];
+            this.bytes = 0;
+        }
+        else if (count !== this.count || byteLength !== this.byteLength) {
+            this.reset();
+            return null;
+        }
+        const part = Buffer.from(data, "base64");
+        // Every piece must carry bytes: an empty one would let a sequence grow
+        // `parts` without ever approaching `byteLength`.
+        if (index !== this.parts.length || part.length === 0 || part.length > PiRpcChunks.MAX_PIECE_BYTES ||
+            this.bytes + part.length > this.byteLength) {
+            this.reset();
+            return null;
+        }
+        this.parts.push(part);
+        this.bytes += part.length;
+        if (this.parts.length < this.count)
+            return null;
+        const complete = this.bytes === this.byteLength;
+        const text = Buffer.concat(this.parts).toString("utf8");
+        this.reset();
+        if (!complete)
+            return null;
+        try {
+            const frame = JSON.parse(text);
+            return frame && typeof frame === "object" && !Array.isArray(frame)
+                ? frame
+                : null;
+        }
+        catch {
+            return null;
         }
-        break;
     }
-    if (!def && options.length)
-        def = options[0].id;
-    return { default: def, options };
+    reset() {
+        this.chunkId = null;
+        this.count = 0;
+        this.byteLength = 0;
+        this.bytes = 0;
+        this.parts = [];
+    }
+}
+/** Decode one pi stdout line: a plain JSON frame, or one piece of an
+ *  `rpc_chunk` sequence (omp's protocol v2) with the reassembled frame
+ *  returned once complete. Non-JSON lines, scalars and broken sequences
+ *  resolve null and are skipped. Exported for the test. */
+export function decodePiFrame(line, chunks) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const frame = parsed;
+    return frame.type === "rpc_chunk" ? chunks.accept(frame) : frame;
+}
+/** Longest stdout line a reader buffers: omp's cap on one whole frame. */
+const PI_MAX_LINE = PiRpcChunks.MAX_BYTES;
+/** Split a pi child's stdout into non-blank lines for `onLine`, which
+ *  returns true to stop reading. A line longer than PI_MAX_LINE is dropped
+ *  through its newline instead of growing the buffer without bound.
+ *  Exported for the test. */
+export function piLineReader(onLine) {
+    let buf = "";
+    let dropping = false;
+    return (chunk) => {
+        buf += chunk;
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (dropping) {
+                dropping = false;
+                continue;
+            }
+            if (line.length > PI_MAX_LINE || !line.trim())
+                continue;
+            if (onLine(line))
+                return;
+        }
+        if (buf.length > PI_MAX_LINE) {
+            buf = "";
+            dropping = true;
+        }
+    };
 }
 /** Split a picker id into pi's `{provider, modelId}`. Accepts both the
  *  native `provider/modelId` composite and a live-host `host::model`
@@ -306,7 +448,6 @@ function readPiDefaultModel(env) {
 export async function fetchPiModels(cli, env) {
     const child = spawnCli(cli, PI_ARGS, { stdio: ["pipe", "pipe", "pipe"], env });
     return new Promise((resolve) => {
-        let buf = "";
         let done = false;
         const fallbackDefault = readPiDefaultModel(env);
         const finish = (catalog) => {
@@ -323,26 +464,20 @@ export async function fetchPiModels(cli, env) {
         };
         const timer = setTimeout(() => finish({ default: "", options: [] }), 15_000);
         timer.unref?.();
+        const chunks = new PiRpcChunks();
         child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            buf += chunk;
-            let nl;
-            while ((nl = buf.indexOf("\n")) !== -1) {
-                const line = buf.slice(0, nl);
-                buf = buf.slice(nl + 1);
-                if (!line.trim())
-                    continue;
-                const parsed = parsePiCatalog(line + "\n", fallbackDefault);
-                if (parsed.options.length || line.includes('"get_available_models"')) {
-                    clearTimeout(timer);
-                    finish(parsed);
-                    return;
-                }
-            }
-        });
+        child.stdout.on("data", piLineReader((line) => {
+            const frame = decodePiFrame(line, chunks);
+            if (frame?.command !== "get_available_models")
+                return false;
+            clearTimeout(timer);
+            finish(piCatalogFromFrame(frame, fallbackDefault) ?? { default: fallbackDefault, options: [] });
+            return true;
+        }));
         child.on("error", () => finish({ default: "", options: [] }));
         child.on("close", () => finish({ default: "", options: [] }));
         try {
+            child.stdin.write(`${JSON.stringify(PI_NEGOTIATE_FRAME)}\n`);
             child.stdin.write(JSON.stringify({ id: "catalog", type: "get_available_models" }) + "\n");
         }
         catch {
@@ -542,7 +677,6 @@ export const PiDriver = {
                     throw err;
                 }
             })();
-            let buf = "";
             let assistantText = "";
             // set when a compaction event arrives this turn; gates the receipt
             // write below so a compacted-around delivery is never claimed
@@ -575,6 +709,11 @@ export const PiDriver = {
                 appendNative(threadId, { dir: "out", source: "pi.rpc", msg: piNativeLogMessage(obj) });
                 child.stdin.write(JSON.stringify(obj) + "\n");
             };
+            // Declare protocol 2 on the same stdin before the first command, so an
+            // omp-style runtime chunks any oversized frame it sends back. Vanilla
+            // pi refuses the unknown command; no waiter is keyed for the reply,
+            // so either answer is ignored.
+            send(PI_NEGOTIATE_FRAME);
             /** Emit buffered assistant text as its own item, then clear it. */
             const flushAssistantText = () => {
                 const text = assistantText;
@@ -911,23 +1050,19 @@ export const PiDriver = {
                         return;
                 }
             };
+            const chunks = new PiRpcChunks();
             child.stdout.setEncoding("utf8");
-            child.stdout.on("data", (chunk) => {
-                buf += chunk;
-                let nl;
-                while ((nl = buf.indexOf("\n")) !== -1) {
-                    const line = buf.slice(0, nl);
-                    buf = buf.slice(nl + 1);
-                    if (!line.trim())
-                        continue;
-                    try {
-                        onEvent(JSON.parse(line));
-                    }
-                    catch {
-                        /* skip non-JSON line */
-                    }
+            child.stdout.on("data", piLineReader((line) => {
+                const frame = decodePiFrame(line, chunks);
+                if (!frame)
+                    return;
+                try {
+                    onEvent(frame);
                 }
-            });
+                catch {
+                    /* skip a frame the event handler can't consume */
+                }
+            }));
             child.on("error", (err) => {
                 const fail = describeSpawnFailure(err, config.cli);
                 rejectWaiters(new Error(fail.message));

package/dist-server/server/fleet-agent.js

@@ -9,15 +9,28 @@ import { dirname } from "node:path";
 import { defaultFleetDeps, executePlan, loadRegistry, markProvisioningFailed, planFleetAction } from "./fleet-cli.js";
 import { assertSlug, fleetLayout, fleetUser, openRouterModelIds, workspaceDataDir } from "./fleet.js";
 const MAX_BODY = 256 * 1024;
-function readBody(req) {
+export function readBody(req) {
     return new Promise((resolve, reject) => {
-        let text = "";
+        const chunks = [];
+        let bytes = 0;
+        let tooLarge = false;
         req.on("data", (chunk) => {
-            text += chunk.toString("utf8");
-            if (text.length > MAX_BODY)
-                reject(Object.assign(new Error("request too large"), { status: 413 }));
+            if (tooLarge)
+                return;
+            bytes += chunk.length;
+            if (bytes > MAX_BODY) {
+                // Keep draining so the 413 can still be sent, but stop holding bytes.
+                tooLarge = true;
+                chunks.length = 0;
+                return reject(Object.assign(new Error("request too large"), { status: 413 }));
+            }
+            chunks.push(chunk);
         });
         req.on("end", () => {
+            if (tooLarge)
+                return;
+            // Decode once: a character split across two chunks stays whole.
+            const text = Buffer.concat(chunks).toString("utf8");
             if (!text.trim())
                 return resolve({});
             try {

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

@@ -20,7 +20,7 @@ export function json(res, status, body) {
 }
 export function readBody(req, limit = 1_000_000) {
     return new Promise((resolve, reject) => {
-        let data = "";
+        const chunks = [];
         let bytes = 0;
         let done = false;
         const fail = (status, msg) => {
@@ -40,11 +40,14 @@ export function readBody(req, limit = 1_000_000) {
                 // receiving the useful 413 response.
                 return fail(413, "body too large");
             }
-            data += c;
+            chunks.push(typeof c === "string" ? Buffer.from(c) : c);
         });
         req.on("end", () => {
             if (done)
                 return;
+            // Decode once, after the last chunk: a character split across two
+            // chunks turns into U+FFFD when each chunk is decoded on its own.
+            const data = Buffer.concat(chunks).toString("utf8");
             let body;
             try {
                 body = data ? JSON.parse(data) : {};

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

@@ -35,6 +35,9 @@ export class ProviderRegistry {
     /** decoded per-instance `cli` overrides, for describe() — drivers spawn
      * from their own config; this map only reports what was configured */
     cliByInstance = new Map();
+    /** What describe() last read of each live instance. A turn's start checks
+     * a thread's own engine against it without waiting on that engine's CLI. */
+    lastSnapshots = new Map();
     driversByKind;
     /** Where Settings-driven npm installs go; the data directory by default. */
     enginesBaseDir;
@@ -100,6 +103,16 @@ export class ProviderRegistry {
     get(instanceId) {
         return this.byId.get(instanceId)?.live ?? null;
     }
+    /** The snapshot describe() last read of this live instance; absent before
+     * the first read, or for an instance that is not live. */
+    lastSnapshot(instanceId) {
+        return this.byId.get(instanceId)?.live ? this.lastSnapshots.get(instanceId) : undefined;
+    }
+    /** How the instance's driver is presented and paid for (EngineAccess). */
+    access(instanceId) {
+        const entry = this.byId.get(instanceId);
+        return entry ? this.driversByKind.get(entry.shadow?.driverKind ?? entry.live.driverKind)?.metadata.access ?? "subscription" : undefined;
+    }
     /** The configured executable for instance-scoped maintenance actions.
      * This deliberately comes from the registry/config, never an HTTP body. */
     cliTarget(instanceId) {
@@ -211,6 +224,10 @@ export class ProviderRegistry {
             catch (e) {
                 snapshot = { state: "unavailable", reason: e instanceof Error ? e.message : String(e) };
             }
+            // Only while this is still the live instance: a reload may have
+            // replaced it during the read.
+            if (this.byId.get(inst.instanceId)?.live === inst)
+                this.lastSnapshots.set(inst.instanceId, snapshot);
             return {
                 instanceId: inst.instanceId,
                 driverKind: inst.driverKind,
@@ -256,11 +273,13 @@ export class ProviderRegistry {
         await Promise.allSettled(this.instances().map((i) => i.dispose()));
         this.byId.clear();
         this.cliByInstance.clear();
+        this.lastSnapshots.clear();
     }
     async dispose(instanceId) {
         const entry = this.byId.get(instanceId);
         this.byId.delete(instanceId);
         this.cliByInstance.delete(instanceId);
+        this.lastSnapshots.delete(instanceId);
         await entry?.live?.dispose();
     }
 }

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

@@ -9,10 +9,12 @@
 // never drifts from what a turn is actually shown.
 import { APPROVAL_MODES, supportsApprovalMode as driverKindSupportsApprovalMode } 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. */
+/** The widest turn the harness can build: every optional integration on, a
+ * Chief of Staff (the only role shown the Chief-only tools) and a
+ * coordinating (room) turn, where the room-only coordination tools exist.
+ * So the count is an upper bound, not one bot's catalog. Both sides of a
+ * comparison get the same profile; only the driver's own capability can
+ * differ. */
 const ENVELOPE = {
     externalRuntime: false,
     coordinating: true,
@@ -22,6 +24,7 @@ const ENVELOPE = {
     voiceNotes: true,
     // Not a tool it adds: a Cloud home only hides its Local VM shell.
     cloudHome: false,
+    chief: true,
     botId: "",
 };
 /** Extra card lines for an engine switch, empty when nothing changes. */

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

@@ -138,12 +138,14 @@ export function hostedModelPolicy(dataDirectory, env = process.env) {
                 const previousDefault = bot.modelSelection;
                 const nextDefault = select(previousDefault);
                 for (const task of store.tasks(bot.id)) {
+                    // A thread without a model of its own follows the bot onto its
+                    // assigned model; a thread's own model is moved onto one itself.
                     const current = task.modelSelection ?? previousDefault;
                     const next = select(current);
                     const changed = JSON.stringify(next) !== JSON.stringify(current);
                     if (changed || changedRoute)
                         store.patchTask(bot.id, task.threadId, {
-                            modelSelection: next, resumeCursors: {}, lastInstanceId: undefined, rewound: true,
+                            ...(task.modelSelection ? { modelSelection: next } : {}), resumeCursors: {}, lastInstanceId: undefined, rewound: true,
                             lastContextModel: undefined, appliedCompactionId: undefined,
                         });
                 }