@fitchmultz/pi-subagents 0.50.0 → 0.52.0

package/dist/pi-intercom/types.js

@@ -1,4 +1,4 @@
-import { finiteNumber, isRecord, isUnknownArray, optionalBoolean, optionalFiniteNumber, optionalLabel, safeLabel, safeText, } from "./validation.js";
+import { finiteNumber, isRecord, isUnknownArray, nonNegativeInteger, optionalBoolean, optionalFiniteNumber, optionalLabel, safeLabel, safeText, } from "./validation.js";
 export function isTopicSubscription(value) {
     return (isRecord(value) &&
         typeof value.topic === "string" &&
@@ -30,6 +30,23 @@ export function isTopicUpdate(value) {
         finiteNumber(value.updatedAt) &&
         validTopicOwnership(value));
 }
+export function isContextTarget(value) {
+    return (isRecord(value) &&
+        ["rootSessionId", "peerId", "incarnation"].every((key) => safeLabel(value[key])));
+}
+export function isDeliveryGuard(value) {
+    return isContextTarget(value) && "applicationGuard" in value && safeLabel(value.applicationGuard);
+}
+export function isPublicationReplyHint(value) {
+    return (isRecord(value) &&
+        typeof value.tool === "string" &&
+        /^[a-zA-Z_][a-zA-Z0-9_]{0,79}$/.test(value.tool) &&
+        typeof value.commandId === "string" &&
+        /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value.commandId) &&
+        (value.commandFingerprint === undefined ||
+            (typeof value.commandFingerprint === "string" &&
+                /^[a-f0-9]{64}$/.test(value.commandFingerprint))));
+}
 export function isHumanMessageOrigin(value) {
     if (!isRecord(value)) {
         return false;
@@ -50,6 +67,9 @@ export function isAttachment(value) {
     return (validType && safeLabel(value.name) && safeText(value.content) && optionalLabel(value.language));
 }
 function validMessageOrigin(message) {
+    if (!validMessageGuard(message)) {
+        return false;
+    }
     if (message.human !== undefined && !isHumanMessageOrigin(message.human)) {
         return false;
     }
@@ -61,6 +81,17 @@ function validMessageOrigin(message) {
         (message.expectsReply === undefined || message.expectsReply === false) &&
         message.replyTo === undefined);
 }
+function validMessageGuard(message) {
+    if (message.guard === undefined) {
+        return message.replyHint === undefined;
+    }
+    return (isDeliveryGuard(message.guard) &&
+        message.expectsReply === false &&
+        message.replyTo === undefined &&
+        message.human === undefined &&
+        message.topic === undefined &&
+        (message.replyHint === undefined || isPublicationReplyHint(message.replyHint)));
+}
 function validDelivery(message) {
     if (message.delivery !== undefined &&
         message.delivery !== "queue" &&
@@ -136,8 +167,11 @@ function validSessionTopics(session) {
             (isUnknownArray(session.topics) && session.topics.every(isTopicUpdate))));
 }
 function validSessionLineage(value) {
-    return (optionalLabel(value.rootSessionId) &&
-        optionalLabel(value.parentSessionId) &&
+    return (["rootSessionId", "parentSessionId", "incarnation", "applicationGuard"].every((key) => optionalLabel(value[key])) &&
+        (value.guardedDelivery === undefined ||
+            (value.guardedDelivery === 1 &&
+                safeLabel(value.incarnation) &&
+                safeLabel(value.rootSessionId))) &&
         (value.parentSessionId === undefined || value.rootSessionId === value.parentSessionId));
 }
 function validSessionProject(value) {
@@ -205,3 +239,20 @@ export function normalizeMessage(value) {
     };
     return isMessage(restored) ? restored : null;
 }
+export const LAST_MESSAGE_PAGE_LIMIT = 16384;
+function optionalEntryId(value) {
+    return value === undefined || (typeof value === "string" && value.length > 0);
+}
+export function isLastMessageQuery(value) {
+    return (isRecord(value) &&
+        value.messageId === undefined &&
+        optionalEntryId(value.entryId) &&
+        (value.offset === undefined || nonNegativeInteger(value.offset)) &&
+        (value.limit === undefined ||
+            (nonNegativeInteger(value.limit) &&
+                value.limit > 0 &&
+                value.limit <= LAST_MESSAGE_PAGE_LIMIT)));
+}
+export function isReceiptQuery(value) {
+    return isRecord(value) && [value.rootSessionId, value.messageId].every(safeLabel);
+}

package/dist/pi-intercom/validation.d.ts

@@ -0,0 +1,12 @@
+/** JSON objects are untrusted at the broker and journal boundaries. */
+export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+export declare function isUnknownArray(value: unknown): value is readonly unknown[];
+export declare function errorMessage(error: unknown): string;
+export declare function asError(error: unknown): Error;
+export declare function safeText(value: unknown): boolean;
+export declare function safeLabel(value: unknown): boolean;
+export declare function optionalLabel(value: unknown): boolean;
+export declare function optionalBoolean(value: unknown): boolean;
+export declare function finiteNumber(value: unknown): value is number;
+export declare function nonNegativeInteger(value: unknown): value is number;
+export declare function optionalFiniteNumber(value: unknown): boolean;

package/dist/pi-intercom/validation.js

@@ -54,6 +54,9 @@ export function optionalBoolean(value) {
 export function finiteNumber(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
+export function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
 export function optionalFiniteNumber(value) {
     return value === undefined || finiteNumber(value);
 }

package/dist/shared/bounded-json.js

@@ -0,0 +1,151 @@
+import { types } from "node:util";
+class Limit extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+/**
+ * Proxies, accessors and custom serializers would run arbitrary code inside the actor; binary
+ * values allocate their full representation. None of them is read.
+ */
+function opaque(value) {
+    return (types.isProxy(value) ||
+        ArrayBuffer.isView(value) ||
+        types.isAnyArrayBuffer(value) ||
+        "toJSON" in value);
+}
+/** An own data property's value, without invoking a getter. */
+function data(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor !== undefined && !("value" in descriptor)) {
+        throw new Limit("unsupported");
+    }
+    return descriptor?.value;
+}
+/** Serialize like JSON.stringify within byte, node and depth limits, without first cloning. */
+class Writer {
+    parts = [];
+    bytes = 0;
+    nodes = 0;
+    ancestors = new Set();
+    budget;
+    constructor(budget) {
+        this.budget = budget;
+    }
+    text() {
+        return this.parts.join("");
+    }
+    add(text, bytes = text.length) {
+        this.bytes += bytes;
+        if (this.bytes > this.budget.bytes) {
+            throw new Limit("oversize");
+        }
+        this.parts.push(text);
+    }
+    string(value) {
+        // A string never encodes to fewer bytes than code units; refuse before copying it.
+        if (value.length > this.budget.bytes - this.bytes) {
+            throw new Limit("oversize");
+        }
+        const json = JSON.stringify(value);
+        this.add(json, Buffer.byteLength(json));
+    }
+    /** Returns false for values JSON omits from objects and nulls in arrays. */
+    value(value, depth) {
+        if (++this.nodes > this.budget.nodes) {
+            throw new Limit("oversize");
+        }
+        switch (typeof value) {
+            case "string":
+                this.string(value);
+                return true;
+            case "number":
+                this.add(Number.isFinite(value) ? String(value) : "null");
+                return true;
+            case "boolean":
+                this.add(String(value));
+                return true;
+            case "bigint":
+                throw new Limit("unsupported");
+            case "object":
+                this.object(value, depth);
+                return true;
+            case "undefined":
+            case "function":
+            case "symbol":
+                return false;
+        }
+    }
+    object(value, depth) {
+        if (value === null) {
+            this.add("null");
+            return;
+        }
+        if (depth >= this.budget.depth) {
+            throw new Limit("oversize");
+        }
+        if (this.ancestors.has(value)) {
+            throw new Limit("cyclic");
+        }
+        if (types.isDate(value) && !types.isProxy(value)) {
+            const time = Date.prototype.getTime.call(value);
+            this.add(Number.isNaN(time) ? "null" : JSON.stringify(new Date(time).toISOString()));
+            return;
+        }
+        if (opaque(value)) {
+            throw new Limit("unsupported");
+        }
+        this.ancestors.add(value);
+        if (Array.isArray(value)) {
+            this.array(value, depth + 1);
+        }
+        else {
+            this.record(value, depth + 1);
+        }
+        this.ancestors.delete(value);
+    }
+    array(value, depth) {
+        this.add("[");
+        for (let index = 0; index < value.length; index++) {
+            if (index > 0) {
+                this.add(",");
+            }
+            if (!this.value(data(value, String(index)), depth)) {
+                this.add("null");
+            }
+        }
+        this.add("]");
+    }
+    record(value, depth) {
+        this.add("{");
+        let first = true;
+        for (const key of Object.keys(value)) {
+            const mark = { parts: this.parts.length, bytes: this.bytes };
+            if (!first) {
+                this.add(",");
+            }
+            this.string(key);
+            this.add(":");
+            if (this.value(data(value, key), depth)) {
+                first = false;
+            }
+            else {
+                this.parts.length = mark.parts;
+                this.bytes = mark.bytes;
+            }
+        }
+        this.add("}");
+    }
+}
+export function boundedJson(value, budget) {
+    const writer = new Writer(budget);
+    try {
+        return writer.value(value, 0) ? { json: writer.text() } : { unavailable: "unsupported" };
+    }
+    catch (error) {
+        // Getters, proxies and revoked proxies are untrusted tool data, not observer failures.
+        return { unavailable: error instanceof Limit ? error.reason : "unreadable" };
+    }
+}

package/dist/shared/compact-cards.js

@@ -0,0 +1,66 @@
+import { getMarkdownTheme, keyHint, truncateToVisualLines, } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Markdown, Spacer, Text, truncateToWidth, } from "@earendil-works/pi-tui";
+import { actionText } from "./tui-action.js";
+function preview(content, expanded, theme, showHint = true) {
+    if (expanded) {
+        return content;
+    }
+    let cache;
+    return {
+        render(width) {
+            if (cache?.width !== width) {
+                const { visualLines, skippedCount } = truncateToVisualLines(content.render(width).join("\n"), 4, width, 0, "start");
+                const hint = theme.fg("dim", `… ${skippedCount} more lines${showHint ? ` · ${keyHint("app.tools.expand", "to expand")}` : ""}`);
+                cache = {
+                    width,
+                    lines: skippedCount > 0 ? [...visualLines, truncateToWidth(hint, width)] : visualLines,
+                };
+            }
+            return cache.lines;
+        },
+        invalidate() {
+            cache = undefined;
+            content.invalidate();
+        },
+    };
+}
+export const renderCompactResult = (result, { expanded }, theme) => preview(new Text(theme.fg("toolOutput", result.content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("\n")), 0, 0), expanded, theme);
+export function registerCompactMessages(pi, types) {
+    let ui;
+    pi.on("session_start", (_event, ctx) => {
+        ui = ctx.mode === "tui" ? ctx.ui : undefined;
+    });
+    pi.on("session_shutdown", () => {
+        ui = undefined;
+    });
+    for (const type of types) {
+        pi.registerMessageRenderer(type, (message, { expanded, outputPad }, theme) => {
+            const text = typeof message.content === "string"
+                ? message.content
+                : message.content
+                    .filter((block) => block.type === "text")
+                    .map((block) => block.text)
+                    .join("\n");
+            const box = new Box(outputPad, 1, (line) => theme.bg("customMessageBg", line));
+            const markdown = new Markdown(text, 0, 0, getMarkdownTheme(), {
+                color: (line) => theme.fg("customMessageText", line),
+            });
+            box.addChild(new (class extends Container {
+                render(width) {
+                    this.clear();
+                    const label = theme.fg("customMessageLabel", theme.bold(`[${type}]`));
+                    this.addChild(markdown.render(width).length > 4
+                        ? actionText(`${label} · ${keyHint("app.tools.expand", expanded ? "to collapse" : "to expand")}`, () => ui?.setToolsExpanded(!expanded))
+                        : new Text(label, 0, 0));
+                    return super.render(width);
+                }
+            })());
+            box.addChild(new Spacer(1));
+            box.addChild(preview(markdown, expanded, theme, false));
+            return box;
+        });
+    }
+}

package/dist/shared/journal-frames.js

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { JsonProjection, } from "./json-projection.js";
+import { JsonProjection } from "./json-projection.js";
 import { errorDescription, isRecord } from "./unknown.js";
 /** Byte-framed JSONL. Publication framing is independent of malformed-record tolerance. */
 export class JournalFrames {
@@ -26,7 +26,7 @@ export class JournalFrames {
         this.projection = this.newProjection();
     }
     newProjection() {
-        return new JsonProjection(this.select, this.options.stringChunk, this.options.keys, this.options.limits);
+        return new JsonProjection(this.select, this.options.stringChunk);
     }
     part(bytes) {
         if (!this.nonblank && bytes.some((byte) => ![9, 10, 13, 32].includes(byte))) {
@@ -76,10 +76,7 @@ export class JournalFrames {
         this.error = undefined;
         this.failed = false;
         this.nonblank = false;
-        if (failed) {
-            this.options.malformed?.(start, end, error);
-        }
-        else if (record) {
+        if (!failed && record) {
             this.record(record);
         }
     }