@youweichen/pi-harness 0.0.0-stage → 1.1.0

package/dist/server/extensions-routes.js

@@ -0,0 +1,255 @@
+import { nativeSkills } from "./skills-service.js";
+import { mkdirSync, readFileSync, writeFileSync, renameSync, statSync, realpathSync, existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { killPidTree } from "./process-utils.js";
+import { fork } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readJson, textField, resourceTypes, sourceInfo, validateSource } from "./extensions-model.js";
+import { browseCatalog, cachedFetch, safeUrl, packageReleaseNotes } from "./extensions-catalog.js";
+const jobs = new Map();
+const tickets = new Map();
+const states = new Map();
+let mutation;
+let readers = 0;
+let canBackgroundRun = () => false;
+const background = new Map();
+function autoCheckEnabled(agentDir) { try {
+    return readJson(join(agentDir, "webui-extensions.json")).autoCheck !== false;
+}
+catch {
+    return false;
+} }
+const backgroundTimer = setInterval(() => {
+    if (mutation || readers || !canBackgroundRun())
+        return;
+    const entry = [...background].find(([, v]) => v.next <= Date.now());
+    if (!entry)
+        return;
+    const [cwd, target] = entry;
+    target.next = Date.now() + 6 * 60 * 60 * 1000;
+    if (!autoCheckEnabled(target.agentDir))
+        return;
+    readers++;
+    void runWorker({ cwd, agentDir: target.agentDir, action: "check" }).then(state => states.set(cwd, state)).catch(() => { }).finally(() => { readers--; });
+}, 60000);
+backgroundTimer.unref();
+function runWorker(input, log = () => { }) {
+    return new Promise((resolve, reject) => {
+        const child = fork(new URL(import.meta.url.endsWith(".ts") ? "./extensions-worker.ts" : "./extensions-worker.js", import.meta.url), ["--extensions-worker"], { detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe", "ipc"], execArgv: process.execArgv.filter(a => !a.startsWith("--watch")), env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", GIT_TERMINAL_PROMPT: "0" } });
+        let result, failure;
+        child.stdout?.on("data", chunk => log(String(chunk)));
+        child.stderr?.on("data", chunk => log(String(chunk)));
+        child.on("message", (message) => { if (message.progress)
+            log(message.progress); if (message.state)
+            result = message.state; if (message.error)
+            failure = Error(message.error); });
+        const stop = () => { if (child.pid)
+            killPidTree(child.pid); };
+        process.once("exit", stop);
+        const timer = setTimeout(() => { failure = Error("Package operation timed out"); stop(); }, input.action === "mutate" ? 20 * 60 * 1000 : 120000);
+        child.once("error", error => { clearTimeout(timer); process.removeListener("exit", stop); reject(error); });
+        child.once("exit", () => { clearTimeout(timer); process.removeListener("exit", stop); result && !failure ? resolve(result) : reject(failure ?? Error("Package worker stopped")); });
+        child.send(input);
+    });
+}
+async function previewSource(source) {
+    const info = sourceInfo(source);
+    let meta = {};
+    if (info.kind === "npm")
+        meta = await cachedFetch(`https://registry.npmjs.org/${encodeURIComponent(info.name)}/${encodeURIComponent(info.ref ?? "latest")}`);
+    if (info.kind === "local") {
+        try {
+            meta = readJson(join(source, "package.json"));
+        }
+        catch (e) {
+            if (e.code !== "ENOTDIR")
+                throw e;
+        }
+    }
+    const resources = {};
+    for (const type of resourceTypes)
+        if (Array.isArray(meta.pi?.[type]))
+            resources[type] = meta.pi[type].filter((v) => typeof v === "string").slice(0, 100);
+    return { source, name: textField(meta.name) ?? info.name, version: textField(meta.version), description: textField(meta.description), license: textField(meta.license), author: textField(typeof meta.author === "string" ? meta.author : meta.author?.name), repository: safeUrl(typeof meta.repository === "string" ? meta.repository : meta.repository?.url), resources, canPin: info.kind === "npm" && typeof meta.version === "string" };
+}
+export function installExtensionsRoutes(app, service, originAllowed) {
+    canBackgroundRun = () => !service().quiesceInfo().quiesced;
+    app.post("/api/extensions", async (req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        if (!originAllowed(req) || !req.is("application/json")) {
+            res.sendStatus(403);
+            return;
+        }
+        const { clientId, cwd, action } = req.body ?? {};
+        const cs = typeof clientId === "string" ? service().get(clientId) : undefined;
+        if (!cs || cs.cwd !== cwd || cs.switchingWorkspace || service().quiesceInfo().quiesced) {
+            res.status(409).json({ error: "Workspace unavailable" });
+            return;
+        }
+        const agentDir = getAgentDir();
+        try {
+            if (action === "open-info" && req.body.id === "skills:user") {
+                const path = join(agentDir, "skills");
+                res.json({ absolute: existsSync(path) ? path : agentDir });
+                return;
+            }
+            if (action === "skills-list" || action === "skills-toggle") {
+                if (mutation || readers >= 4)
+                    throw Error("Package manager busy");
+                const change = action === "skills-toggle" ? req.body : undefined;
+                if (change && (typeof change.id !== "string" || typeof change.enabled !== "boolean" || typeof change.version !== "string"))
+                    throw Error("Invalid skill change");
+                if (change)
+                    mutation = randomUUID();
+                readers++;
+                try {
+                    const valid = () => cs.cwd === cwd && !cs.switchingWorkspace && !service().quiesceInfo().quiesced;
+                    const state = await nativeSkills(cwd, agentDir, change, valid);
+                    if (!valid())
+                        throw Error("Workspace changed");
+                    res.json(state);
+                }
+                finally {
+                    readers--;
+                    if (change)
+                        mutation = undefined;
+                }
+                return;
+            }
+            if (action === "preferences") {
+                if (typeof req.body.enabled !== "boolean")
+                    throw Error("Invalid preference");
+                const path = join(agentDir, "webui-extensions.json"), previous = readJson(path);
+                mkdirSync(agentDir, { recursive: true });
+                writeFileSync(`${path}.tmp`, JSON.stringify({ ...previous, autoCheck: req.body.enabled }), { mode: 0o600 });
+                renameSync(`${path}.tmp`, path);
+                res.json({ autoCheck: req.body.enabled });
+                return;
+            }
+            if (action === "search") {
+                res.json(await browseCatalog(String(req.body.query ?? ""), String(req.body.type ?? ""), String(req.body.sort ?? ""), Number(req.body.page) || 1));
+                return;
+            }
+            if (action === "details") {
+                res.json(await previewSource(validateSource(req.body.source, cwd)));
+                return;
+            }
+            if (action === "preview") {
+                const preview = { ...await previewSource(validateSource(req.body.source, cwd)), ticket: randomUUID() };
+                if (tickets.size >= 64)
+                    tickets.delete(tickets.keys().next().value);
+                tickets.set(preview.ticket, { cwd, clientId, until: Date.now() + 1200000, preview });
+                res.json(preview);
+                return;
+            }
+            if (action === "job") {
+                const job = jobs.get(req.body.id);
+                if (!job || job.clientId !== clientId || job.cwd !== cwd)
+                    throw Error("Operation not found");
+                res.json(job);
+                return;
+            }
+            if (action === "start") {
+                if (mutation)
+                    throw Error("Package manager is busy; retry shortly");
+                const op = req.body.operation;
+                if (!op || !["install", "remove", "toggle", "update", "update-all", "unpin", "move"].includes(op.action) || op.scope && !["user", "project"].includes(op.scope) || op.action === "toggle" && typeof op.enabled !== "boolean")
+                    throw Error("Invalid operation");
+                let source;
+                if (op.action === "install") {
+                    const ticket = tickets.get(op.ticket ?? "");
+                    if (!ticket || ticket.cwd !== cwd || ticket.clientId !== clientId || ticket.until < Date.now())
+                        throw Error("Install preview expired; review the source again");
+                    source = ticket.preview.source;
+                    if (op.pin && ticket.preview.canPin)
+                        source = `${sourceInfo(source).unpinned}@${ticket.preview.version}`;
+                    tickets.delete(op.ticket);
+                }
+                const id = randomUUID(), job = { id, phase: "running", log: "", cwd, clientId };
+                if (jobs.size >= 32)
+                    jobs.delete(jobs.keys().next().value);
+                jobs.set(id, job);
+                mutation = id;
+                void runWorker({ cwd, agentDir, action: "mutate", operation: op, source, version: req.body.version }, line => { job.log = (job.log + line + "\n").slice(-128000); }).then(() => { states.delete(cwd); job.phase = "done"; }, error => { job.phase = "error"; job.error = error.message; job.log += `\n${error.message}`; }).finally(() => { mutation = undefined; });
+                res.json(job);
+                return;
+            }
+            if (action !== "list" && action !== "check" && !["open-info", "file", "save-file", "notes"].includes(action))
+                throw Error("Unknown action");
+            if (mutation)
+                throw Error("Package operation running");
+            if (readers >= 4)
+                throw Error("Package manager busy");
+            readers++;
+            try {
+                const cached = states.get(cwd);
+                const state = await runWorker({ cwd, agentDir, action: action === "check" ? "check" : "list" });
+                if (cs.cwd !== cwd || cs.switchingWorkspace)
+                    throw Error("Workspace changed");
+                if (["file", "save-file", "notes"].includes(action)) {
+                    const item = state.packages.find(p => p.id === req.body.id);
+                    if (!item)
+                        throw Error("Package unavailable");
+                    if (action === "notes") {
+                        res.json(item.kind === "npm" ? await packageReleaseNotes(sourceInfo(item.source).name) : { title: item.version ?? "", notes: [] });
+                        return;
+                    }
+                    if (item.kind !== "file" || !item.trusted || !item.path || !/\.[cm]?[jt]s$/.test(item.path))
+                        throw Error("Only trusted standalone extension files can be edited here");
+                    const path = realpathSync(item.path), info = statSync(path);
+                    if (!info.isFile() || info.size > 512 * 1024)
+                        throw Error("Extension file exceeds editor limit (512 KB)");
+                    const raw = readFileSync(path), version = createHash("sha256").update(raw).digest("hex");
+                    if (action === "save-file") {
+                        if (mutation)
+                            throw Error("Package operation running");
+                        if (version !== req.body.version)
+                            throw Error("File changed externally; reopen before saving");
+                        if (typeof req.body.content !== "string" || Buffer.byteLength(req.body.content) > 512 * 1024)
+                            throw Error("Invalid extension content");
+                        const temp = `${path}.${randomUUID()}.tmp`;
+                        writeFileSync(temp, req.body.content, { mode: info.mode });
+                        renameSync(temp, path);
+                        res.json({ saved: true });
+                    }
+                    else
+                        res.json({ content: new TextDecoder("utf-8", { fatal: true }).decode(raw), version });
+                    return;
+                }
+                if (action === "open-info") {
+                    const item = state.packages.find(p => p.id === req.body.id);
+                    if (!item?.path)
+                        throw Error("Installed path unavailable");
+                    res.json({ absolute: item.path });
+                    return;
+                }
+                if (action === "check") {
+                    if (states.size > 32)
+                        states.delete(states.keys().next().value);
+                    states.set(cwd, state);
+                }
+                else if (cached?.version === state.version) {
+                    state.checkedAt = cached.checkedAt;
+                    for (const item of state.packages) {
+                        const old = cached.packages.find(p => p.id === item.id);
+                        if (old?.version === item.version)
+                            Object.assign(item, { update: old?.update, latest: old?.latest, checkError: old?.checkError });
+                    }
+                }
+                state.autoCheck = autoCheckEnabled(agentDir);
+                if (background.size > 32)
+                    background.delete(background.keys().next().value);
+                background.set(cwd, { agentDir, next: Math.max(Date.now() + 60000, (state.checkedAt ?? 0) + 6 * 60 * 60 * 1000) });
+                res.json(state);
+            }
+            finally {
+                readers--;
+            }
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+}

package/dist/server/extensions-worker.js

@@ -0,0 +1,188 @@
+import { DefaultPackageManager, SettingsManager, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+import { writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+import { readJson, textField, resourceTypes, sourceOf, sourceInfo, packageDisabled, settingsVersion } from "./extensions-model.js";
+import { extensionDisplay } from "./extension-display.js";
+import { gitOutput, latestNpmVersion } from "./component-updates.js";
+const blankResources = () => ({ extensions: [], skills: [], prompts: [], themes: [] });
+export async function extensionWork(input, progress = () => { }) {
+    const { cwd, agentDir } = input;
+    const trusted = new ProjectTrustStore(agentDir).get(cwd) === true;
+    const settings = SettingsManager.create(cwd, agentDir, { projectTrusted: trusted });
+    const errors = settings.drainErrors();
+    if (errors.length)
+        throw Error(errors.map(e => e.error.message).join("\n"));
+    const manager = new DefaultPackageManager({ cwd, agentDir, settingsManager: settings });
+    manager.setProgressCallback(event => progress(`${event.type}: ${event.message ?? event.source}`));
+    const config = (scope) => scope === "user" ? settings.getGlobalSettings() : settings.getProjectSettings();
+    const packages = (scope) => config(scope).packages ?? [];
+    const setPackages = (scope, entries) => scope === "user" ? settings.setPackages(entries) : settings.setProjectPackages(entries);
+    const flush = async () => { await settings.flush(); const errors = settings.drainErrors(); if (errors.length)
+        throw Error(errors.map(e => e.error.message).join("\n")); };
+    const scopedManager = (scope, entries) => {
+        const isolated = SettingsManager.inMemory({ ...settings.getSettings(), packages: [] }, { projectTrusted: true });
+        if (scope === "project")
+            isolated.setProjectPackages(entries);
+        else
+            isolated.setPackages(entries);
+        return new DefaultPackageManager({ cwd, agentDir, settingsManager: isolated });
+    };
+    const checkUpdates = async () => (await Promise.all(["user", "project"].filter(scope => scope === "user" || trusted).map(scope => scopedManager(scope, packages(scope)).checkForAvailableUpdates()))).flat();
+    const backupPath = join(agentDir, "webui-extension-filters.json");
+    const backup = readJson(backupPath);
+    const backupKey = (id) => createHash("sha256").update(`${id.startsWith("user:") ? "global" : cwd}:${id}`).digest("hex");
+    const saveBackup = () => { mkdirSync(agentDir, { recursive: true }); writeFileSync(`${backupPath}.tmp`, JSON.stringify(backup), { mode: 0o600 }); renameSync(`${backupPath}.tmp`, backupPath); };
+    async function list() {
+        const resources = await manager.resolve(async () => "skip");
+        const result = [];
+        const projectDeclarations = readJson(join(cwd, ".pi/settings.json")).packages ?? [];
+        for (const scope of ["user", "project"]) {
+            const declarations = scope === "project" && !trusted ? projectDeclarations : packages(scope);
+            for (const entry of declarations) {
+                const source = sourceOf(entry), info = sourceInfo(source), path = scope === "project" && !trusted ? undefined : manager.getInstalledPath(source, scope);
+                let metadata = {};
+                if (path)
+                    try {
+                        metadata = readJson(join(path, "package.json"));
+                    }
+                    catch { }
+                const counts = blankResources();
+                for (const type of resourceTypes)
+                    counts[type] = resources[type].filter(r => r.metadata.source === source && r.metadata.scope === scope).map(r => relative(path ?? cwd, r.path));
+                result.push({ id: `${scope}:${source}`, source, scope, kind: info.kind, name: textField(metadata.name) ?? info.name, path, version: textField(metadata.version), description: textField(metadata.description), enabled: !packageDisabled(entry), pinned: info.pinned, trusted: scope === "user" || trusted, resources: counts, protected: ["@youweichen/pi-harness", "pi-harness", "@earendil-works/pi-coding-agent"].includes(info.name) });
+            }
+        }
+        for (const resource of resources.extensions) {
+            if (resource.metadata.origin !== "top-level" || resource.path.startsWith("builtin:") || resource.metadata.scope === "temporary")
+                continue;
+            result.push({ id: `file:${resource.metadata.scope}:${resource.path}`, source: resource.path, ...extensionDisplay(resource.path), scope: resource.metadata.scope, kind: "file", path: resource.path, enabled: resource.enabled, pinned: false, trusted: resource.metadata.scope === "user" || trusted, resources: blankResources() });
+        }
+        return { packages: result, version: settingsVersion(cwd, agentDir), trusted };
+    }
+    if (input.action === "mutate") {
+        if (input.version !== settingsVersion(cwd, agentDir))
+            throw Error("Pi settings changed; refresh before applying changes");
+        const op = input.operation;
+        const state = await list(), target = state.packages.find(p => p.id === op.id);
+        if (!["install", "update-all"].includes(op.action) && !target)
+            throw Error("Package no longer configured");
+        if (target?.kind === "file" && op.action !== "toggle")
+            throw Error("Standalone files only support toggling and editing");
+        if (target?.protected)
+            throw Error("This package must be managed with the application");
+        if (target && !target.trusted || op.scope === "project" && !trusted)
+            throw Error("Project is not trusted; review it in MCP settings or Pi first");
+        if (input.version !== settingsVersion(cwd, agentDir))
+            throw Error("Pi settings changed; refresh before applying changes");
+        const scope = target?.scope ?? op.scope ?? "user", local = scope === "project";
+        const source = target?.source ?? input.source;
+        const entries = packages(scope), index = entries.findIndex(p => sourceOf(p) === source);
+        if (op.action === "install") {
+            if (!input.source)
+                throw Error("Install preview expired");
+            if (["@youweichen/pi-harness", "pi-harness", "@earendil-works/pi-coding-agent"].includes(sourceInfo(input.source).name))
+                throw Error("Manage this package with the application updater");
+            await manager.install(input.source, { local });
+            if (input.version !== settingsVersion(cwd, agentDir))
+                throw Error("Pi settings changed during install; files were installed but configuration was not overwritten");
+            manager.addSourceToSettings(input.source, { local });
+        }
+        else if (op.action === "remove") {
+            await manager.remove(source, { local });
+            await settings.reload();
+            manager.removeSourceFromSettings(source, { local });
+            delete backup[backupKey(target.id)];
+            saveBackup();
+        }
+        else if (op.action === "toggle" && target?.kind === "file") {
+            const paths = [...(config(scope).extensions ?? [])].filter(p => p !== `-${source}` && p !== `+${source}`);
+            paths.push(`${op.enabled ? "+" : "-"}${source}`);
+            if (local)
+                settings.setProjectExtensionPaths(paths);
+            else
+                settings.setExtensionPaths(paths);
+        }
+        else if (op.action === "toggle") {
+            const key = backupKey(target.id);
+            if (!op.enabled && !packageDisabled(entries[index])) {
+                backup[key] = entries[index];
+                saveBackup();
+                entries[index] = { ...(typeof entries[index] === "object" ? entries[index] : { source }), autoload: true, extensions: [], skills: [], prompts: [], themes: [] };
+            }
+            if (op.enabled && packageDisabled(entries[index]))
+                entries[index] = backup[key] ?? { source };
+            setPackages(scope, entries);
+        }
+        else if (op.action === "unpin") {
+            const unpinned = sourceInfo(source).unpinned;
+            entries[index] = typeof entries[index] === "string" ? unpinned : { ...entries[index], source: unpinned };
+            const saved = backup[backupKey(target.id)];
+            if (saved) {
+                backup[backupKey(`${scope}:${unpinned}`)] = typeof saved === "string" ? unpinned : { ...saved, source: unpinned };
+                saveBackup();
+            }
+            setPackages(scope, entries);
+        }
+        else if (op.action === "move") {
+            const destination = scope === "user" ? "project" : "user";
+            if (!trusted)
+                throw Error("Project is not trusted");
+            if (packages(destination).some(p => sourceInfo(sourceOf(p)).unpinned === sourceInfo(source).unpinned))
+                throw Error("Package already declared in destination scope");
+            const movedSource = target.kind === "local" ? target.path ?? source : source;
+            await manager.install(movedSource, { local: destination === "project" });
+            if (input.version !== settingsVersion(cwd, agentDir))
+                throw Error("Pi settings changed during move; destination files installed but configuration retained");
+            const old = entries[index], moved = typeof old === "string" ? movedSource : { ...old, source: movedSource };
+            setPackages(destination, [...packages(destination), moved]);
+            await flush();
+            setPackages(scope, entries.filter((_, i) => i !== index));
+            const oldBackup = backup[backupKey(target.id)];
+            if (oldBackup) {
+                backup[backupKey(`${destination}:${movedSource}`)] = typeof oldBackup === "string" ? movedSource : { ...oldBackup, source: movedSource };
+                saveBackup();
+            }
+        }
+        else if (op.action === "update" || op.action === "update-all") {
+            const updates = await checkUpdates();
+            const eligible = state.packages.filter(p => !p.protected && p.trusted && !p.pinned && updates.some(u => u.source === p.source && u.scope === p.scope) && (op.action === "update-all" || p.id === target.id));
+            if (!eligible.length)
+                throw Error("No updates available");
+            for (const [i, p] of eligible.entries()) {
+                if (p.kind === "git" && p.path && await gitOutput(p.path, ["status", "--porcelain"]))
+                    throw Error(`Local changes in ${p.name}; commit or save them before updating`);
+                progress(`${i + 1}/${eligible.length} ${p.name}`);
+                // A scope-isolated native manager prevents update(source) from also updating another declaration.
+                const updater = scopedManager(p.scope, [p.source]);
+                updater.setProgressCallback(event => progress(`${event.type}: ${event.message ?? event.source}`));
+                await updater.update(p.source);
+            }
+        }
+        else
+            throw Error("Unsupported operation");
+        await flush();
+    }
+    const state = await list();
+    if (input.action === "check") {
+        const updates = await checkUpdates();
+        for (const item of state.packages) {
+            item.update = !item.protected && updates.some(u => u.scope === item.scope && u.source === item.source);
+            if (item.update && item.kind === "npm" && !sourceInfo(item.source).ref)
+                try {
+                    item.latest = await latestNpmVersion(sourceInfo(item.source).name);
+                }
+                catch (e) {
+                    item.checkError = String(e);
+                }
+            if (item.update && item.kind === "git")
+                item.latest = "HEAD";
+        }
+        state.checkedAt = Date.now();
+    }
+    return state;
+}
+if (process.send && process.argv.includes("--extensions-worker"))
+    process.once("message", (input) => {
+        void extensionWork(input, message => process.send?.({ progress: message })).then(state => process.send?.({ state }, () => process.disconnect()), error => process.send?.({ error: error instanceof Error ? error.message : String(error) }, () => process.disconnect()));
+    });