@youweichen/pi-harness 0.0.0-stage → 1.0.0

package/dist/server/private-file.js

@@ -0,0 +1,28 @@
+import { chmodSync, mkdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Atomic write (tmp + rename) of a file that may hold secrets or personal state:
+ * new directories are 0700, the file is 0600 unless told otherwise, and a crash
+ * mid-write never leaves a truncated file.
+ */
+export function writeFileAtomic(path, data, options = {}) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    let mode = options.mode ?? 0o600;
+    if (options.keepExistingMode) {
+        try {
+            mode = statSync(path).mode & 0o777;
+        }
+        catch {
+            /* new file */
+        }
+    }
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, data, { mode });
+    try {
+        chmodSync(tmp, mode); // the create mode is masked by umask; make it exact
+    }
+    catch {
+        /* best effort on Windows */
+    }
+    renameSync(tmp, path);
+}

package/dist/server/process-utils.js

@@ -0,0 +1,112 @@
+/**
+ * process-utils — 跨平台进程工具：监听端口快照、进程树查杀、进程名查询。
+ * 后台任务面板（bgServers）用它们检测/停止 agent 在后台拉起的服务。
+ * 从 agent-service.ts 抽出，行为保持不变。全平台 best-effort：失败静默。
+ */
+/**
+ * Snapshot currently LISTENING TCP ports → owning pid. Windows: netstat;
+ * POSIX: lsof. Used to detect servers the agent started in the background
+ * (the bash tool itself exits, leaving e.g. `npm run dev &` listening).
+ */
+export async function snapshotListeningPorts() {
+    const m = new Map();
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            const out = await new Promise((resolve, reject) => execFile("netstat", ["-ano", "-p", "tcp"], { windowsHide: true, timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/)) {
+                const p = line.trim().split(/\s+/);
+                // TCP 0.0.0.0:5173 0.0.0.0:0 LISTENING 12345
+                if (p.length >= 5 && p[0] === "TCP" && p[3] === "LISTENING") {
+                    const port = Number(p[1].split(":").pop());
+                    const pid = Number(p[4]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+        else {
+            const out = await new Promise((resolve, reject) => execFile("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], { timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/).slice(1)) {
+                const p = line.trim().split(/\s+/);
+                if (p.length >= 9) {
+                    // NAME column tail: "*:5173 (LISTEN)" or "[::1]:5173 (LISTEN)"
+                    const mm = (p[p.length - 1] ?? "").match(/(\d+)\)?\s*$/);
+                    const port = mm ? Number(mm[1]) : NaN;
+                    const pid = Number(p[1]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+    }
+    catch {
+        // best effort — snapshot failure just means no tracking this round
+    }
+    return m;
+}
+/** Kill a pid and its whole process tree (cross-platform). */
+export function killPidTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            void import("node:child_process").then(({ spawn }) => {
+                spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                    stdio: "ignore",
+                    detached: true,
+                    windowsHide: true,
+                }).unref();
+            });
+        }
+        else {
+            process.kill(-pid, "SIGKILL");
+        }
+    }
+    catch {
+        // already dead
+    }
+}
+/** Best-effort full command line of a pid (PowerShell CIM on win32 — wmic is
+ *  gone on recent Win11 builds; ps -o command= on POSIX). Returns undefined
+ *  when the process is gone or the lookup fails. */
+export async function lookupProcessCommandLine(pid) {
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            // CIM query is slower (~1s) than tasklist but this is a one-shot
+            // best-effort probe fired once per detected background server.
+            const out = await new Promise((resolve, reject) => execFile("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine`,
+            ], { windowsHide: true, timeout: 10000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            const line = out.trim();
+            return line || undefined;
+        }
+        const out = await new Promise((resolve, reject) => execFile("ps", ["-o", "command=", "-p", String(pid)], { timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+        const line = out.trim();
+        return line || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Best-effort process name for a pid (tasklist on win32, ps on POSIX).
+ *  Returns undefined when the process is gone or the lookup fails. */
+export async function lookupProcessName(pid) {
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            const out = await new Promise((resolve, reject) => execFile("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { windowsHide: true, timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            // CSV: "node.exe","12345",...
+            const m = out.match(/"([^"]+)"/);
+            return m ? m[1] : undefined;
+        }
+        const out = await new Promise((resolve, reject) => execFile("ps", ["-o", "comm=", "-p", String(pid)], { timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+        const name = out.trim();
+        return name || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/prompt-delivery.js

@@ -0,0 +1,80 @@
+import { expandNativeTemplate } from "./native-prompt-template.js";
+const imagesBySession = new WeakMap();
+/** A question and its attachments occupy ONE native queue item. Never override
+ * the user's queue modes or enqueue context that could reach another prompt. */
+export function promptWithAttachments(text, asides) {
+    const content = asides.flatMap(({ message }) => typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content);
+    // Native skill parsing separates the command from arguments with a
+    // literal space. Keep that separator when attaching context to a bare command.
+    const question = content.some(block => block.type === "text") && /^\/\S+$/.test(text) ? `${text} ` : text;
+    return {
+        text: [question, ...content.flatMap(block => block.type === "text" ? [block.text] : [])].join("\n\n"),
+        images: content.filter((block) => block.type === "image"),
+    };
+}
+export async function deliverPrompt(session, text, asides, queue, acknowledge) {
+    // Extension commands run immediately and own their input/turn. Preserve the
+    // original command text instead of turning attachments into command arguments.
+    const command = text.startsWith("/") ? session.extensionRunner.getCommand(text.slice(1).split(" ", 1)[0]) : undefined;
+    const template = !command && text.startsWith("/") && session.promptTemplates.some(t => t.name === text.slice(1).split(/\s/, 1)[0]) && asides.some(({ message }) => typeof message.content === "string" || message.content.some(b => b.type === "text"));
+    if (command) {
+        let failed = false;
+        const off = session.extensionRunner.onError(error => { if (error.event === "command")
+            failed = true; });
+        try {
+            await session.prompt(text);
+            acknowledge(!failed, !failed);
+        }
+        finally {
+            off();
+        }
+        return;
+    }
+    const input = promptWithAttachments(template ? await expandNativeTemplate(text, session.promptTemplates) : text, command ? [] : asides);
+    let pending = imagesBySession.get(session);
+    if (!pending) {
+        pending = { steering: [], followUp: [] };
+        imagesBySession.set(session, pending);
+        const records = pending;
+        const unsubscribe = session.subscribe(event => {
+            if (event.type === "queue_update") {
+                // SDK consumes the first matching text. Keep the remaining suffix
+                // for duplicate prompts, including prompts without image attachments.
+                for (const lane of ["steering", "followUp"]) {
+                    const counts = new Map();
+                    for (const text of event[lane])
+                        counts.set(text, (counts.get(text) ?? 0) + 1);
+                    records[lane] = records[lane].slice().reverse().filter(record => {
+                        const count = counts.get(record.text) ?? 0;
+                        counts.set(record.text, count - 1);
+                        return count > 0;
+                    }).reverse();
+                }
+            }
+            if (event.type === "agent_settled") {
+                imagesBySession.delete(session);
+                unsubscribe();
+            }
+        });
+    }
+    await session.prompt(input.text, {
+        expandPromptTemplates: !template,
+        images: input.images, streamingBehavior: queue ? "followUp" : "steer",
+        preflightResult: disposition => {
+            if (disposition === "queued") {
+                const lane = queue ? "followUp" : "steering";
+                const native = queue ? session.getFollowUpMessages() : session.getSteeringMessages();
+                const accepted = native.at(-1);
+                if (accepted !== undefined)
+                    pending[lane].push({ text: accepted, images: input.images });
+            }
+            acknowledge(disposition !== "handled");
+        },
+    });
+}
+/** Snapshot attachments before clearQueue emits the empty native queue. */
+export function recallPending(session) {
+    const pending = imagesBySession.get(session);
+    const images = pending ? [...pending.steering, ...pending.followUp].flatMap(record => record.images) : [];
+    return { ...session.clearQueue(), images };
+}

package/dist/server/protocol-version.js

@@ -0,0 +1,11 @@
+/**
+ * Wire-protocol version. Bump whenever a protocol change would make an old
+ * browser tab talk to a newer server (or vice versa) in a broken way — the
+ * classic symptom is "UI is new, WS handling is old" after an in-place app
+ * update before the auto-restart completes.
+ *
+ * Lives OUTSIDE protocol.ts (which must stay pure types). The frontend keeps
+ * its own copy in web/src/protocol-version.ts; scripts/check-protocol-sync.mjs
+ * verifies the two never drift.
+ */
+export const PROTOCOL_VERSION = 41;

package/dist/server/protocol.js

@@ -0,0 +1,6 @@
+/**
+ * Wire protocol between the browser client and the pi-harness server.
+ * Pure JSON over WebSocket. The web frontend mirrors these types in
+ * web/src/types.ts (kept in sync by hand — types only, no shared runtime code).
+ */
+export {};

package/dist/server/provider-auth.js

@@ -0,0 +1,99 @@
+import { randomUUID } from "node:crypto";
+/** Bridge official provider login; credentials remain entirely inside ModelRuntime. */
+export class ProviderAuthService {
+    runtime;
+    emit;
+    changed;
+    getDeviceId;
+    controller;
+    pending;
+    state = null;
+    constructor(runtime, emit, changed, getDeviceId) {
+        this.runtime = runtime;
+        this.emit = emit;
+        this.changed = changed;
+        this.getDeviceId = getDeviceId;
+    }
+    replay() { if (this.state)
+        this.emit({ type: "provider_auth", state: this.state }); }
+    respond(requestId, promptId, value) {
+        if (this.state?.requestId === requestId && this.pending?.id === promptId)
+            this.pending.resolve(value);
+    }
+    cancel(requestId) {
+        if (!requestId || this.state?.requestId === requestId)
+            this.controller?.abort();
+    }
+    async logout(provider) {
+        this.cancel();
+        try {
+            await this.runtime().logout(provider);
+            await this.changed();
+        }
+        catch (error) {
+            this.emit({ type: "notice", level: "error", text: error instanceof Error ? error.message : "Sign-out failed" });
+        }
+    }
+    publish(state) { this.state = state; this.emit({ type: "provider_auth", state }); }
+    async login(provider) {
+        this.cancel();
+        const requestId = randomUUID(), controller = new AbortController();
+        this.controller = controller;
+        const signal = controller.signal;
+        const current = () => this.state?.requestId === requestId;
+        const update = (partial) => { if (current())
+            this.publish({ ...this.state, ...partial }); };
+        this.publish({ requestId, provider, phase: "pending" });
+        const deadline = setTimeout(() => controller.abort(), 10 * 60_000);
+        deadline.unref();
+        const interaction = {
+            signal,
+            notify: event => {
+                if (event.type === "auth_url")
+                    update({ url: event.url, message: event.instructions });
+                else if (event.type === "device_code")
+                    update({ url: event.verificationUri, code: event.userCode });
+                else
+                    update({ message: event.message, ...(event.type === "info" && event.links?.length ? { url: event.links[0].url } : {}) });
+            },
+            prompt: prompt => new Promise((resolve, reject) => {
+                const promptId = randomUUID();
+                const combined = prompt.signal ? AbortSignal.any([signal, prompt.signal]) : signal;
+                const finish = (value) => {
+                    combined.removeEventListener("abort", abort);
+                    if (this.pending?.id === promptId)
+                        this.pending = undefined;
+                    if (current() && this.state?.prompt?.id === promptId)
+                        update({ prompt: undefined });
+                    if (value === undefined)
+                        reject(new DOMException("Login cancelled", "AbortError"));
+                    else
+                        resolve(value);
+                };
+                const abort = () => finish();
+                if (combined.aborted) {
+                    abort();
+                    return;
+                }
+                this.pending = { id: promptId, resolve: value => finish(value) };
+                combined.addEventListener("abort", abort, { once: true });
+                update({ prompt: { id: promptId, kind: prompt.type, message: prompt.message, ...(prompt.type === "select" ? { options: prompt.options.map(({ id, label }) => ({ id, label })) } : { placeholder: prompt.placeholder }) } });
+            }),
+        };
+        try {
+            if (!this.runtime().getProvider(provider)?.auth.oauth)
+                throw new Error("Provider does not support OAuth login");
+            await this.runtime().login(provider, "oauth", interaction, { getDeviceId: this.getDeviceId });
+            await this.changed();
+            update({ phase: "success", url: undefined, code: undefined, prompt: undefined, message: undefined });
+        }
+        catch (error) {
+            update({ phase: signal.aborted ? "cancelled" : "error", message: signal.aborted ? undefined : error instanceof Error ? error.message : "Login failed", url: undefined, code: undefined, prompt: undefined });
+        }
+        finally {
+            clearTimeout(deadline);
+            if (this.controller === controller)
+                this.controller = undefined;
+        }
+    }
+}

package/dist/server/query-cache.js

@@ -0,0 +1,45 @@
+/** TTL + stale-while-revalidate, with one in-flight scan per key. */
+export class QueryCache {
+    ttl;
+    maxEntries;
+    entries = new Map();
+    constructor(ttl, maxEntries = 24) {
+        this.ttl = ttl;
+        this.maxEntries = maxEntries;
+    }
+    clear() { this.entries.clear(); }
+    async get(key, scan, refreshed) {
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = { expires: 0 };
+            this.entries.set(key, entry);
+        }
+        else {
+            this.entries.delete(key);
+            this.entries.set(key, entry);
+        }
+        while (this.entries.size > this.maxEntries) {
+            this.entries.delete(this.entries.keys().next().value);
+        }
+        if (entry.value !== undefined && entry.expires > Date.now())
+            return entry.value;
+        if (!entry.pending) {
+            const current = entry;
+            const hadValue = current.value !== undefined;
+            current.pending = scan().then((value) => {
+                if (this.entries.get(key) === current) {
+                    current.value = value;
+                    current.expires = Date.now() + this.ttl;
+                    if (hadValue)
+                        refreshed?.(value);
+                }
+                return value;
+            }).finally(() => { current.pending = undefined; });
+        }
+        if (entry.value !== undefined) {
+            void entry.pending.catch(() => { });
+            return entry.value;
+        }
+        return entry.pending;
+    }
+}

package/dist/server/recovery-state.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+/** Compaction and its summary retry have independent lifetimes. */
+export function recoveryEvent(state, event, now = Date.now(), contextTokens) {
+    switch (event.type) {
+        case "compaction_start": return { ...state, lastCompaction: undefined, compaction: { id: randomUUID(), reason: event.reason, tokensBefore: contextTokens } };
+        case "compaction_end": return { ...state, compaction: undefined, lastCompaction: {
+                id: state.compaction?.id ?? randomUUID(), reason: event.reason,
+                status: event.aborted ? "aborted" : event.result ? "completed" : "error",
+                tokensBefore: event.result?.tokensBefore ?? state.compaction?.tokensBefore,
+                tokensAfter: event.result && !event.aborted ? contextTokens : undefined,
+                error: event.errorMessage?.slice(0, 500),
+            } };
+        case "auto_retry_start": return { ...state, retry: { id: randomUUID(), phase: "waiting", attempt: event.attempt, maxAttempts: event.maxAttempts, deadline: now + event.delayMs, error: event.errorMessage.slice(0, 500) } };
+        case "agent_start": return state.retry ? { ...state, retry: { ...state.retry, phase: "running" } } : state;
+        case "auto_retry_end": return { ...state, retry: undefined };
+        case "summarization_retry_scheduled": return { ...state, summary: { id: randomUUID(), source: state.compaction ? "compaction" : "branchSummary", phase: "waiting", attempt: event.attempt, maxAttempts: event.maxAttempts, deadline: now + event.delayMs, error: event.errorMessage.slice(0, 500) } };
+        case "summarization_retry_attempt_start": return { ...state, summary: { ...state.summary, id: state.summary?.id ?? randomUUID(), source: event.source, phase: "running", deadline: undefined } };
+        case "summarization_retry_finished": return { ...state, summary: undefined };
+        case "agent_settled": return { ...(state.branch ? { branch: state.branch } : {}), ...(state.lastCompaction ? { lastCompaction: state.lastCompaction } : {}) };
+        default: return state;
+    }
+}
+export function isRecovering(state) { return !!(state.compaction || state.retry || state.summary || state.branch); }
+/** Send durations, never compare clocks on different machines. Reconnection resamples the duration. */
+export function recoverySnapshot(state, now = Date.now()) {
+    const { retry, summary, ...rest } = state;
+    const snapshot = { ...rest };
+    if (retry) {
+        const { deadline, ...operation } = retry;
+        snapshot.retry = { ...operation, remainingMs: retry.phase === "waiting" ? Math.max(0, deadline - now) : 0 };
+    }
+    if (summary) {
+        const { deadline, ...operation } = summary;
+        snapshot.summary = { ...operation, remainingMs: summary.phase === "waiting" && deadline !== undefined ? Math.max(0, deadline - now) : 0 };
+    }
+    return snapshot;
+}