@youweichen/pi-web-ui 0.45.0

package/dist/server/bg-servers.js

@@ -0,0 +1,150 @@
+import { killPidTree, lookupProcessName, lookupProcessCommandLine, snapshotListeningPorts, } from "./process-utils.js";
+const BG_REFRESH_INTERVAL_MS = 30_000;
+/** bash 结束后等这么久再拍「后」快照——给后台服务绑定端口的时间。 */
+const BG_BIND_WAIT_MS = 1500;
+export class BgServerTracker {
+    opts;
+    servers = new Map();
+    /** bash 工具开始执行前拍的监听端口快照（tool_execution_start 时设置）。 */
+    listenBefore = null;
+    refreshTimer = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** 启动周期性存活检查（死项静默剔除）。 */
+    start() {
+        this.refreshTimer = setInterval(() => void this.refresh(), BG_REFRESH_INTERVAL_MS);
+        this.refreshTimer.unref?.();
+    }
+    stop() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    /** tool_execution_start(bash)：先记下「前」快照。 */
+    snapshotBefore() {
+        void snapshotListeningPorts().then((m) => {
+            this.listenBefore = m;
+        });
+    }
+    /** After a bash tool run, wait briefly for background servers to bind,
+     *  then diff the listening-port snapshot against the pre-run one and
+     *  remember anything new — those are servers the agent left running. */
+    async trackAfterBash() {
+        const before = this.listenBefore;
+        this.listenBefore = null;
+        if (!before)
+            return;
+        await new Promise((r) => setTimeout(r, BG_BIND_WAIT_MS));
+        const after = await snapshotListeningPorts();
+        let added = false;
+        for (const [port, pid] of after) {
+            if (!before.has(port) && !this.servers.has(port)) {
+                this.servers.set(port, { pid, since: Date.now() });
+                added = true;
+                // Best-effort process name + full command line so the panel shows
+                // something readable (name) AND what is actually running (command).
+                void lookupProcessName(pid).then((name) => {
+                    const cur = this.servers.get(port);
+                    if (cur && cur.pid === pid && name) {
+                        cur.name = name;
+                        this.push();
+                    }
+                });
+                void lookupProcessCommandLine(pid).then((command) => {
+                    const cur = this.servers.get(port);
+                    if (cur && cur.pid === pid && command) {
+                        cur.command = command;
+                        this.push();
+                    }
+                });
+                this.opts.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `检测到 AI 启动的后台服务：端口 ${port}（pid ${pid}）——可在顶栏「后台任务」里单独停止或全部关闭`,
+                });
+            }
+        }
+        if (added)
+            this.push();
+    }
+    /** The current background-server list, oldest first. 合并插件任务。 */
+    list() {
+        const out = [...this.servers.entries()]
+            .map(([port, v]) => ({
+            port,
+            pid: v.pid,
+            since: v.since,
+            ...(v.name ? { name: v.name } : {}),
+            ...(v.command ? { command: v.command } : {}),
+        }))
+            .sort((a, b) => a.since - b.since);
+        for (const t of this.opts.pluginTasks?.() ?? [])
+            out.push(t);
+        return out;
+    }
+    /** Push the current background-task list to every connected socket. */
+    push() {
+        this.opts.emit({ type: "bg_servers", servers: this.list() });
+    }
+    /** Re-snapshot listening ports and drop tracked entries that are no longer
+     *  listening — the process exited on its own, so it must leave the panel.
+     *  Port AND pid must both match: a port reused by an unrelated process is
+     *  not our server anymore. Silent (the list just updates). */
+    async refresh() {
+        if (this.opts.isDisposed() || this.servers.size === 0)
+            return;
+        const now = await snapshotListeningPorts();
+        let changed = false;
+        for (const [port, v] of [...this.servers]) {
+            if (now.get(port) !== v.pid) {
+                this.servers.delete(port);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.push();
+    }
+    /** Re-push the current list on request (panel opened); prunes dead entries first. */
+    async listAndPush() {
+        await this.refresh();
+        this.push();
+    }
+    /** Kill ONE background server (by port); returns whether anything was killed. */
+    async killOne(port) {
+        const entry = this.servers.get(port);
+        if (!entry) {
+            this.opts.emit({
+                type: "notice",
+                level: "info",
+                text: `端口 ${port} 不在后台任务列表中`,
+            });
+            this.opts.flushSnapshot();
+            return false;
+        }
+        killPidTree(entry.pid);
+        this.servers.delete(port);
+        this.push();
+        this.opts.emit({
+            type: "notice",
+            level: "info",
+            text: `已停止后台任务：端口 ${port}（pid ${entry.pid}）`,
+        });
+        this.opts.flushSnapshot();
+        return true;
+    }
+    /** Kill every background server the agent started; returns the freed ports. */
+    async killAll() {
+        if (this.servers.size === 0)
+            return [];
+        const killed = [];
+        for (const [port, { pid }] of [...this.servers]) {
+            killPidTree(pid);
+            killed.push(String(port));
+        }
+        this.servers.clear();
+        this.push();
+        return killed;
+    }
+}

package/dist/server/client-state.js

@@ -0,0 +1,234 @@
+/**
+ * client-state — 每浏览器客户端的持久化 UI 状态（<dataDir>/client-state.json）：
+ * 最近项目/工作目录、目标审查偏好、设置面板状态（提示词模式 + 技能/插件开关 +
+ * 视觉桥偏好）、命名预设。文件 I/O 一律 best-effort：持久化故障绝不能
+ * 弄崩 server 或阻塞会话。
+ *
+ * 从 agent-service.ts 抽出，行为保持不变。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** Stable identity of an extension for the enable/disable toggle: the npm
+ *  spec for packages (survives version bumps), the resolved entry path
+ *  otherwise. */
+export function extensionKey(e) {
+    const src = e.sourceInfo;
+    if (src?.origin === "package" && src.source)
+        return src.source;
+    return src?.path ?? e.path;
+}
+/** All identities an extension may be disabled by. The SDK applies
+ *  `sourceInfo` only AFTER extensionsOverride runs (resource-loader reload():
+ *  override first, applyExtensionSourceInfo second), so inside the override a
+ *  package extension still has no sourceInfo and extensionKey() falls back to
+ *  the raw entry path — which never matches the "npm:<pkg>" id the settings
+ *  panel stores. Derive the package name from the entry path
+ *  (.../node_modules/<pkg>/... or .../node_modules/@scope/<pkg>/...) so both
+ *  sides agree. */
+export function extensionKeyCandidates(e) {
+    const keys = new Set([extensionKey(e)]);
+    const norm = e.path.replace(/\\/g, "/");
+    const marker = "/node_modules/";
+    const idx = norm.lastIndexOf(marker);
+    if (idx !== -1) {
+        const segs = norm.slice(idx + marker.length).split("/");
+        // Scoped package @scope/name spans two segments.
+        const name = segs[0]?.startsWith("@") && segs[1] ? `${segs[0]}/${segs[1]}` : segs[0];
+        if (name)
+            keys.add(`npm:${name}`);
+    }
+    return [...keys];
+}
+/** Whether an extension is covered by the disabled list (any identity match). */
+export function isExtensionDisabled(e, disabled) {
+    if (disabled.length === 0)
+        return false;
+    const keys = extensionKeyCandidates(e);
+    return disabled.some((d) => keys.includes(d));
+}
+/**
+ * Persists which workspace each browser client last used + which workspaces it
+ * has opened, so a server restart / page reload restores the same project and
+ * the UI can offer a one-click recent-project list. File I/O is best-effort:
+ * persistence problems must never crash the server or block a session.
+ */
+export class ClientStateStore {
+    filePath;
+    cache = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        try {
+            const parsed = JSON.parse(readFileSync(this.filePath, "utf8"));
+            this.cache = parsed && typeof parsed === "object" ? parsed : {};
+        }
+        catch {
+            this.cache = {};
+        }
+        return this.cache;
+    }
+    save() {
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            // Atomic write (tmp + rename): a crash mid-write must never leave a
+            // half-written JSON — that would wipe ALL persisted state (recent
+            // projects / presets / settings / goal prefs) on next load.
+            const tmp = `${this.filePath}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify(this.cache, null, 2) + "\n");
+            renameSync(tmp, this.filePath);
+        }
+        catch {
+            // best effort
+        }
+    }
+    get(clientId) {
+        return this.load()[clientId] ?? { projects: [] };
+    }
+    /** Remember which workspace a client last used; bumps its project entry. */
+    remember(clientId, cwd) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.lastCwd = cwd;
+        const now = Date.now();
+        state.projects = [
+            { path: cwd, lastUsed: now },
+            ...state.projects.filter((p) => p.path !== cwd),
+        ].slice(0, 30);
+        // Opening the workspace again clears its removal tombstone.
+        if (state.removedProjects?.length) {
+            state.removedProjects = state.removedProjects.filter((p) => p !== cwd);
+        }
+        this.save();
+    }
+    /** Drop one workspace from the recent-project list (user-requested removal).
+     *  Records a tombstone too: pushProjects() re-discovers cwds from session
+     *  files on every listing, so without it the entry would instantly reappear. */
+    removeProject(clientId, cwd) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.projects = state.projects.filter((p) => p.path !== cwd);
+        if (state.lastCwd === cwd)
+            delete state.lastCwd;
+        const removed = new Set(state.removedProjects ?? []);
+        removed.add(cwd);
+        state.removedProjects = [...removed];
+        this.save();
+    }
+    /** Tombstoned projects (explicitly removed by the user) for filtering the
+     *  merged recent-project list. */
+    getRemovedProjects(clientId) {
+        return this.load()[clientId]?.removedProjects ?? [];
+    }
+    /** Last-used goal/review prefs for a client, or undefined if never set. */
+    getGoalPrefs(clientId) {
+        const s = this.load()[clientId];
+        if (!s?.goalPrefs)
+            return undefined;
+        return {
+            reviewModel: s.goalPrefs.reviewModel ?? null,
+            maxRounds: s.goalPrefs.maxRounds ?? 0,
+            locked: s.goalPrefs.locked ?? true,
+        };
+    }
+    /** Persist the client's goal/review preferences (model choice, rounds, lock). */
+    saveGoalPrefs(clientId, prefs) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.goalPrefs = {
+            reviewModel: prefs?.reviewModel ?? null,
+            maxRounds: prefs?.maxRounds ?? 0,
+            locked: prefs?.locked ?? true,
+        };
+        this.save();
+    }
+    /** Remember conversations that were still streaming at shutdown (best-
+     *  effort; called during the graceful-shutdown path). */
+    saveInterrupted(clientId, list) {
+        if (list.length === 0)
+            return;
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.interrupted = list.slice(0, 8);
+        this.save();
+    }
+    /** Consume the interrupted-conversation record (returns and clears it) —
+     *  called once on the client's first attach after a restart. */
+    takeInterrupted(clientId) {
+        const all = this.load();
+        const state = all[clientId];
+        const list = state?.interrupted;
+        if (list?.length && state) {
+            delete state.interrupted;
+            this.save();
+        }
+        return list;
+    }
+    /** Last-used settings-panel state for a client, or defaults. */
+    getSettings(clientId) {
+        const s = this.load()[clientId];
+        return {
+            promptMode: s?.settings?.promptMode === "replace" ? "replace" : "append",
+            customSystemPrompt: s?.settings?.customSystemPrompt ?? "",
+            disabledSkills: s?.settings?.disabledSkills ?? [],
+            disabledExtensions: s?.settings?.disabledExtensions ?? [],
+            terminalToolsEnabled: s?.settings?.terminalToolsEnabled ?? true,
+            terminalBash: s?.settings?.terminalBash ?? false,
+            terminalBashIdleMs: s?.settings?.terminalBashIdleMs ?? 15_000,
+            thinkingWrap: s?.settings?.thinkingWrap ?? false,
+            toolsWrap: s?.settings?.toolsWrap ?? true,
+            visionBridgeEnabled: s?.settings?.visionBridgeEnabled ?? true,
+            visionBridgeModel: s?.settings?.visionBridgeModel ?? null,
+            visionBridgePromptMode: s?.settings?.visionBridgePromptMode === "replace" ? "replace" : "append",
+            visionBridgePrompt: s?.settings?.visionBridgePrompt ?? "",
+            reviewPrompt: s?.settings?.reviewPrompt ?? "",
+            reviewDisabledSkills: s?.settings?.reviewDisabledSkills ?? [],
+            disabledPlugins: s?.settings?.disabledPlugins ?? [],
+        };
+    }
+    /** Persist the client's settings-panel state (partial merge). */
+    saveSettings(clientId, settings) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        const cur = state.settings ?? {};
+        state.settings = {
+            promptMode: settings.promptMode ?? cur.promptMode ?? "append",
+            customSystemPrompt: settings.customSystemPrompt ?? cur.customSystemPrompt ?? "",
+            disabledSkills: settings.disabledSkills ?? cur.disabledSkills ?? [],
+            disabledExtensions: settings.disabledExtensions ?? cur.disabledExtensions ?? [],
+            terminalToolsEnabled: settings.terminalToolsEnabled ?? cur.terminalToolsEnabled ?? true,
+            terminalBash: settings.terminalBash ?? cur.terminalBash ?? false,
+            terminalBashIdleMs: settings.terminalBashIdleMs ?? cur.terminalBashIdleMs ?? 15_000,
+            thinkingWrap: settings.thinkingWrap ?? cur.thinkingWrap ?? false,
+            toolsWrap: settings.toolsWrap ?? cur.toolsWrap ?? true,
+            visionBridgeEnabled: settings.visionBridgeEnabled ?? cur.visionBridgeEnabled ?? true,
+            visionBridgeModel: settings.visionBridgeModel ?? cur.visionBridgeModel ?? null,
+            visionBridgePromptMode: settings.visionBridgePromptMode ??
+                cur.visionBridgePromptMode ??
+                "append",
+            visionBridgePrompt: settings.visionBridgePrompt ?? cur.visionBridgePrompt ?? "",
+            reviewPrompt: settings.reviewPrompt ?? cur.reviewPrompt ?? "",
+            reviewDisabledSkills: settings.reviewDisabledSkills ?? cur.reviewDisabledSkills ?? [],
+            disabledPlugins: settings.disabledPlugins ?? cur.disabledPlugins ?? [],
+        };
+        this.save();
+    }
+    /** Named settings presets for a client (empty if never saved). */
+    getPresets(clientId) {
+        return (this.load()[clientId]?.presets ?? []).map((p) => ({
+            ...p,
+            // Older client-state files predate review settings.
+            reviewPrompt: p.reviewPrompt ?? "",
+            reviewDisabledSkills: p.reviewDisabledSkills ?? [],
+        }));
+    }
+    /** Persist the client's named settings presets. */
+    savePresets(clientId, presets) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        state.presets = presets;
+        this.save();
+    }
+}

package/dist/server/control-socket.js

@@ -0,0 +1,177 @@
+/**
+ * Local control socket for the pi-web-ui server.
+ *
+ * Lets the CLI (and humans) query status and quiesce/unquiesce the server
+ * WITHOUT opening a network port or exposing an unauthenticated HTTP
+ * endpoint. Only the local OS user can reach it:
+ *   - POSIX: a mode-0600 Unix domain socket at <dataDir>/pi-web-ui.sock
+ *   - Windows: a named pipe  \\.\pipe\pi-web-ui-<port>
+ *
+ * Protocol: one JSON object per line.
+ *   → {"cmd":"status"}        ← {"ok":true, ...serviceStatus}
+ *   → {"cmd":"quiesce"}       ← {"ok":true}
+ *   → {"cmd":"unquiesce"}     ← {"ok":true}
+ *   → anything else           ← {"ok":false,"error":"..."}
+ *
+ * Idle connections are closed after a short timeout so a stuck CLI never
+ * holds the socket.
+ */
+import { createServer, createConnection } from "node:net";
+import { chmodSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+/** How long a control connection may sit idle before the server closes it. */
+const CONTROL_IDLE_TIMEOUT_MS = 5_000;
+/** How long the CLI waits for a reply before giving up. */
+const CONTROL_CLIENT_TIMEOUT_MS = 3_000;
+/** Socket path (POSIX) or pipe name (Windows). */
+export function controlPath(dataDir, port) {
+    return process.platform === "win32"
+        ? `\\\\.\\pipe\\pi-web-ui-${port}`
+        : join(dataDir, "pi-web-ui.sock");
+}
+/** Start the control socket; returns a stop function. */
+export function startControlServer(opts) {
+    const { service, dataDir, port } = opts;
+    const path = controlPath(dataDir, port);
+    let server;
+    let stop = false;
+    if (process.platform === "win32") {
+        server = createServer(handleConnection);
+    }
+    else {
+        // Remove a stale socket left by a previous crash (only if it's ours —
+        // an existing socket file that refuses connections is stale).
+        if (existsSync(path)) {
+            try {
+                rmSync(path);
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        server = createServer(handleConnection);
+    }
+    // A second instance on the same data dir / port would fail to bind — don't
+    // crash the server over it, just log and run without a control socket.
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.warn(`[control] socket ${path} already in use — control socket disabled`);
+        }
+        else {
+            console.warn(`[control] socket error: ${err.message}`);
+        }
+    });
+    function handleConnection(sock) {
+        let buf = "";
+        const timer = setTimeout(() => {
+            sock.destroy();
+        }, CONTROL_IDLE_TIMEOUT_MS);
+        sock.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            let nl;
+            while ((nl = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                timer.refresh();
+                let req;
+                try {
+                    req = JSON.parse(line);
+                }
+                catch {
+                    sock.write(JSON.stringify({ ok: false, error: "bad json" }) + "\n");
+                    continue;
+                }
+                let resp;
+                switch (req.cmd) {
+                    case "status":
+                        resp = { ok: true, ...service.serviceStatus() };
+                        break;
+                    case "quiesce":
+                        service.quiesce();
+                        resp = { ok: true };
+                        break;
+                    case "unquiesce":
+                        service.unquiesce();
+                        resp = { ok: true };
+                        break;
+                    default:
+                        resp = { ok: false, error: `unknown cmd: ${String(req.cmd)}` };
+                        break;
+                }
+                sock.write(JSON.stringify(resp) + "\n");
+            }
+        });
+        sock.on("error", () => {
+            /* client vanished */
+        });
+        sock.on("close", () => clearTimeout(timer));
+    }
+    if (process.platform === "win32") {
+        // net.Server on a named pipe: listen on the pipe name directly.
+        server.listen(path, () => {
+            console.log(`  control    : ${path}`);
+        });
+    }
+    else {
+        server.listen(path, () => {
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch {
+                /* best-effort */
+            }
+            console.log(`  control    : ${path}`);
+        });
+    }
+    return () => {
+        stop = true;
+        server.close();
+        try {
+            if (process.platform !== "win32" && existsSync(path))
+                rmSync(path);
+        }
+        catch {
+            /* best-effort */
+        }
+    };
+}
+/**
+ * CLI-side client: send one command and return the parsed reply (or null if
+ * the server is unreachable / timed out).
+ */
+export function sendControlCommand(dataDir, port, cmd) {
+    const path = controlPath(dataDir, port);
+    return new Promise((resolve) => {
+        const sock = createConnection(path);
+        let done = false;
+        const finish = (v) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            sock.destroy();
+            resolve(v);
+        };
+        const timer = setTimeout(() => finish(null), CONTROL_CLIENT_TIMEOUT_MS);
+        let buf = "";
+        sock.on("connect", () => {
+            sock.write(JSON.stringify({ cmd }) + "\n");
+        });
+        sock.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            const nl = buf.indexOf("\n");
+            if (nl >= 0) {
+                try {
+                    finish(JSON.parse(buf.slice(0, nl)));
+                }
+                catch {
+                    finish(null);
+                }
+            }
+        });
+        sock.on("error", () => finish(null));
+        sock.on("close", () => finish(null));
+    });
+}

package/dist/server/ensure-bash.js

@@ -0,0 +1,80 @@
+/**
+ * Lightweight bash fallback for Windows.
+ *
+ * When neither Git Bash nor a bash on PATH exists, download busybox-w32
+ * (single self-contained ~1.5MB exe, no installer) into <home>/.pi-web/bin/
+ * and expose it as bash.exe — busybox dispatches on argv[0], so `bash.exe`
+ * runs its bash (ash) applet. The terminal panel (terminals.ts) and the SDK
+ * bash tool (via PATH) then both resolve to it, so the agent never silently
+ * falls back to cmd/PowerShell syntax on a bare Windows box.
+ *
+ * Download is fire-and-forget at server start and never throws: on failure
+ * the terminal simply falls back to $COMSPEC (cmd.exe) as before.
+ */
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Official busybox-w32 64-bit Unicode build (Win10 1903+ / Win11). */
+const BUSYBOX_URL = "https://frippery.org/files/busybox/busybox64u.exe";
+/** busybox.exe is ~660KB; anything far smaller is an error page, not a binary. */
+const MIN_SIZE = 500_000;
+/** Download cap — a stalled connection must not block startup forever. */
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+/** Directory holding the busybox fallback (shared with terminals.ts / PATH). */
+export function windowsBashDir() {
+    return join(homedir(), ".pi-web", "bin");
+}
+/** bash.exe (busybox bash applet) used by the terminal and the SDK bash tool. */
+export function windowsBashPath() {
+    return join(windowsBashDir(), "bash.exe");
+}
+/** True when a standard Git Bash install exists (SDK's preferred shell). */
+export function hasGitBash() {
+    const pf = process.env.ProgramFiles;
+    const pf86 = process.env["ProgramFiles(x86)"];
+    for (const cand of [
+        pf ? join(pf, "Git", "bin", "bash.exe") : "",
+        pf86 ? join(pf86, "Git", "bin", "bash.exe") : "",
+    ]) {
+        if (cand && existsSync(cand))
+            return true;
+    }
+    return false;
+}
+/**
+ * Ensure a bash.exe exists on Windows. No-op when Git Bash is already
+ * installed (it is strictly preferred) or the fallback is already present.
+ * Never throws — failures degrade silently to the previous behaviour.
+ *
+ * @returns the bash.exe path when ready, null otherwise.
+ */
+export async function ensureWindowsBash() {
+    if (process.platform !== "win32")
+        return null;
+    const target = windowsBashPath();
+    if (existsSync(target))
+        return target;
+    if (hasGitBash())
+        return null; // Git Bash preferred — nothing to install.
+    const dir = windowsBashDir();
+    mkdirSync(dir, { recursive: true });
+    const tmp = join(dir, `busybox-${process.pid}.tmp`);
+    try {
+        const res = await fetch(BUSYBOX_URL, {
+            signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (buf.length < MIN_SIZE)
+            return null; // error/HTML page, not the exe.
+        writeFileSync(tmp, buf);
+        renameSync(tmp, join(dir, "busybox.exe"));
+        copyFileSync(join(dir, "busybox.exe"), target);
+        return target;
+    }
+    catch {
+        rmSync(tmp, { force: true });
+        return null;
+    }
+}