@youweichen/pi-web-ui 0.45.0

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/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 = 10;

package/dist/server/protocol.js

@@ -0,0 +1,6 @@
+/**
+ * Wire protocol between the browser client and the pi-web-ui 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/scm.js

@@ -0,0 +1,298 @@
+/**
+ * Read-only git queries backing the source-control panel.
+ *
+ * Replaces the old hidden-PTY + text-scraping approach: every query is a
+ * plain `execFile("git", …)` — no shell, no prompts, no echo, no sentinel
+ * parsing. Output is parsed into structured JSON on the server; the client
+ * just renders it.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+/** Per-command timeout / output cap — a stuck repo must not hang the panel. */
+const GIT_TIMEOUT_MS = 15_000;
+const MAX_GIT_OUTPUT = 16 * 1024 * 1024;
+/** Run one git command; throws Error with a readable message on failure. */
+async function git(cwd, args) {
+    try {
+        const { stdout } = await exec("git", ["-c", "core.quotepath=false", ...args], {
+            cwd,
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: MAX_GIT_OUTPUT,
+            windowsHide: true,
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT")
+            throw new Error("未找到 git 命令——请确认已安装 Git 并在 PATH 中");
+        if (e.killed)
+            throw new Error("git 命令超时");
+        const detail = (e.stderr ?? e.message ?? "").trim().split("\n")[0];
+        throw new Error(detail || "git 命令失败");
+    }
+}
+/** Absolute path of the repo's git dir (handles worktrees/submodules), or
+ *  null when cwd isn't inside a repository. */
+export async function gitDirOf(cwd) {
+    try {
+        const { stdout } = await exec("git", ["rev-parse", "--absolute-git-dir"], {
+            cwd,
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when the error is "this directory isn't a git repository". */
+export function isNotRepoError(err) {
+    return /not a git repository/i.test(err instanceof Error ? err.message : String(err));
+}
+/* ------------------------------------------------------------------ */
+/* parsers                                                             */
+/* ------------------------------------------------------------------ */
+/** Undo git's C-style quoting for unusual file names ("a\tb" → a<TAB>b).
+ *  core.quotepath=false already handles non-ASCII; this covers control chars. */
+function unquotePath(s) {
+    if (!s.startsWith('"'))
+        return s;
+    const inner = s.endsWith('"') ? s.slice(1, -1) : s.slice(1);
+    return inner.replace(/\\(.)/g, (_m, c) => {
+        switch (c) {
+            case "n": return "\n";
+            case "t": return "\t";
+            case "r": return "\r";
+            case "b": return "\b";
+            case "a": return "\a";
+            case "f": return "\f";
+            case "v": return "\v";
+            case "\\": return "\\";
+            case '"': return '"';
+            default: return c;
+        }
+    });
+}
+function parseStatusHeader(rest) {
+    const out = {
+        branch: "HEAD",
+        detached: false,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        upstreamGone: false,
+    };
+    let branchPart = rest;
+    let flags = "";
+    const bi = rest.indexOf(" [");
+    if (bi >= 0) {
+        branchPart = rest.slice(0, bi);
+        flags = rest.slice(bi + 2);
+        if (flags.endsWith("]"))
+            flags = flags.slice(0, -1);
+    }
+    if (branchPart === "HEAD (no branch)" || branchPart === "HEAD") {
+        out.detached = true;
+    }
+    else {
+        if (branchPart.startsWith("No commits yet on "))
+            branchPart = branchPart.slice("No commits yet on ".length);
+        const up = branchPart.indexOf("...");
+        if (up >= 0) {
+            out.branch = branchPart.slice(0, up);
+            out.upstream = branchPart.slice(up + 3);
+        }
+        else {
+            out.branch = branchPart;
+        }
+    }
+    if (flags) {
+        for (const part of flags.split(",")) {
+            const p = part.trim();
+            const m = p.match(/^(ahead|behind) (\d+)$/);
+            if (m) {
+                if (m[1] === "ahead")
+                    out.ahead = Number(m[2]);
+                else
+                    out.behind = Number(m[2]);
+            }
+            else if (p === "gone") {
+                out.upstreamGone = true;
+            }
+        }
+    }
+    return out;
+}
+function parseStatusFiles(text) {
+    const out = [];
+    for (const rawLine of text.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (!line || line.startsWith("## "))
+            continue;
+        if (line.length >= 3) {
+            let path = line.slice(3);
+            const arrow = path.indexOf(" -> "); // rename: "R  old -> new"
+            if (arrow >= 0)
+                path = path.slice(arrow + 4);
+            out.push({ path: unquotePath(path), x: line[0], y: line[1] });
+        }
+    }
+    return out;
+}
+function parseBranches(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const parts = line.split("\t");
+        if (parts.length < 2)
+            continue;
+        const ref = parts[0];
+        const isHead = parts[1] === "*";
+        if (ref.startsWith("refs/heads/")) {
+            out.push({ name: ref.slice("refs/heads/".length), current: isHead });
+        }
+        else if (ref.startsWith("refs/remotes/")) {
+            const short = ref.slice("refs/remotes/".length);
+            // Skip the "origin/HEAD -> origin/main" symlink.
+            if (short.endsWith("/HEAD"))
+                continue;
+            const slash = short.indexOf("/");
+            out.push({
+                name: short,
+                current: false,
+                remote: slash > 0 ? short.slice(0, slash) : true,
+            });
+        }
+    }
+    return out;
+}
+/** Parse `git log --graph --pretty=format:%H%x09…` preserving graph prefixes. */
+function parseCommitHistory(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const tab = line.indexOf("\t");
+        if (tab < 0)
+            continue; // connector-only graph line
+        const prefixAndHash = line.slice(0, tab);
+        const match = prefixAndHash.match(/([0-9a-f]{7,40})$/i);
+        if (!match || match.index === undefined)
+            continue;
+        const fields = line.slice(tab + 1).split("\t");
+        // An empty decoration field removes the final tab — four fields is a
+        // valid undecorated commit.
+        if (fields.length < 4)
+            continue;
+        out.push({
+            hash: match[1],
+            shortHash: fields[0],
+            author: fields[1],
+            date: fields[2],
+            subject: fields[3],
+            decorations: fields[4] ?? "",
+            graph: prefixAndHash.slice(0, match.index),
+        });
+    }
+    return out;
+}
+/** Parse `git diff --numstat` output: "12\t3\tpath" → { path: [add, del] }. */
+function parseNumStat(text) {
+    const stats = {};
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        const tab1 = line.indexOf("\t");
+        const tab2 = tab1 < 0 ? -1 : line.indexOf("\t", tab1 + 1);
+        if (tab2 < 0)
+            continue;
+        let add = Number(line.slice(0, tab1));
+        let del = Number(line.slice(tab1 + 1, tab2));
+        if (!Number.isFinite(add))
+            add = 0; // binary file → "-"
+        if (!Number.isFinite(del))
+            del = 0;
+        const path = unquotePath(line.slice(tab2 + 1).trim());
+        const prev = stats[path];
+        stats[path] = [
+            (prev?.[0] ?? 0) + add,
+            (prev?.[1] ?? 0) + del,
+        ];
+    }
+    return stats;
+}
+/* ------------------------------------------------------------------ */
+/* queries                                                             */
+/* ------------------------------------------------------------------ */
+const HISTORY_ARGS = [
+    "log",
+    "--all",
+    "--graph",
+    "--decorate=short",
+    "--date=short",
+    "--pretty=format:%H%x09%h%x09%an%x09%ad%x09%s%x09%D",
+    "-n",
+    "120",
+];
+/** Commit graph for the history tab — fetched lazily so the common
+ *  "changes" view never pays for it on huge repos. */
+export async function scmHistory(cwd) {
+    return parseCommitHistory(await git(cwd, HISTORY_ARGS));
+}
+/** Status refresh payload (status + branches + numstat) — parallel. */
+export async function scmStatus(cwd) {
+    const [statusText, branchText, statText, cachedStatText] = await Promise.all([
+        git(cwd, ["status", "--porcelain=v1", "-b", "--find-renames"]),
+        git(cwd, [
+            "for-each-ref",
+            "refs/heads",
+            "refs/remotes",
+            "--format=%(refname)%09%(HEAD)",
+        ]),
+        git(cwd, ["diff", "--numstat"]),
+        git(cwd, ["diff", "--cached", "--numstat"]),
+    ]);
+    const header = parseStatusHeader(statusText.split("\n").find((l) => l.startsWith("## "))?.slice(3) ?? "");
+    // Worktree + staged line counts, merged per path.
+    const merged = {};
+    for (const [path, pair] of Object.entries(parseNumStat(statText))) {
+        merged[path] = pair;
+    }
+    for (const [path, pair] of Object.entries(parseNumStat(cachedStatText))) {
+        const prev = merged[path];
+        merged[path] = [(prev?.[0] ?? 0) + pair[0], (prev?.[1] ?? 0) + pair[1]];
+    }
+    return {
+        notRepo: false,
+        branch: header.branch,
+        detached: header.detached,
+        upstream: header.upstream,
+        ahead: header.ahead,
+        behind: header.behind,
+        upstreamGone: header.upstreamGone,
+        files: parseStatusFiles(statusText),
+        branches: parseBranches(branchText),
+        stats: merged,
+    };
+}
+/** Staged + worktree diffs for one file (empty strings when no diff). */
+export async function scmFileDiff(cwd, path) {
+    const [staged, worktree] = await Promise.all([
+        git(cwd, ["diff", "--cached", "--no-color", "--no-ext-diff", "--", path]).catch(() => ""),
+        git(cwd, ["diff", "--no-color", "--no-ext-diff", "--", path]).catch(() => ""),
+    ]);
+    return { staged, worktree };
+}
+/** Full patch of one commit (`git show`). */
+export async function scmCommitDetail(cwd, hash) {
+    return git(cwd, [
+        "show",
+        "--no-color",
+        "--no-ext-diff",
+        "--find-renames",
+        "--format=fuller",
+        "--stat",
+        "--patch",
+        hash,
+    ]);
+}

package/dist/server/serialize.js

@@ -0,0 +1,172 @@
+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 };
+}
+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,
+                errorMessage: m.errorMessage,
+            };
+        case "toolResult": {
+            const raw = m.content
+                .map((c) => (c.type === "text" ? c.text : "[image result]"))
+                .join("\n");
+            const { text, truncated } = truncate(raw, TOOL_OUTPUT_CAP);
+            return {
+                id: `t-${m.toolCallId}`,
+                role: "toolResult",
+                content: [{ type: "text", text, truncated }],
+                toolCallId: m.toolCallId,
+                toolName: m.toolName,
+                isError: m.isError,
+                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}` };
+}