@fitchmultz/pi-subagents 0.50.0 → 0.51.0

package/dist/agent/observe-card.js

@@ -0,0 +1,243 @@
+import { isRecord } from "../shared/unknown.js";
+import { AssistantMessageComponent, Container, Text, ToolExecutionComponent, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createPowerShellToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "./observe-layout.js";
+const renderers = Object.entries({
+    bash: createBashToolDefinition,
+    edit: createEditToolDefinition,
+    find: createFindToolDefinition,
+    grep: createGrepToolDefinition,
+    ls: createLsToolDefinition,
+    powershell: createPowerShellToolDefinition,
+    read: createReadToolDefinition,
+    write: createWriteToolDefinition,
+});
+function nativeTool(name, id, args, options) {
+    return new ToolExecutionComponent(name, id, args, { showImages: false, outputPad: 0 }, renderers.find(([key]) => key === name)?.[1](options.cwd) ?? {}, options.tui, options.cwd);
+}
+export function blocks(value) {
+    if (typeof value === "string") {
+        return [{ type: "text", text: value }];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((part) => {
+        if (!isRecord(part)) {
+            return [];
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            return [{ type: "text", text: part.text }];
+        }
+        if (part.type === "thinking" && typeof part.thinking === "string") {
+            return [{ type: "thinking", text: part.thinking }];
+        }
+        if (part.type === "toolCall" && typeof part.id === "string" && typeof part.name === "string") {
+            return [{ type: "toolCall", id: part.id, name: part.name, args: part.arguments }];
+        }
+        return [
+            {
+                type: "text",
+                text: `[${typeof part.type === "string" ? part.type : "non-text"} attachment]`,
+            },
+        ];
+    });
+}
+export function projected(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return "json" in value ? value.json : undefined;
+}
+export function assistant(content, streaming) {
+    // Rendering only. Accounting and completion still use native journals and receipts.
+    return {
+        role: "assistant",
+        api: "observer",
+        provider: "observer",
+        model: "",
+        timestamp: 0,
+        stopReason: streaming ? "pending" : "stop",
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        content: content.flatMap((block) => {
+            if (block.type === "thinking") {
+                return [{ type: "thinking", thinking: block.text ?? "" }];
+            }
+            return block.type === "text" ? [{ type: "text", text: block.text ?? "" }] : [];
+        }),
+    };
+}
+export class Card {
+    id;
+    content = new Container();
+    footer = new Container();
+    assistant;
+    status;
+    blocks;
+    ended;
+    value;
+    tool;
+    selected = false;
+    expanded = false;
+    ready = false;
+    page = 0;
+    pages = 1;
+    cache;
+    arguments;
+    phase = "";
+    constructor(id) {
+        this.id = id;
+    }
+    publish(page, args, options) {
+        this.content.clear();
+        this.footer.clear();
+        this.ready = true;
+        this.page = page.page;
+        this.pages = page.pages;
+        const { message } = page;
+        const content = blocks(message.content);
+        if (message.role === "assistant") {
+            this.content.addChild(new AssistantMessageComponent(assistant(content, false), options.hideThinking));
+            if (typeof message.errorMessage === "string") {
+                this.content.addChild(new Text(message.errorMessage, 0, 0));
+            }
+        }
+        else if (message.role === "toolResult") {
+            this.publishTool(message, args, options);
+        }
+        else {
+            this.content.addChild(new Text(`${typeof message.role === "string" ? message.role : "message"}\n${content.map((part) => part.text ?? "").join("\n")}`, 0, 0));
+        }
+    }
+    publishTool(message, args, options) {
+        this.tool ??= nativeTool(typeof message.toolName === "string" ? message.toolName : "tool", typeof message.toolCallId === "string" ? message.toolCallId : this.id, args ?? {}, options);
+        this.tool.updateResult({
+            content: blocks(message.content)
+                .filter((part) => part.type === "text")
+                .map((part) => ({ type: "text", text: part.text })),
+            isError: message.isError === true,
+        });
+        this.tool.setExpanded(this.expanded);
+        this.content.addChild(this.tool);
+        this.footer.addChild(new Text("Arguments are a bounded preview. Exact call in Details journal.", 0, 0));
+    }
+    configureTool(value, options) {
+        if (!this.tool) {
+            this.tool = nativeTool(value.name, value.id, projected(value.args) ?? {}, options);
+            this.tool.setExpanded(this.expanded);
+            this.content.addChild(this.tool);
+            this.status = new Text("", 0, 0);
+            this.content.addChild(this.status);
+        }
+        if (this.arguments !== value.args) {
+            this.tool.updateArgs(projected(value.args) ?? {});
+            this.arguments = value.args;
+            this.invalidate();
+        }
+    }
+    updateTool(value, options, preparing) {
+        this.configureTool(value, options);
+        const ended = value.end !== undefined;
+        const source = value.end ?? { result: value.partial, isError: false };
+        let phase = preparing ? "Preparing tool call" : "Running";
+        if (ended) {
+            phase = "Awaiting journal publication";
+        }
+        if (this.value !== source.result || this.phase !== phase) {
+            if (source.result !== undefined) {
+                this.preview(source.result, source.isError, !ended);
+            }
+            this.status?.setText(phase);
+            this.phase = phase;
+            this.value = source.result;
+            this.ended = ended;
+            this.invalidate();
+        }
+    }
+    preview(value, isError, partial) {
+        const result = projected(value) ?? {
+            content: [
+                { type: "text", text: "Live preview unavailable; full result appears after publication." },
+            ],
+        };
+        if (isRecord(result)) {
+            this.tool?.updateResult({
+                content: blocks(result.content)
+                    .filter((part) => part.type === "text")
+                    .map((part) => ({ type: "text", text: part.text })),
+                isError,
+            }, partial);
+        }
+    }
+    stream(message, hideThinking) {
+        if (!this.assistant) {
+            this.assistant = new AssistantMessageComponent(undefined, hideThinking);
+            this.status = new Text("", 0, 0);
+            this.content.addChild(this.assistant);
+            this.content.addChild(this.status);
+        }
+        if (this.matches(message.blocks, message.ended)) {
+            return;
+        }
+        this.assistant.updateContent(assistant(message.blocks.filter(Boolean), !message.ended), !message.ended);
+        this.status?.setText(message.ended ? "Awaiting journal publication" : "In progress");
+        this.blocks = message.blocks.slice();
+        this.ended = message.ended;
+        this.invalidate();
+    }
+    invalidate() {
+        this.cache = undefined;
+        this.content.invalidate();
+        this.footer.invalidate();
+    }
+    render(width) {
+        if (this.cache?.width !== width) {
+            const lines = [...this.content.render(width), ...this.footer.render(width)];
+            if (this.selected && this.tool && lines.length > 0) {
+                lines[0] = "> Selected tool".slice(0, width);
+            }
+            this.cache = { width, lines };
+        }
+        return this.cache.lines;
+    }
+    matches(content, ended) {
+        return (this.ended === ended &&
+            this.blocks?.length === content.length &&
+            content.every((block, index) => this.blocks?.[index] === block));
+    }
+    toggle() {
+        if (this.tool) {
+            this.expanded = !this.expanded;
+            this.tool.setExpanded(this.expanded);
+            this.cache = undefined;
+        }
+    }
+    handleMouse(event) {
+        const body = this.content.render(event.width).length;
+        if (event.y >= body) {
+            return this.footer.handleMouse({
+                ...event,
+                y: event.y - body,
+                height: Math.max(0, event.height - body),
+            });
+        }
+        if (this.tool &&
+            event.button === "left" &&
+            (event.type === "press" || event.type === "click")) {
+            if (event.type === "click") {
+                this.toggle();
+            }
+            return { handled: true, render: event.type === "click" };
+        }
+        const result = this.content.handleMouse(event);
+        if (result?.handled) {
+            this.cache = undefined;
+        }
+        return result;
+    }
+}

package/dist/agent/observe-chrome.js

@@ -0,0 +1,85 @@
+import { actionHints, actionText } from "../shared/tui-action.js";
+import { Container, HStack, rawKeyHint, ScrollView, Text, TruncatedText, } from "./observe-layout.js";
+import { plainText } from "./journal-tail.js";
+export class Details extends ScrollView {
+    constructor(launch) {
+        super(new Text(`${launch.context === "fork" ? "Fork context: includes inherited parent activity.\n" : ""}${launch.id}\nAssignment preview: ${plainText(launch.prompt, 160)}\n${launch.sessionFile}`, 0, 0), { primary: false, scrollbar: "always" });
+    }
+}
+export class ChildList extends ScrollView {
+    list;
+    open;
+    constructor(open) {
+        const list = new Container();
+        super(list, { primary: false, scrollbar: "always" });
+        this.list = list;
+        this.open = open;
+    }
+    update(rows, selected, checking) {
+        this.list.clear();
+        if (rows.length === 0) {
+            this.list.addChild(new Text(checking
+                ? "Checking saved child runs…"
+                : "No child runs to show. Completed runs are hidden.", 0, 0));
+        }
+        for (const row of rows) {
+            this.list.addChild(actionText(`${row.id === selected ? ">" : " "} ${row.status} · ${row.name}`, () => this.open(row.id)));
+        }
+    }
+    reveal(index) {
+        this.scrollTo(Math.max(0, index - Math.floor(this.viewportHeight / 2)));
+    }
+}
+/** Header activity label: a live connection wins over the last known row status. */
+export function activityLabel(options) {
+    const { row, client } = options;
+    if (row?.live !== true) {
+        return row?.status ?? "checking";
+    }
+    if (client?.connected === true) {
+        return client.activity;
+    }
+    if (client) {
+        return "Reconnecting";
+    }
+    return options.connecting ? "Connecting" : (row.activity ?? row.status);
+}
+/** Footer key hints press the same actions as the keyboard table. */
+export function appendHints(target, options) {
+    const hints = options.actions
+        .filter(([, label]) => label.length > 0)
+        .map(([key, label, action]) => ({
+        text: rawKeyHint(options.keys.getKeys(key)[0] ?? "", label),
+        action: () => options.perform(action),
+    }));
+    target.addChild(actionHints(hints), { basis: 1 });
+}
+/** Conversation body: persistent child strip beside the transcript, plus the follow footer. */
+export function appendConversation(target, options) {
+    target.addChild(new HStack([
+        {
+            component: options.list,
+            basis: 27,
+            visible: (viewport) => viewport.width >= 100,
+        },
+        { component: options.reading.scroll, basis: 0, grow: 1, minSize: 1 },
+    ], { gap: 1 }), { basis: 0, grow: 1, minSize: 1 });
+    const { following, pending } = options.reading;
+    let follow = pending
+        ? "New activity below · End to follow live"
+        : "Reading earlier · End to follow live";
+    if (following) {
+        follow = "Following live";
+    }
+    target.addChild(actionText(follow, options.follow), { basis: 1 });
+}
+export function appendHeader(target, options) {
+    const { launch } = options;
+    target.addChild(actionText(`${plainText(launch.name ?? "Child", 32)} · ${options.activity} · Details`, options.toggle), { basis: 1 });
+    target.addChild(new TruncatedText(`${options.model} · Thinking ${options.thinking}`, 0, 0), {
+        basis: 1,
+    });
+    if (options.details) {
+        target.addChild(options.details, { maxSize: 5 });
+    }
+}

package/dist/agent/observe-client.js

@@ -0,0 +1,285 @@
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { agentObservationSocketPath } from "../pi-intercom/broker/paths.js";
+import { createMessageReader, writeFrame } from "../pi-intercom/broker/framing.js";
+import { Assert, Type } from "./typebox.js";
+const activitySchema = Type.Object({
+    phase: Type.String(),
+    tools: Type.Array(Type.String()),
+    model: Type.Optional(Type.String()),
+    thinking: Type.Optional(Type.String()),
+});
+const nullableString = Type.Union([Type.String(), Type.Null()]);
+const settlementSchema = Type.Tuple([
+    Type.Number(),
+    Type.String(),
+    Type.Union([Type.Number(), Type.Null()]),
+    nullableString,
+]);
+const blockSchema = Type.Union([
+    Type.Tuple([
+        Type.Integer({ minimum: 0, maximum: 255 }),
+        Type.Union([Type.Literal("text"), Type.Literal("thinking")]),
+        Type.Integer({ minimum: 0 }),
+        Type.String(),
+    ]),
+    Type.Tuple([
+        Type.Integer({ minimum: 0, maximum: 255 }),
+        Type.Literal("toolCall"),
+        Type.String(),
+        Type.String(),
+        Type.Unknown(),
+    ]),
+]);
+const messageSchema = Type.Object({
+    key: Type.Number(),
+    reset: Type.Boolean(),
+    ended: Type.Boolean(),
+    count: Type.Number(),
+    blocks: Type.Array(blockSchema),
+});
+const toolSchema = Type.Object({
+    id: Type.String(),
+    name: Type.Optional(Type.String()),
+    args: Type.Optional(Type.Unknown()),
+    partial: Type.Optional(Type.Object({ rev: Type.Number(), value: Type.Unknown() })),
+    end: Type.Optional(Type.Object({ result: Type.Unknown(), isError: Type.Boolean() })),
+});
+const frameSchema = Type.Union([
+    Type.Object({
+        t: Type.Literal("snapshot"),
+        v: Type.Literal(1),
+        generation: Type.String(),
+        rootId: Type.String(),
+        sessionId: Type.String(),
+        seq: Type.Number(),
+        leafId: nullableString,
+        activity: activitySchema,
+    }),
+    Type.Object({ t: Type.Literal("activity"), activity: activitySchema }),
+    Type.Object({
+        t: Type.Literal("delta"),
+        settled: Type.Array(settlementSchema),
+        tools: Type.Array(toolSchema),
+        message: Type.Optional(messageSchema),
+    }),
+]);
+export class ObservationChannel {
+    current;
+    pending;
+    changed;
+    constructor(changed) {
+        this.changed = changed;
+    }
+    get connecting() {
+        return this.pending !== undefined;
+    }
+    connect(identity) {
+        if (this.pending || this.current?.connected === true) {
+            return;
+        }
+        const client = new ObservationClient(identity, "detail", () => {
+            if (this.pending !== client && this.current !== client) {
+                return;
+            }
+            if (this.pending === client && client.connected) {
+                this.current = client;
+                this.pending = undefined;
+            }
+            if (this.pending === client && client.closed) {
+                this.pending = undefined;
+            }
+            this.changed();
+        });
+        this.pending = client;
+    }
+    pause() {
+        this.current?.close();
+        this.pending?.close();
+        this.pending = undefined;
+    }
+    clear() {
+        this.pause();
+        this.current = undefined;
+    }
+}
+/** A selected read-only peer. Destruction closes its own socket, never native execution. */
+export class ObservationClient {
+    activity = "Connecting";
+    model = "";
+    thinking = "";
+    connected = false;
+    closed = false;
+    revision = 0;
+    leaf;
+    message;
+    tools = new Map();
+    handovers = [];
+    seq = -1;
+    chars = 0;
+    socket;
+    identity;
+    changed;
+    constructor(identity, level, changed) {
+        this.identity = identity;
+        this.changed = changed;
+        const file = agentObservationSocketPath(identity.token);
+        const directory = fs.lstatSync(path.dirname(file));
+        const endpoint = fs.lstatSync(file);
+        const uid = process.getuid?.();
+        if (!directory.isDirectory() ||
+            directory.uid !== uid ||
+            (directory.mode & 0o777) !== 0o700 ||
+            !endpoint.isSocket() ||
+            endpoint.uid !== uid ||
+            (endpoint.mode & 0o777) !== 0o600) {
+            throw new Error("Unsafe child observation endpoint.");
+        }
+        this.socket = net.createConnection(file);
+        this.socket.on("connect", () => {
+            writeFrame(this.socket, JSON.stringify({ t: "hello", v: 1, ...identity, level }));
+        });
+        this.socket.on("data", createMessageReader((frame) => {
+            try {
+                this.receive(frame);
+            }
+            catch {
+                this.socket.destroy();
+            }
+        }, () => {
+            this.socket.destroy();
+        }, 256 * 1024));
+        this.socket.on("error", () => {
+            this.socket.destroy();
+        });
+        this.socket.on("close", () => {
+            this.closed = true;
+            this.connected = false;
+            this.changed();
+        });
+    }
+    receive(value) {
+        Assert(frameSchema, value);
+        if (value.t === "snapshot") {
+            this.baseline(value);
+        }
+        else if (this.seq < 0) {
+            throw new Error("Observation before baseline.");
+        }
+        else if (value.t === "delta") {
+            this.delta(value);
+        }
+        if (value.t !== "delta") {
+            this.activity = [value.activity.phase, ...value.activity.tools].join(" · ");
+            this.model = value.activity.model ?? this.model;
+            this.thinking = value.activity.thinking ?? this.thinking;
+        }
+        this.revision++;
+        this.changed();
+    }
+    baseline(value) {
+        const { token, rootId, sessionId } = this.identity;
+        if (value.generation !== token || value.rootId !== rootId || value.sessionId !== sessionId) {
+            throw new Error("Foreign child observation.");
+        }
+        this.leaf = value.leafId;
+        this.seq = value.seq;
+        this.connected = true;
+        this.message = undefined;
+        this.tools.clear();
+        this.handovers.length = 0;
+        this.chars = 0;
+    }
+    delta(value) {
+        for (const item of value.settled) {
+            if (item[0] !== this.seq + 1) {
+                throw new Error("Invalid handover sequence.");
+            }
+            this.seq = item[0];
+            this.leaf = item[1];
+            this.handovers.push(item);
+        }
+        if (this.handovers.length > 256) {
+            throw new Error("Journal handover stalled.");
+        }
+        for (const item of value.tools) {
+            const tool = this.tools.get(item.id) ?? {
+                id: item.id,
+                name: item.name ?? "tool",
+                args: item.args,
+            };
+            if (item.partial) {
+                tool.partial = item.partial.value;
+            }
+            if (item.end) {
+                tool.end = item.end;
+            }
+            this.tools.set(item.id, tool);
+        }
+        if (this.tools.size > 256) {
+            throw new Error("Too many live tools.");
+        }
+        this.assistant(value.message);
+    }
+    assistant(value) {
+        if (!value) {
+            return;
+        }
+        if (value.reset) {
+            this.message = { key: value.key, ended: false, blocks: [] };
+            this.chars = 0;
+        }
+        const message = this.message;
+        if (message?.key !== value.key) {
+            throw new Error("Assistant changed without reset.");
+        }
+        message.ended = value.ended;
+        message.blocks.length = Math.min(message.blocks.length, value.count);
+        for (const item of value.blocks) {
+            const [index, type, first, second] = item;
+            if (type === "toolCall") {
+                message.blocks[index] = { type, id: first, name: second, args: item[4] };
+            }
+            else {
+                message.blocks[index] = this.append(message.blocks[index], type, first, second);
+            }
+        }
+    }
+    append(current, type, offset, text) {
+        const previous = offset === 0 ? "" : current?.text;
+        if (previous === undefined || previous.length !== offset) {
+            throw new Error("Assistant append gap.");
+        }
+        this.chars += text.length;
+        if (this.chars > 1024 * 1024) {
+            throw new Error("Live content awaits journal publication.");
+        }
+        return { type, text: previous + text };
+    }
+    /** Retire live state only after its exact journal entries have been indexed. */
+    settle(has) {
+        while (this.handovers.length > 0 && has(this.handovers[0][1])) {
+            const item = this.handovers.shift();
+            if (item) {
+                this.retire(item[2], item[3]);
+            }
+        }
+        return (this.handovers.length === 0 &&
+            (this.leaf === undefined || this.leaf === null || has(this.leaf)));
+    }
+    retire(key, tool) {
+        if (key !== null && this.message?.key === key) {
+            this.message = undefined;
+        }
+        for (const id of this.tools.keys()) {
+            if (tool !== null && (id === tool || id.startsWith(`${tool}/`))) {
+                this.tools.delete(id);
+            }
+        }
+    }
+    close() {
+        this.closed = true;
+        this.socket.destroy();
+    }
+}

package/dist/agent/observe-layout.js

@@ -0,0 +1,65 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { findPackageJSON } from "node:module";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadSDK, packageRoot } from "./host.js";
+// Runtime values in lazy-only viewer modules come from the selected host's files.
+// A bare import would resolve against whatever node_modules exist when /agents first opens.
+// Jiti aliases the pi-tui root to an index file, so submodule URLs must resolve here too.
+const sdkRoot = packageRoot();
+const manifest = findPackageJSON("@earendil-works/pi-tui", path.join(sdkRoot, "dist/index.js"));
+if (manifest === undefined) {
+    throw new Error("Cannot locate the native Pi TUI package.");
+}
+const root = pathToFileURL(path.join(path.dirname(manifest), "dist/index.js"));
+// oxlint-disable-next-line typescript/no-unsafe-assignment
+const tui = await import(__rewriteRelativeImportExtension(root.href));
+// oxlint-disable-next-line typescript/no-unsafe-assignment
+const layout = await import(__rewriteRelativeImportExtension(new URL("./layout.js", root).href));
+// oxlint-disable-next-line typescript/no-unsafe-assignment
+const dispatch = await import(__rewriteRelativeImportExtension(new URL("./tui.js", root).href));
+const sdk = await loadSDK(sdkRoot);
+export const { Container, HStack, ScrollView, Text, TruncatedText, VStack } = tui;
+export const { AssistantMessageComponent, ToolExecutionComponent, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createPowerShellToolDefinition, createReadToolDefinition, createWriteToolDefinition, rawKeyHint, } = sdk;
+export const { renderLayoutFrame, getLayoutBoxesAt, getScrollViewsAt } = layout;
+export const { dispatchMouseEvent } = dispatch;
+export function dispatchLayoutMouse(component, frame, event) {
+    if (event.type === "wheel") {
+        getScrollViewsAt(frame, event.x, event.y)
+            .at(0)
+            ?.scrollBy(event.wheelDelta ?? 0);
+        return {
+            handled: true,
+            target: {
+                component,
+                originX: event.screenX - event.x,
+                originY: event.screenY - event.y,
+                width: event.width,
+                height: event.height,
+            },
+        };
+    }
+    for (const box of getLayoutBoxesAt(frame, event.x, event.y)) {
+        if (box.children.length > 0 || box.component === component) {
+            continue;
+        }
+        const result = dispatchMouseEvent(box.component, {
+            ...event,
+            x: event.x - box.rect.x,
+            y: event.y - box.rect.y,
+            width: box.rect.width,
+            height: box.rect.height,
+        });
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}