@youweichen/pi-harness 0.0.0-stage → 1.1.0

package/dist/server/serialize.js

@@ -0,0 +1,254 @@
+import { codemodeDetails } from "./codemode-presentation.js";
+import { createHash } from "node:crypto";
+import { snapshotFromDetails } from "./plan/state.js";
+const TEXT_CAP = 200_000;
+const TOOL_OUTPUT_CAP = 100_000;
+const ARGS_CAP = 20_000;
+function truncate(s, cap) {
+    if (s.length <= cap)
+        return { text: s, truncated: false };
+    return { text: `${s.slice(0, cap)}\n\n… [truncated]`, truncated: true };
+}
+/** Only documented native result fields cross the wire. */
+export function toolExitCode(result, isError = false) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const r = result;
+    for (const value of [r.structuredContent?.exit_code, r.details?.exitCode]) {
+        if (typeof value === "number" && Number.isSafeInteger(value))
+            return value;
+    }
+    if (!isError)
+        return undefined;
+    const text = Array.isArray(r.content) ? r.content.filter(c => c?.type === "text" && typeof c.text === "string").map(c => c.text).join("\n") : "";
+    const match = text.match(/exited with code (-?\d+)/);
+    return match && Number.isSafeInteger(Number(match[1])) ? Number(match[1]) : undefined;
+}
+export function nativeToolDetails(name, result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const r = result;
+    const d = r.details;
+    const out = {};
+    if (name === "edit") {
+        if (typeof d?.diff === "string") {
+            const bounded = truncate(d.diff, TOOL_OUTPUT_CAP);
+            out.diff = bounded.text;
+            out.diffTruncated = bounded.truncated;
+        }
+        if (typeof d?.firstChangedLine === "number" && Number.isSafeInteger(d.firstChangedLine) && d.firstChangedLine > 0)
+            out.firstChangedLine = d.firstChangedLine;
+    }
+    const path = d?.fullOutputPath ?? (["bash", "powershell"].includes(name) ? r.structuredContent?.full_output_path : undefined);
+    if (typeof path === "string" && path.length <= 4096)
+        out.fullOutputPath = path;
+    if (name === "bash") {
+        out.exitCode = toolExitCode(result, r.isError);
+        if (d?.truncation && typeof d.truncation === "object") {
+            const source = d.truncation;
+            const truncation = {};
+            for (const key of ["truncated", "lastLinePartial"])
+                if (typeof source[key] === "boolean")
+                    truncation[key] = source[key];
+            for (const key of ["totalLines", "totalBytes", "outputLines", "outputBytes"])
+                if (typeof source[key] === "number" && Number.isSafeInteger(source[key]) && source[key] >= 0)
+                    truncation[key] = source[key];
+            if (source.truncatedBy === "lines" || source.truncatedBy === "bytes")
+                truncation.truncatedBy = source.truncatedBy;
+            out.truncation = truncation;
+        }
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function serializeUserContent(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return content.map((b) => {
+        if (b.type === "image") {
+            const img = b;
+            // Canonical ImageContent shape is { type, data, mimeType }; tolerate the
+            // legacy { source } wrapper too.
+            if (typeof img.data === "string" && img.data.length > 0) {
+                return {
+                    type: "image",
+                    dataUrl: `data:${img.mimeType ?? "image/png"};base64,${img.data}`,
+                    mimeType: img.mimeType,
+                };
+            }
+            const src = img.source;
+            if (src?.type === "base64" && src.data) {
+                return {
+                    type: "image",
+                    dataUrl: `data:${src.mediaType ?? "image/png"};base64,${src.data}`,
+                    mimeType: src.mediaType,
+                };
+            }
+            return { type: "image", dataUrl: src?.url };
+        }
+        return { type: "text", text: String(b.text ?? "") };
+    });
+}
+function serializeAssistantContent(content) {
+    return content.map((b) => {
+        if (b.type === "text") {
+            const { text, truncated } = truncate(b.text, TEXT_CAP);
+            return { type: "text", text, truncated };
+        }
+        if (b.type === "thinking") {
+            return { type: "thinking", thinking: b.thinking };
+        }
+        if (b.type === "toolCall") {
+            if (b.arguments === undefined) {
+                return { type: "toolCall", id: b.id, name: b.name };
+            }
+            const { text, truncated } = truncate(JSON.stringify(b.arguments), ARGS_CAP);
+            return {
+                type: "toolCall",
+                id: b.id,
+                name: b.name,
+                argumentsText: text,
+                argumentsTruncated: truncated,
+            };
+        }
+        return { type: "unknown", ...b };
+    });
+}
+export function serializeMessage(m, seq) {
+    switch (m.role) {
+        case "user":
+            return {
+                id: `u-${m.timestamp}-${seq}`,
+                role: "user",
+                content: serializeUserContent(m.content),
+                timestamp: m.timestamp,
+            };
+        case "assistant":
+            return {
+                id: `a-${m.timestamp}-${seq}`,
+                role: "assistant",
+                content: serializeAssistantContent(m.content),
+                timestamp: m.timestamp,
+                model: m.model,
+                provider: m.provider,
+                stopReason: m.stopReason,
+                usage: m.usage ? { input: m.usage.input, output: m.usage.output, cacheRead: m.usage.cacheRead, cacheWrite: m.usage.cacheWrite } : undefined,
+                errorMessage: m.errorMessage,
+            };
+        case "toolResult": {
+            const raw = m.content
+                .map((c) => (c.type === "text" ? c.text : ""))
+                .join("\n");
+            const { text, truncated } = truncate(raw, TOOL_OUTPUT_CAP);
+            const plan = m.toolName === "plan" && !m.isError ? snapshotFromDetails(m.details) : undefined;
+            let nestedComplete = m.nestedCalls?.complete === true && m.nestedCalls.calls.length <= 256;
+            const nestedCalls = m.nestedCalls?.calls.slice(0, 256).map(call => {
+                const args = call.arguments ? truncate(JSON.stringify(call.arguments), ARGS_CAP) : undefined;
+                if (args?.truncated)
+                    nestedComplete = false;
+                return { id: call.id, name: call.name, status: call.status, durationMs: call.durationMs,
+                    error: call.error?.slice(0, 500), argumentsBytes: call.argumentsBytes,
+                    argumentsText: args?.text };
+            });
+            return {
+                id: `t-${m.toolCallId}`,
+                role: "toolResult",
+                content: [{ type: "text", text, truncated }, ...serializeUserContent(m.content.filter(block => block.type === "image"))],
+                ...(nestedCalls ? { nestedCalls: { complete: nestedComplete, calls: nestedCalls } } : {}),
+                toolCallId: m.toolCallId,
+                toolName: m.toolName,
+                details: nativeToolDetails(m.toolName, m),
+                ...(m.toolName === "codemode" ? { codemode: codemodeDetails(m.details) } : {}),
+                isError: m.isError,
+                ...(plan ? { planSnapshot: plan } : {}),
+                timestamp: m.timestamp,
+            };
+        }
+        case "bashExecution": {
+            const { text, truncated } = truncate(m.output, TOOL_OUTPUT_CAP);
+            return {
+                id: `b-${m.timestamp}-${seq}`,
+                role: "bashExecution",
+                content: [
+                    {
+                        type: "bash",
+                        command: m.command,
+                        output: text,
+                        exitCode: m.exitCode,
+                        cancelled: m.cancelled,
+                        truncated,
+                    },
+                ],
+                timestamp: m.timestamp,
+            };
+        }
+        case "custom": {
+            // Third-party extension messages with display:false are UI-hidden
+            // (they still go into LLM context — the SDK handles that).
+            if (m.display === false) {
+                return null;
+            }
+            const content = serializeUserContent(m.content);
+            return {
+                id: `c-${m.timestamp}-${seq}`,
+                role: "custom",
+                content,
+                customType: m.customType,
+                details: m.details,
+                timestamp: m.timestamp,
+            };
+        }
+        case "branchSummary": {
+            const { text, truncated } = truncate(m.summary, TEXT_CAP);
+            return {
+                id: `bs-${m.timestamp}-${seq}`,
+                role: "branchSummary",
+                content: [{ type: "text", text, truncated }],
+                timestamp: m.timestamp,
+            };
+        }
+        case "compactionSummary": {
+            const { text, truncated } = truncate(m.summary, TEXT_CAP);
+            return {
+                id: `cs-${m.timestamp}-${seq}`,
+                role: "compactionSummary",
+                content: [{ type: "text", text, truncated }],
+                timestamp: m.timestamp,
+            };
+        }
+        default:
+            return {
+                id: `x-${seq}`,
+                role: String(m.role ?? "unknown"),
+                content: [],
+                timestamp: m.timestamp,
+            };
+    }
+}
+/**
+ * Serialize the in-progress assistant message (agent.state.streamingMessage).
+ *
+ * Unlike persisted messages, the id must be STABLE across snapshots: the SDK
+ * replaces the partial object on every stream event, so a seq-based id would
+ * remount the React component (and collapse open thinking/tool blocks) every
+ * 60ms. The timestamp is fixed at message creation, so `stream-<ts>` stays
+ * constant for the whole stream.
+ */
+export function serializeStreamingMessage(m) {
+    const msg = serializeMessage(m, 0);
+    if (!msg)
+        return null;
+    return { ...msg, id: `stream-${m.timestamp ?? 0}` };
+}
+/** Stable discriminator for messages sharing a role and millisecond timestamp. */
+const fingerprints = new WeakMap();
+export function contentFingerprint(message) {
+    const cached = fingerprints.get(message);
+    if (cached)
+        return cached;
+    // Persisted messages are immutable. Hash all blocks once, including image
+    // bytes, thinking, tool arguments and custom metadata; a prefix/length is
+    // not an identity. Streaming messages never use this cache.
+    const fingerprint = createHash("sha256").update(JSON.stringify(message)).digest("hex");
+    fingerprints.set(message, fingerprint);
+    return fingerprint;
+}

package/dist/server/session-file-read.js

@@ -0,0 +1,225 @@
+import { statSync } from "node:fs";
+import { open, readFile, stat } from "node:fs/promises";
+import { setImmediate as yieldLoop } from "node:timers/promises";
+import { Worker } from "node:worker_threads";
+import { StringDecoder } from "node:string_decoder";
+import { isDeepStrictEqual } from "node:util";
+import { parseSessionEntries } from "@earendil-works/pi-coding-agent";
+const stamp = (s) => `${s.dev}:${s.ino}:${s.size}:${s.mtimeMs}:${s.ctimeMs}`;
+const matches = (native, disk) => native !== undefined && isDeepStrictEqual(JSON.parse(JSON.stringify(native)), disk);
+/** Verify the baseline once, then read only appended bytes except for equal-size stamp changes. */
+export class SessionTailValidator {
+    path;
+    changed;
+    previous;
+    verified = new Set();
+    invalid = false;
+    missing = false;
+    disposed = false;
+    pending;
+    worker;
+    get checking() { return !!this.pending; }
+    blockingCheck = false;
+    get blocking() { return this.checking && this.blockingCheck; }
+    dispose() { this.disposed = true; void this.worker?.terminate(); }
+    async ready() { return this.pending ?? !this.invalid; }
+    async verify(source) { return this.check(source) ?? this.ready(); }
+    /** Includes baseline I/O; callers can measure subsequent reads by subtracting the initial value. */
+    bytesRead = 0;
+    constructor(path, source, changed = () => { }) {
+        this.path = path;
+        this.changed = changed;
+        this.check(source);
+    }
+    check(source) {
+        if (this.invalid || this.disposed)
+            return false;
+        if (this.pending)
+            return undefined;
+        this.blockingCheck = true;
+        try {
+            const current = statSync(this.path);
+            this.blockingCheck = !this.previous || current.size <= this.previous.size || current.ino !== this.previous.ino || current.dev !== this.previous.dev;
+            if (this.previous && stamp(this.previous) === stamp(current))
+                return true;
+        }
+        catch (error) {
+            if (this.missing && error.code === "ENOENT")
+                return true;
+        }
+        const finish = (valid) => {
+            this.pending = undefined;
+            if (this.disposed)
+                return false;
+            this.invalid = !valid;
+            if (this.blockingCheck || !valid)
+                this.changed();
+            return valid;
+        };
+        this.pending = this.validate(source).then(finish, () => finish(false));
+        return undefined;
+    }
+    compareInWorker(request) {
+        const worker = this.worker ??= new Worker(new URL(import.meta.url.endsWith(".ts") ? "./session-record-worker.ts" : "./session-record-worker.js", import.meta.url), { execArgv: process.execArgv.filter(arg => !arg.startsWith("--watch")) });
+        return new Promise((resolve, reject) => {
+            const cleanup = () => { worker.off("message", message); worker.off("error", failed); worker.off("exit", exited); };
+            const failed = (error) => { cleanup(); reject(error); };
+            const exited = () => failed(new Error("Record validation cancelled"));
+            const message = (result) => { cleanup(); if (result.error)
+                reject(new Error("Invalid session record"));
+            else
+                resolve(result); };
+            worker.once("message", message);
+            worker.once("error", failed);
+            worker.once("exit", exited);
+            worker.postMessage(request);
+        });
+    }
+    async validate(source) {
+        let handle;
+        let observed = false;
+        try {
+            const current = await stat(this.path);
+            observed = true;
+            const previous = this.previous;
+            if (previous && stamp(previous) === stamp(current))
+                return true;
+            if (previous && (previous.ino !== current.ino || previous.dev !== current.dev || current.size < previous.size))
+                return false;
+            const full = !previous || current.size === previous.size;
+            const offset = full ? 0 : previous.size;
+            const expected = full ? [source.getHeader(), ...source.getEntries()] : undefined;
+            const added = new Set();
+            let index = 0;
+            const accept = async (line) => {
+                if (!line.trim())
+                    return true;
+                let id, equal;
+                if (line.length > 256 * 1024) {
+                    ({ id } = await this.compareInWorker({ text: line }));
+                    const native = full ? expected[index] : typeof id === "string" ? source.getEntry(id) : undefined;
+                    equal = (await this.compareInWorker({ native })).equal === true;
+                }
+                else {
+                    const entry = JSON.parse(line);
+                    id = entry?.id;
+                    equal = matches(full ? expected[index] : typeof id === "string" ? source.getEntry(id) : undefined, entry);
+                }
+                if (!equal || (!full && typeof id === "string" && this.verified.has(id)))
+                    return false;
+                if (!(full && index === 0)) {
+                    if (typeof id !== "string" || added.has(id))
+                        return false;
+                    added.add(id);
+                }
+                index++;
+                return true;
+            };
+            handle = await open(this.path, "r");
+            const opened = await handle.stat();
+            if (stamp(opened) !== stamp(current)) {
+                if (opened.ino !== current.ino || opened.dev !== current.dev || opened.size < current.size)
+                    return false;
+                await handle.close();
+                handle = undefined;
+                return this.disposed ? false : this.validate(source);
+            }
+            const buffer = Buffer.alloc(64 * 1024), decoder = new StringDecoder("utf8");
+            let position = offset;
+            let fragments = [];
+            while (position < current.size) {
+                if (this.disposed)
+                    return false;
+                const { bytesRead: n } = await handle.read(buffer, 0, Math.min(buffer.length, current.size - position), position);
+                if (!n)
+                    return false;
+                position += n;
+                this.bytesRead += n;
+                const text = decoder.write(buffer.subarray(0, n));
+                let start = 0, newline;
+                while ((newline = text.indexOf("\n", start)) !== -1) {
+                    fragments.push(text.slice(start, newline));
+                    if (!await accept(fragments.join("")))
+                        return false;
+                    fragments = [];
+                    start = newline + 1;
+                }
+                if (start < text.length)
+                    fragments.push(text.slice(start));
+                await yieldLoop();
+            }
+            const after = await stat(this.path);
+            if (stamp(await handle.stat()) !== stamp(current) || stamp(after) !== stamp(current)) {
+                if (after.ino !== current.ino || after.dev !== current.dev || after.size < current.size)
+                    return false;
+                await handle.close();
+                handle = undefined;
+                // Native writes may continue during metadata verification. Retry against
+                // the new snapshot instead of treating our own append as a conflict.
+                return this.disposed ? false : this.validate(source);
+            }
+            if (decoder.end() || fragments.length || !index || (expected && index !== expected.length))
+                return false;
+            if (full)
+                this.verified = added;
+            else
+                for (const id of added)
+                    this.verified.add(id);
+            this.previous = current;
+            this.missing = false;
+            return true;
+        }
+        catch (error) {
+            this.missing = !observed && !this.previous && error.code === "ENOENT";
+            return this.missing;
+        }
+        finally {
+            await handle?.close();
+            if (this.worker) {
+                const worker = this.worker;
+                this.worker = undefined;
+                await worker.terminate();
+            }
+        }
+    }
+}
+/** Listing must never instantiate a SessionManager: open() can migrate and rewrite files. */
+export class SessionBranchCounts {
+    cache = new Map();
+    async getMany(paths) {
+        const results = new Array(paths.length);
+        let next = 0;
+        await Promise.all(Array.from({ length: Math.min(8, paths.length) }, async () => {
+            while (next < paths.length) {
+                const index = next++;
+                results[index] = await this.get(paths[index]);
+            }
+        }));
+        return results;
+    }
+    async get(path) {
+        try {
+            const before = await stat(path), key = stamp(before);
+            const cached = this.cache.get(path);
+            if (cached?.stamp === key)
+                return cached.count;
+            const entries = parseSessionEntries(await readFile(path, "utf8"));
+            if (stamp(await stat(path)) !== key)
+                return undefined;
+            const parents = new Map();
+            for (const entry of entries)
+                if ("parentId" in entry && entry.parentId)
+                    parents.set(entry.parentId, (parents.get(entry.parentId) ?? 0) + 1);
+            const count = [...parents.values()].filter(n => n > 1).length;
+            this.cache.delete(path);
+            this.cache.set(path, { stamp: key, count });
+            if (this.cache.size > 1000)
+                this.cache.delete(this.cache.keys().next().value);
+            return count;
+        }
+        catch {
+            this.cache.delete(path);
+            return undefined;
+        }
+    }
+}

package/dist/server/session-record-worker.js

@@ -0,0 +1,21 @@
+import { parentPort } from "node:worker_threads";
+import { isDeepStrictEqual } from "node:util";
+// Large JSON records are parsed and compared away from the server event loop.
+let record;
+parentPort.on("message", (request) => {
+    try {
+        if ("text" in request) {
+            record = JSON.parse(request.text);
+            parentPort.postMessage({ id: record?.id });
+        }
+        else {
+            const equal = request.native !== undefined && isDeepStrictEqual(JSON.parse(JSON.stringify(request.native)), record);
+            record = undefined;
+            parentPort.postMessage({ equal });
+        }
+    }
+    catch {
+        record = undefined;
+        parentPort.postMessage({ error: true });
+    }
+});

package/dist/server/session-reload.js

@@ -0,0 +1,13 @@
+const pending = new WeakMap();
+/** Host reload entry points share one queue per native session. A failed
+ * reload is reported to its caller without poisoning later retries. */
+export function reloadSession(session) {
+    const previous = pending.get(session) ?? Promise.resolve();
+    const operation = previous.catch(() => { }).then(() => session.reload());
+    pending.set(session, operation);
+    void operation.finally(() => {
+        if (pending.get(session) === operation)
+            pending.delete(session);
+    }).catch(() => { });
+    return operation;
+}