pipane 0.1.5 → 0.1.7

package/dist/server/server/update-check.js

@@ -1,24 +1,44 @@
-/**
- * Check the npm registry for the latest version of a package.
- * Returns null if the check fails (network error, timeout, etc.)
- */
-export async function fetchLatestVersion(packageName, timeoutMs = 3000) {
+async function fetchJson(url, timeoutMs, headers) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+        const response = await fetch(url, {
             signal: controller.signal,
-            headers: { Accept: "application/json" },
+            headers,
         });
-        clearTimeout(timer);
-        if (!res.ok)
+        if (!response.ok)
             return null;
-        const data = (await res.json());
-        return data.version ?? null;
+        return await response.json();
     }
     catch {
         return null;
     }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Check the npm registry for the latest version of a package. */
+export async function fetchLatestVersion(packageName, timeoutMs = 3000) {
+    const data = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, timeoutMs, { Accept: "application/json" });
+    return typeof data?.version === "string" && data.version.trim() ? data.version.trim() : null;
+}
+/** Check Pi's release endpoint, including package migration metadata. */
+export async function fetchLatestPiRelease(currentVersion, timeoutMs = 3000) {
+    const data = await fetchJson("https://pi.dev/api/latest-version", timeoutMs, {
+        Accept: "application/json",
+        "User-Agent": `pipane/${currentVersion}`,
+    });
+    if (typeof data?.version !== "string" || !data.version.trim())
+        return null;
+    return {
+        version: data.version.trim(),
+        ...(typeof data.packageName === "string" && data.packageName.trim()
+            ? { packageName: data.packageName.trim() }
+            : {}),
+        ...(typeof data.note === "string" && data.note.trim()
+            ? { note: data.note.trim() }
+            : {}),
+    };
 }
 /**
  * Compare two semver strings. Returns:

package/dist/server/server/update-manager.js

@@ -0,0 +1,231 @@
+import { spawn } from "node:child_process";
+import { DefaultPackageManager, SettingsManager, getAgentDir, } from "@earendil-works/pi-coding-agent";
+import { compareSemver, fetchLatestPiRelease, fetchLatestVersion, } from "./update-check.js";
+const UPDATE_COMMAND_TIMEOUT_MS = 10 * 60_000;
+const MAX_COMMAND_OUTPUT = 16 * 1024;
+const NO_UPDATE_MESSAGES = {
+    pipane: "pipane is already up to date.",
+    pi: "Pi is already up to date.",
+    extensions: "Pi packages are already up to date.",
+};
+function appendBounded(current, chunk) {
+    const next = current + chunk.toString();
+    return next.length > MAX_COMMAND_OUTPUT ? next.slice(-MAX_COMMAND_OUTPUT) : next;
+}
+export function runUpdateCommand(command, args, cwd, timeoutMs = UPDATE_COMMAND_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => { stdout = appendBounded(stdout, chunk); });
+        child.stderr?.on("data", (chunk) => { stderr = appendBounded(stderr, chunk); });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new Error(`Failed to start ${command}: ${error.message}`));
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`Update command timed out after ${Math.round(timeoutMs / 1000)} seconds.`));
+                return;
+            }
+            if (code !== 0) {
+                const detail = (stderr || stdout).trim();
+                const suffix = detail ? `: ${detail}` : signal ? ` (signal ${signal})` : "";
+                reject(new Error(`Update command failed with exit code ${code ?? "unknown"}${suffix}`));
+                return;
+            }
+            resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+        });
+    });
+}
+async function getInstalledPiVersion(launch, cwd) {
+    try {
+        const result = await runUpdateCommand(launch.command, [...launch.baseArgs, "--version"], cwd, 10_000);
+        const match = `${result.stdout}\n${result.stderr}`.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/);
+        return match?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function checkManagedExtensionUpdates(cwd) {
+    if (process.env.PI_OFFLINE)
+        return [];
+    const agentDir = getAgentDir();
+    // RPC mode does not prompt for project trust. Check the user-level package set,
+    // which is shared by every Pi worker, without loading untrusted project config.
+    const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const updates = await packageManager.checkForAvailableUpdates();
+    return updates.map((update) => update.displayName);
+}
+function cloneSnapshot(snapshot) {
+    return {
+        checkedAt: snapshot.checkedAt,
+        notices: snapshot.notices.map((notice) => ({
+            ...notice,
+            ...(notice.packages ? { packages: [...notice.packages] } : {}),
+        })),
+    };
+}
+export class UpdateManager {
+    options;
+    dependencies;
+    snapshot = { checkedAt: new Date(0).toISOString(), notices: [] };
+    checkPromise;
+    activeUpdate;
+    constructor(options) {
+        this.options = options;
+        this.dependencies = {
+            fetchLatestVersion,
+            fetchLatestPiRelease,
+            getPiVersion: getInstalledPiVersion,
+            checkExtensionUpdates: checkManagedExtensionUpdates,
+            runCommand: runUpdateCommand,
+            ...options.dependencies,
+        };
+    }
+    get currentSnapshot() {
+        return cloneSnapshot(this.snapshot);
+    }
+    check() {
+        if (!this.checkPromise) {
+            this.checkPromise = this.performCheck();
+        }
+        return this.checkPromise.then(cloneSnapshot);
+    }
+    async performCheck() {
+        if (this.options.skipChecks || process.env.PIPANE_SKIP_UPDATE_CHECK || process.env.PI_OFFLINE) {
+            this.snapshot = { checkedAt: new Date().toISOString(), notices: [] };
+            return this.snapshot;
+        }
+        const pipaneCheck = this.checkPipaneUpdate();
+        const piCheck = process.env.PI_SKIP_VERSION_CHECK
+            ? Promise.resolve(null)
+            : this.checkPiUpdate();
+        const extensionCheck = this.checkExtensionUpdate();
+        const notices = (await Promise.all([pipaneCheck, piCheck, extensionCheck]))
+            .filter((notice) => notice !== null);
+        this.snapshot = { checkedAt: new Date().toISOString(), notices };
+        return this.snapshot;
+    }
+    async checkPipaneUpdate() {
+        try {
+            const latestVersion = await this.dependencies.fetchLatestVersion(this.options.pipanePackageName);
+            if (!latestVersion || compareSemver(this.options.pipaneVersion, latestVersion) >= 0)
+                return null;
+            return {
+                target: "pipane",
+                currentVersion: this.options.pipaneVersion,
+                latestVersion,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async checkPiUpdate() {
+        try {
+            const currentVersion = await this.dependencies.getPiVersion(this.options.piLaunch, this.options.cwd);
+            if (!currentVersion)
+                return null;
+            const release = await this.dependencies.fetchLatestPiRelease(currentVersion);
+            if (!release || compareSemver(currentVersion, release.version) >= 0)
+                return null;
+            return {
+                target: "pi",
+                currentVersion,
+                latestVersion: release.version,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async checkExtensionUpdate() {
+        try {
+            const packages = [...new Set(await this.dependencies.checkExtensionUpdates(this.options.cwd))]
+                .sort((left, right) => left.localeCompare(right));
+            return packages.length > 0 ? { target: "extensions", packages } : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async run(target) {
+        await this.check();
+        if (this.activeUpdate) {
+            throw new Error(`An update is already running for ${this.activeUpdate}.`);
+        }
+        const notice = this.snapshot.notices.find((candidate) => candidate.target === target);
+        if (!notice) {
+            return {
+                target,
+                message: NO_UPDATE_MESSAGES[target],
+                restartRequired: false,
+            };
+        }
+        this.activeUpdate = target;
+        try {
+            const result = await this.performUpdate(notice);
+            this.snapshot = {
+                checkedAt: new Date().toISOString(),
+                notices: this.snapshot.notices.filter((candidate) => candidate.target !== target),
+            };
+            return result;
+        }
+        finally {
+            this.activeUpdate = undefined;
+        }
+    }
+    async performUpdate(notice) {
+        switch (notice.target) {
+            case "pipane": {
+                if (!notice.latestVersion)
+                    throw new Error("The pipane update has no target version.");
+                await this.dependencies.runCommand("npm", ["install", "-g", "--ignore-scripts", `${this.options.pipanePackageName}@${notice.latestVersion}`], this.options.cwd);
+                return {
+                    target: "pipane",
+                    message: `pipane v${notice.latestVersion} installed. Restart pipane to use the new version.`,
+                    restartRequired: true,
+                };
+            }
+            case "pi": {
+                await this.dependencies.runCommand(this.options.piLaunch.command, [...this.options.piLaunch.baseArgs, "update", "--self"], this.options.cwd);
+                await this.options.onPiRuntimeChanged?.();
+                return {
+                    target: "pi",
+                    message: `Pi${notice.latestVersion ? ` v${notice.latestVersion}` : ""} installed. Pi workers are restarting.`,
+                    restartRequired: false,
+                };
+            }
+            case "extensions": {
+                await this.dependencies.runCommand(this.options.piLaunch.command, [...this.options.piLaunch.baseArgs, "update", "--extensions"], this.options.cwd);
+                await this.options.onPiRuntimeChanged?.();
+                const count = notice.packages?.length ?? 0;
+                return {
+                    target: "extensions",
+                    message: `${count} Pi package${count === 1 ? "" : "s"} updated. Pi workers are restarting.`,
+                    restartRequired: false,
+                };
+            }
+        }
+    }
+}

package/dist/server/server/worktree-name.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+/**
+ * Filesystem-only Git checkout lookup. One instance is shared across all
+ * sessions in a single listing, then discarded so worktree changes are visible
+ * on the next request.
+ */
+class GitCheckoutLookup {
+    cache = new Map();
+    resolve(location) {
+        if (!location)
+            return null;
+        let dir = path.resolve(location);
+        const visited = [];
+        while (true) {
+            if (this.cache.has(dir)) {
+                return this.remember(visited, this.cache.get(dir) ?? null);
+            }
+            visited.push(dir);
+            const gitPath = path.join(dir, ".git");
+            if (existsSync(gitPath)) {
+                return this.remember(visited, this.readCheckout(dir, gitPath));
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return this.remember(visited, null);
+            dir = parent;
+        }
+    }
+    readCheckout(root, gitPath) {
+        try {
+            const stat = statSync(gitPath);
+            if (stat.isDirectory()) {
+                return {
+                    root,
+                    commonGitDir: canonicalPath(gitPath),
+                    linked: false,
+                };
+            }
+            if (!stat.isFile())
+                return null;
+            const marker = readFileSync(gitPath, "utf8").trim();
+            if (!marker.startsWith("gitdir: "))
+                return null;
+            const gitDir = path.resolve(root, marker.slice("gitdir: ".length).trim());
+            if (!existsSync(gitDir))
+                return null;
+            const commonDirMarker = path.join(gitDir, "commondir");
+            if (!existsSync(commonDirMarker)) {
+                // A separate Git directory or submodule checkout uses a .git file too,
+                // but unlike a linked worktree it has no commondir pointer.
+                return {
+                    root,
+                    commonGitDir: canonicalPath(gitDir),
+                    linked: false,
+                };
+            }
+            const commonDir = path.resolve(gitDir, readFileSync(commonDirMarker, "utf8").trim());
+            if (!existsSync(commonDir))
+                return null;
+            return {
+                root,
+                commonGitDir: canonicalPath(commonDir),
+                linked: true,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    remember(visited, checkout) {
+        for (const location of visited)
+            this.cache.set(location, checkout);
+        return checkout;
+    }
+}
+function canonicalPath(value) {
+    try {
+        return realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
+    }
+}
+function checkoutName(checkout) {
+    return checkout?.linked ? path.basename(checkout.root) || "root" : "root";
+}
+/**
+ * Create a resolver with a request-scoped filesystem cache. This avoids Git
+ * subprocesses and ensures shared cwd/path ancestors are only inspected once
+ * while listing many sessions.
+ */
+export function createWorktreeNameResolver() {
+    const lookup = new GitCheckoutLookup();
+    return (cwd, recentToolPaths = []) => {
+        const cwdCheckout = lookup.resolve(cwd);
+        // Tool paths are stored oldest-to-newest. The newest successful project
+        // file operation is stronger evidence than Pi's immutable session cwd.
+        for (let i = recentToolPaths.length - 1; i >= 0; i--) {
+            const activityCheckout = lookup.resolve(recentToolPaths[i]);
+            if (!activityCheckout)
+                continue;
+            if (!cwdCheckout || activityCheckout.commonGitDir === cwdCheckout.commonGitDir) {
+                return checkoutName(activityCheckout);
+            }
+        }
+        // The session cwd says where Pi was launched, not which checkout the
+        // conversation is actively using. Until successful same-repository file
+        // activity provides evidence, treat the session as root.
+        return "root";
+    };
+}
+/**
+ * Return a short label for the Git checkout a session is actively using.
+ *
+ * Pi cannot change its process cwd persistently, so the recorded cwd only
+ * identifies the repository. Recent successful read/write/edit paths identify
+ * its active checkout; without one, the label defaults to root. Linked
+ * worktrees are recognized by their commondir pointer. Removed worktrees
+ * naturally stop matching because their .git metadata is no longer present.
+ */
+export function resolveWorktreeName(cwd, recentToolPaths = []) {
+    return createWorktreeNameResolver()(cwd, recentToolPaths);
+}