@fitchmultz/pi-subagents 0.46.2 → 0.48.0

package/dist/pi-intercom/saved-transcript.js

@@ -0,0 +1,135 @@
+import { constants, openSync, closeSync, fstatSync } from "node:fs";
+import { loadNativeSession } from "../shared/native-session-loader.js";
+import { scanJournal } from "../shared/journal-reader.js";
+import { Fault } from "./bridge-protocol.js";
+import { readLiveTranscript } from "./transcript.js";
+const FILE_BYTES = 64 * 1024 * 1024;
+const ENTRY_COUNT = 50000;
+const TEXT_LIMIT = 131072;
+const fields = new Set([
+    "type",
+    "id",
+    "parentId",
+    "timestamp",
+    "version",
+    "cwd",
+    "customType",
+    "display",
+    "content",
+]);
+/** Only branch structure and public textual content are hydrated, never image/provider/custom data. */
+const transcriptProjection = (path) => {
+    if (path.length === 0) {
+        return true;
+    }
+    if (path[0] === "message") {
+        return messageField(path.slice(1));
+    }
+    if (path[0] === "content") {
+        return contentField(path.slice(1));
+    }
+    return path.length === 1 && fields.has(String(path[0])) ? 4096 : false;
+};
+function messageField(path) {
+    if (path.length === 0) {
+        return true;
+    }
+    if (path[0] === "content") {
+        return contentField(path.slice(1));
+    }
+    return path.length === 1 && ["role", "output", "display", "truncated"].includes(String(path[0]))
+        ? TEXT_LIMIT
+        : false;
+}
+function contentField(path) {
+    return path.length < 2 || (path.length === 2 && ["type", "text"].includes(String(path[1])))
+        ? TEXT_LIMIT
+        : false;
+}
+function textField(path) {
+    if (path[0] === "message") {
+        return ((path.length === 2 && ["content", "output"].includes(String(path[1]))) ||
+            (path.length === 4 && path[1] === "content" && path[3] === "text"));
+    }
+    return path[0] === "content" && (path.length === 1 || (path.length === 3 && path[2] === "text"));
+}
+function savedLines(fd, size) {
+    const lines = [];
+    const cut = new Set();
+    const lengths = new Map();
+    scanJournal(fd, transcriptProjection, ({ value }) => {
+        if (lines.length >= ENTRY_COUNT) {
+            throw new Fault(413, "transcript_too_large", "Saved journal exceeds the 50000-entry budget.");
+        }
+        lines.push(JSON.stringify(value));
+        lengths.clear();
+    }, {
+        policy: "inspect",
+        requireNewline: true,
+        end: size,
+        limits: { depth: 64, nodes: 16384, arrayLength: 4096, keyLength: 512 },
+        malformed: (_start, _end, error) => {
+            if (error instanceof RangeError) {
+                throw new Fault(413, "transcript_too_large", "Saved record exceeds projection limits.");
+            }
+            lengths.clear();
+            cut.delete(lines.length);
+        },
+        stringChunk: (path, chunk) => {
+            if (textField(path)) {
+                const key = JSON.stringify(path);
+                const count = (lengths.get(key) ?? 0) + chunk.length;
+                lengths.set(key, count);
+                if (count > TEXT_LIMIT) {
+                    cut.add(lines.length);
+                }
+            }
+        },
+    });
+    return { lines, cut };
+}
+/** Internal hook: caller MUST resolve a catalog-approved saved ID/name, never accept an HTTP filepath. */
+export async function readSavedTranscript(packageRoot, approvedFile, options = {}) {
+    const sdk = await loadNativeSession(packageRoot);
+    const fd = openSync(approvedFile, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const before = fstatSync(fd);
+        if (!before.isFile() || before.size > FILE_BYTES) {
+            throw new Fault(413, "transcript_too_large", "Saved journal exceeds the 64 MiB read budget.");
+        }
+        const { lines, cut } = savedLines(fd, before.size);
+        const after = fstatSync(fd);
+        if (after.size !== before.size ||
+            after.mtimeMs !== before.mtimeMs ||
+            after.ctimeMs !== before.ctimeMs) {
+            throw new Fault(409, "session_changed", "Saved journal changed during reading; refresh the catalog.");
+        }
+        const entries = sdk.parseSessionEntries(lines.join("\n"));
+        return savedPage(entries, cut, options, sdk);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function savedPage(entries, cut, options, sdk) {
+    const header = entries.find((entry) => entry.type === "session");
+    if (header === undefined) {
+        throw new Fault(409, "invalid_session", "Saved journal has no native session header.");
+    }
+    const legacy = (header.version ?? 1) < 2;
+    if (legacy && options.cursor !== undefined) {
+        throw new Fault(409, "cursor_unavailable", "Legacy journals have no stable entry IDs; request a fresh bounded recent transcript.");
+    }
+    // Native inMemory reconstructs branch state/migrations without ever opening or writing the file.
+    const manager = sdk.SessionManager.inMemory(header.cwd, undefined, entries);
+    const page = readLiveTranscript(manager, options);
+    const cutIds = new Set(entries.flatMap((entry, index) => entry.type !== "session" && cut.has(index) ? [entry.id] : []));
+    const records = page.records.map((entry) => cutIds.has(entry.id) ? { ...entry, truncated: true } : entry);
+    return {
+        ...page,
+        // ponytail: v1 has no persisted entry IDs; use catalog snapshot cursors if legacy pagination is needed.
+        cursor: legacy ? undefined : page.cursor,
+        records,
+        truncated: page.truncated || records.some((entry) => entry.truncated),
+    };
+}

package/dist/pi-intercom/session-targets.js

@@ -2,6 +2,9 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import path from "node:path";
 export const MIN_SESSION_TARGET_PREFIX_LENGTH = 8;
+export function nativePeerId(sessionId) {
+    return `pi-${createHash("sha256").update(sessionId).digest("hex").slice(0, 32)}`;
+}
 export function shortSessionId(sessionId) {
     return sessionId.slice(0, MIN_SESSION_TARGET_PREFIX_LENGTH);
 }

package/dist/pi-intercom/transcript.js

@@ -0,0 +1,175 @@
+import { isRecord, isUnknownArray } from "../shared/unknown.js";
+import { Fault, label, object } from "./bridge-protocol.js";
+const SCAN_LIMIT = 1024;
+export function transcriptOptions(value = {}) {
+    const input = object(value, ["limit", "maxBytes", "cursor"]);
+    const limit = integer(input.limit, 50, 1, 100);
+    const maxBytes = integer(input.maxBytes, 65536, 256, 131072);
+    const cursor = input.cursor === undefined ? undefined : label(input.cursor, "cursor", 512);
+    return { limit, maxBytes, cursor };
+}
+function integer(value, fallback, min, max) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== "number" || !Number.isInteger(result) || result < min || result > max) {
+        throw new Fault(400, "invalid_input", `Transcript limit must be an integer from ${min} to ${max}.`);
+    }
+    return result;
+}
+function textualContent(content) {
+    if (typeof content === "string") {
+        return { text: content, truncated: false };
+    }
+    if (!isUnknownArray(content)) {
+        return { text: "", truncated: false };
+    }
+    const pieces = [];
+    let remaining = 131073;
+    let truncated = content.length > 4096;
+    for (const part of content.slice(0, 4096)) {
+        if (remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+            const text = part.text.slice(0, remaining);
+            pieces.push(text);
+            truncated ||= text.length < part.text.length;
+            remaining -= text.length + 1;
+        }
+    }
+    return { text: pieces.join("\n"), truncated };
+}
+function visible(entry) {
+    if (entry.type === "custom_message") {
+        return entry.display ? { role: "custom", ...textualContent(entry.content) } : undefined;
+    }
+    if (entry.type !== "message") {
+        return undefined;
+    }
+    const message = entry.message;
+    if (message.role === "bashExecution") {
+        return {
+            role: "toolResult",
+            text: message.output,
+            truncated: nativeTruncation(message.truncated),
+        };
+    }
+    if (!["user", "assistant", "toolResult", "custom"].includes(message.role)) {
+        return undefined;
+    }
+    if (message.role === "custom" && !message.display) {
+        return undefined;
+    }
+    return "content" in message
+        ? { role: message.role, ...textualContent(message.content) }
+        : undefined;
+}
+function nativeTruncation(value) {
+    // Older saved bash entries may predate the native boolean field.
+    return value === true;
+}
+function boundedText(text, budget) {
+    // Slice before UTF-8 encoding to avoid copying arbitrarily large live tool output.
+    const bytes = Buffer.from(text.slice(0, budget));
+    if (bytes.length <= budget) {
+        return bytes.toString();
+    }
+    let end = budget;
+    while (end > 0 && (bytes[end] & 0xc0) === 0x80) {
+        end -= 1;
+    }
+    return bytes.subarray(0, end).toString();
+}
+function startId(manager, leaf, cursor) {
+    if (cursor === undefined) {
+        return { id: leaf, scanned: 0 };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Fault(400, "invalid_cursor", "Invalid transcript cursor.");
+    }
+    const data = object(raw, ["leaf", "before"]);
+    if (data.leaf !== leaf) {
+        throw new Fault(409, "branch_changed", "Active branch changed; request a new transcript page.");
+    }
+    const before = label(data.before, "cursor entry", 128);
+    let id = leaf;
+    for (let scanned = 0; id !== null && scanned < SCAN_LIMIT; scanned += 1) {
+        if (id === before) {
+            return { id, scanned };
+        }
+        id = manager.getEntry(id)?.parentId ?? null;
+    }
+    throw new Fault(400, "invalid_cursor", "Cursor is outside the bounded active branch.");
+}
+/** Finalized textual output on the selected branch; never builds full history/context. */
+export function readLiveTranscript(manager, input = {}) {
+    const options = transcriptOptions(input);
+    const leaf = manager.getLeafId();
+    const start = startId(manager, leaf, options.cursor);
+    let id = start.id;
+    let scanned = start.scanned;
+    const records = [];
+    let bytes = 0;
+    let textTruncated = false;
+    while (id !== null && scanned < SCAN_LIMIT) {
+        scanned += 1;
+        const entry = manager.getEntry(id);
+        if (!entry) {
+            textTruncated = true;
+            id = null;
+            break;
+        }
+        const record = transcriptRecord(entry, options.maxBytes - bytes);
+        if (record !== undefined) {
+            records.push(record);
+            bytes += Buffer.byteLength(record.text);
+            textTruncated ||= record.truncated;
+        }
+        id = entry.parentId;
+        if (records.length >= options.limit || bytes >= options.maxBytes) {
+            break;
+        }
+    }
+    return transcriptPage(manager, {
+        leaf,
+        records,
+        bytes,
+        textTruncated,
+        id,
+        scanLimitReached: scanned >= SCAN_LIMIT && id !== null,
+    });
+}
+function transcriptRecord(entry, budget) {
+    const output = visible(entry);
+    if (output === undefined || output.text.length === 0) {
+        return undefined;
+    }
+    const text = boundedText(output.text, budget);
+    return {
+        id: entry.id,
+        timestamp: entry.timestamp,
+        role: output.role,
+        text,
+        truncated: text !== output.text || output.truncated,
+    };
+}
+function transcriptPage(manager, state) {
+    const { leaf, records, bytes, textTruncated, id, scanLimitReached } = state;
+    return {
+        sessionId: manager.getSessionId(),
+        leafId: leaf,
+        records: records.reverse(),
+        bytes,
+        truncated: id !== null || textTruncated,
+        scanLimitReached,
+        ...(id !== null && !scanLimitReached
+            ? { cursor: Buffer.from(JSON.stringify({ leaf, before: id })).toString("base64url") }
+            : {}),
+        finalizedOnly: true,
+        streaming: "unavailable",
+    };
+}