npm - pipane - Versions diffs - 0.1.4 → 0.1.6 - Mend

pipane 0.1.4 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (99) hide show

package/dist/client/index.html CHANGED Viewed

@@ -17,8 +17,8 @@
 				if (colorTheme && colorTheme !== "default") root.setAttribute("data-color-theme", colorTheme);
 			})();
 		</script>
-		<script type="module" crossorigin src="/assets/index-Cp2vV6HJ.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-CUE9pgq9.css">
+		<script type="module" crossorigin src="/assets/index-hNqbnG06.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-Dl_wdLZH.css">
 	</head>
 	<body>
 		<div id="app">

package/dist/server/server/bundled-extensions.js ADDED Viewed

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+/** Absolute entrypoint for the bundled common-subscription usage extension. */
+export function resolveUsageExtensionPath() {
+    return require.resolve("@sreetej510/pi-usage/dist/index.js");
+}

package/dist/server/server/extension-status.js ADDED Viewed

@@ -0,0 +1,31 @@
+import { stripVTControlCharacters } from "node:util";
+export const PROVIDER_USAGE_STATUS_KEY = "provider-usage";
+const MAX_STATUS_KEY_LENGTH = 128;
+const MAX_STATUS_TEXT_LENGTH = 512;
+const KEY_CONTROL_CHARACTER = /[\u0000-\u001f\u007f-\u009f]/;
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+export function isValidExtensionStatusKey(value) {
+    return typeof value === "string"
+        && value.length > 0
+        && value.length <= MAX_STATUS_KEY_LENGTH
+        && !KEY_CONTROL_CHARACTER.test(value);
+}
+export function normalizeExtensionStatusText(value) {
+    return stripVTControlCharacters(value)
+        .replace(/[\r\n\t]+/g, " ")
+        .replace(CONTROL_CHARACTERS, "")
+        .replace(/\s{2,}/g, " ")
+        .trim()
+        .slice(0, MAX_STATUS_TEXT_LENGTH);
+}
+export function extensionStatusSnapshot(statuses) {
+    return Object.fromEntries(statuses ?? []);
+}
+/** Identify successful pi-usage status text; transient states such as "checking" do not match. */
+export function providerForUsageStatus(text) {
+    if (/^codex(?:\s|$)/i.test(text))
+        return "codex";
+    if (/^(?:anthropic|claude)(?:\s|$)/i.test(text))
+        return "anthropic";
+    return undefined;
+}

package/dist/server/server/local-settings.js CHANGED Viewed

@@ -343,6 +343,20 @@ function validateSettingsObject(value, errors) {
             toolCollapse = { keepOpen: tc.keepOpen };
         }
     }
+    // Validate messages (optional)
+    let messagesConfig;
+    if (value.messages !== undefined) {
+        const mc = value.messages;
+        if (!mc || typeof mc !== "object" || Array.isArray(mc)) {
+            errors.push("messages must be an object");
+        }
+        else if (typeof mc.initialCount !== "number" || !Number.isFinite(mc.initialCount) || mc.initialCount < 0 || Math.floor(mc.initialCount) !== mc.initialCount) {
+            errors.push("messages.initialCount must be a non-negative integer");
+        }
+        else {
+            messagesConfig = { initialCount: mc.initialCount };
+        }
+    }
     if (errors.length > 0)
         return null;
     return {
@@ -362,6 +376,7 @@ function validateSettingsObject(value, errors) {
             showTokenUsage,
         },
         ...(toolCollapse ? { toolCollapse } : {}),
+        ...(messagesConfig ? { messages: messagesConfig } : {}),
     };
 }
 function compileFilters(settings) {

package/dist/server/server/pi-runtime.js CHANGED Viewed

@@ -24,7 +24,7 @@ export function makePiNotFoundMessage(command) {
 }
 export async function installPiGlobal(deps = {}) {
     const spawnSync = deps.spawnSync ?? childSpawnSync;
-    const result = spawnSync("npm", ["install", "-g", "@mariozechner/pi-coding-agent"], {
+    const result = spawnSync("npm", ["install", "-g", "@earendil-works/pi-coding-agent"], {
         stdio: "inherit",
         env: process.env,
     });

package/dist/server/server/process-pool.js CHANGED Viewed

@@ -1,29 +1,43 @@
 /**
- * CWD-aware process pool for pi RPC processes.
+ * CWD-aware, leased process pool for pi RPC processes.
  *
- * Processes are grouped by cwd. When acquiring a process for a session,
- * the caller provides the session's cwd and gets a process that was
- * spawned in that directory. This ensures bash/read/edit/write tools
- * operate in the correct project directory.
- *
- * Features:
- * - Lazy spawning per-cwd with configurable pre-warming
- * - Readiness check via get_state RPC (replaces setTimeout(500) hack)
- * - Dead process cleanup on exit
- * - Global process cap
+ * The pool is the sole owner of process availability. Callers receive an
+ * idempotent lease instead of passing a separate busy set, so a process is
+ * reserved atomically before control returns to asynchronous application code.
  */
 import { spawn } from "node:child_process";
 import * as readline from "node:readline";
 import { existsSync } from "node:fs";
+/** Exclusive ownership of one pooled process. */
+export class RpcProcessLease {
+    process;
+    pool;
+    _released = false;
+    constructor(pool, process) {
+        this.pool = pool;
+        this.process = process;
+    }
+    get released() { return this._released; }
+    release() {
+        this.pool.releaseLease(this);
+    }
+    /** @internal */
+    markReleased() {
+        this._released = true;
+    }
+}
 export class ProcessPool {
-    /** All live processes, keyed by cwd */
     pools = new Map();
+    leases = new Map();
+    decommissioning = new Set();
+    finalizedProcesses = new WeakSet();
     nextProcId = 0;
     spawnConfig;
     maxProcesses;
     prewarmCount;
     rpcTimeout;
     onProcessExit;
+    eventListeners = new Set();
     constructor(spawnConfig, options) {
         this.spawnConfig = spawnConfig;
         this.maxProcesses = options?.maxProcesses ?? 6;
@@ -31,34 +45,50 @@ export class ProcessPool {
         this.rpcTimeout = options?.rpcTimeout ?? 30000;
         this.onProcessExit = options?.onProcessExit;
     }
-    /** Get the total count of live processes across all cwds */
     get totalProcesses() {
         let count = 0;
         for (const procs of this.pools.values()) {
-            count += procs.filter((p) => p.process.exitCode === null).length;
+            count += procs.filter((proc) => proc.process.exitCode === null).length;
         }
         return count;
     }
-    /** Get all processes (for debug endpoint) */
+    subscribeEvents(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    emitEvent(proc, event) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(proc, event);
+            }
+            catch (err) {
+                console.error(`[pool] pi#${proc.id} event listener failed:`, err);
+            }
+        }
+    }
     getAllProcesses() {
         const all = [];
-        for (const procs of this.pools.values()) {
+        for (const procs of this.pools.values())
             all.push(...procs);
-        }
         return all;
     }
-    /**
-     * Spawn a new RPC process for the given cwd.
-     * Does not wait for readiness — call waitForReady() separately.
-     */
+    isLeased(proc) {
+        return this.leases.has(proc);
+    }
+    isDecommissioning(proc) {
+        return this.decommissioning.has(proc);
+    }
+    getRecentStderr(proc, maxLines = 12) {
+        if (!proc?.recentStderr?.length)
+            return [];
+        return proc.recentStderr.slice(Math.max(0, proc.recentStderr.length - maxLines));
+    }
     spawn(cwd) {
         if (!existsSync(cwd)) {
             throw new Error(`Cannot spawn pi process: directory does not exist: ${cwd}`);
         }
         const procId = ++this.nextProcId;
         console.log(`[pool] Spawning pi process #${procId} (cwd: ${cwd})...`);
-        // Strip NODE_ENV from the child environment so tools spawned by pi
-        // (e.g. bash) don't inherit pipane's "production" setting.
         const { NODE_ENV: _, ...parentEnv } = process.env;
         const baseArgs = typeof this.spawnConfig.baseArgs === "function"
             ? this.spawnConfig.baseArgs()
@@ -71,8 +101,18 @@ export class ProcessPool {
             env: { ...parentEnv, ...(this.spawnConfig.env ?? {}) },
             stdio: ["pipe", "pipe", "pipe"],
         });
+        const recentStderr = [];
         child.stderr?.on("data", (data) => {
-            process.stderr.write(`[pi#${procId}] ${data.toString()}`);
+            const text = data.toString();
+            process.stderr.write(`[pi#${procId}] ${text}`);
+            for (const line of text.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                recentStderr.push(trimmed);
+                if (recentStderr.length > 60)
+                    recentStderr.splice(0, recentStderr.length - 60);
+            }
         });
         const rl = readline.createInterface({ input: child.stdout, terminal: false });
         const proc = {
@@ -83,8 +123,8 @@ export class ProcessPool {
             pendingRequests: new Map(),
             requestId: 0,
             lastResponseTime: Date.now(),
+            recentStderr,
         };
-        // Set up response handler
         rl.on("line", (line) => {
             let data;
             try {
@@ -93,51 +133,25 @@ export class ProcessPool {
             catch {
                 return;
             }
-            if (data.type === "response" && data.id && proc.pendingRequests.has(data.id)) {
-                const pending = proc.pendingRequests.get(data.id);
-                proc.pendingRequests.delete(data.id);
-                proc.lastResponseTime = Date.now();
-                pending.resolve(data);
+            if (data.type === "response") {
+                if (data.id && proc.pendingRequests.has(data.id)) {
+                    const pending = proc.pendingRequests.get(data.id);
+                    proc.pendingRequests.delete(data.id);
+                    proc.lastResponseTime = Date.now();
+                    pending.resolve(data);
+                }
+                return;
             }
+            this.emitEvent(proc, data);
         });
         child.on("error", (err) => {
             console.error(`[pool] pi#${proc.id} spawn error: ${err.message}`);
-            // Remove from pool
-            const poolForCwd = this.pools.get(cwd);
-            if (poolForCwd) {
-                const idx = poolForCwd.indexOf(proc);
-                if (idx !== -1)
-                    poolForCwd.splice(idx, 1);
-                if (poolForCwd.length === 0)
-                    this.pools.delete(cwd);
-            }
-            // Reject any pending requests
-            for (const [, pending] of proc.pendingRequests) {
-                pending.reject(new Error(`pi process #${proc.id} failed to spawn: ${err.message}`));
-            }
-            proc.pendingRequests.clear();
-            this.onProcessExit?.(proc);
+            this.finalizeProcess(proc, new Error(`pi process #${proc.id} failed to spawn: ${err.message}`));
         });
         child.on("exit", (code) => {
             console.log(`[pool] pi#${proc.id} exited (code ${code})`);
-            // Remove from pool
-            const poolForCwd = this.pools.get(cwd);
-            if (poolForCwd) {
-                const idx = poolForCwd.indexOf(proc);
-                if (idx !== -1)
-                    poolForCwd.splice(idx, 1);
-                if (poolForCwd.length === 0)
-                    this.pools.delete(cwd);
-            }
-            // Reject any pending requests
-            for (const [, pending] of proc.pendingRequests) {
-                pending.reject(new Error(`pi process #${proc.id} exited unexpectedly (code ${code})`));
-            }
-            proc.pendingRequests.clear();
-            // Notify caller
-            this.onProcessExit?.(proc);
+            this.finalizeProcess(proc, new Error(`pi process #${proc.id} exited unexpectedly (code ${code})`));
         });
-        // Add to pool
         let poolForCwd = this.pools.get(cwd);
         if (!poolForCwd) {
             poolForCwd = [];
@@ -147,10 +161,28 @@ export class ProcessPool {
         console.log(`[pool] pi#${procId} spawned (total: ${this.totalProcesses})`);
         return proc;
     }
-    /**
-     * Wait for a process to be ready by sending a get_state RPC.
-     * Falls back to a timeout if the process doesn't respond.
-     */
+    finalizeProcess(proc, error) {
+        if (this.finalizedProcesses.has(proc))
+            return;
+        this.finalizedProcesses.add(proc);
+        const poolForCwd = this.pools.get(proc.cwd);
+        if (poolForCwd) {
+            const index = poolForCwd.indexOf(proc);
+            if (index !== -1)
+                poolForCwd.splice(index, 1);
+            if (poolForCwd.length === 0)
+                this.pools.delete(proc.cwd);
+        }
+        const lease = this.leases.get(proc);
+        if (lease)
+            lease.markReleased();
+        this.leases.delete(proc);
+        this.decommissioning.delete(proc);
+        for (const pending of proc.pendingRequests.values())
+            pending.reject(error);
+        proc.pendingRequests.clear();
+        this.onProcessExit?.(proc);
+    }
     async waitForReady(proc, timeoutMs = 5000) {
         try {
             await this.sendRpc(proc, { type: "get_state" }, timeoutMs);
@@ -160,84 +192,109 @@ export class ProcessPool {
             return false;
         }
     }
-    /**
-     * Get an idle process for the given cwd, or spawn one.
-     * An "idle" process is one that's alive and not in the busySet.
-     */
-    acquire(cwd, busySet) {
+    /** Atomically reserve a matching process, spawning one when capacity allows. */
+    acquire(cwd) {
         const poolForCwd = this.pools.get(cwd);
-        if (poolForCwd) {
-            const idle = poolForCwd.find((p) => p.process.exitCode === null && !busySet.has(p));
-            if (idle)
-                return idle;
-        }
-        // Check global cap
-        if (this.totalProcesses >= this.maxProcesses) {
+        const idle = poolForCwd?.find((proc) => this.isAvailable(proc));
+        if (idle)
+            return this.reserve(idle);
+        if (this.totalProcesses >= this.maxProcesses)
             return null;
-        }
-        return this.spawn(cwd);
+        return this.reserve(this.spawn(cwd));
     }
-    /**
-     * Get any live process (idle preferred). For model queries that don't
-     * need a specific cwd.
-     */
-    getAny(busySet) {
-        // Prefer idle
+    /** Reserve any idle live process, regardless of cwd. */
+    acquireAny() {
         for (const procs of this.pools.values()) {
-            const idle = procs.find((p) => p.process.exitCode === null && !busySet.has(p));
+            const idle = procs.find((proc) => this.isAvailable(proc));
             if (idle)
-                return idle;
-        }
-        // Fall back to any live process
-        for (const procs of this.pools.values()) {
-            const live = procs.find((p) => p.process.exitCode === null);
-            if (live)
-                return live;
+                return this.reserve(idle);
         }
         return null;
     }
-    /**
-     * Evict one idle process from a different cwd to free capacity.
-     * Returns the evicted process, or null if none can be evicted.
-     */
-    evictIdleDifferentCwd(targetCwd, busySet) {
+    isAvailable(proc) {
+        return proc.process.exitCode === null
+            && !this.leases.has(proc)
+            && !this.decommissioning.has(proc);
+    }
+    reserve(proc) {
+        if (!this.isAvailable(proc))
+            throw new Error(`pi process #${proc.id} is not available`);
+        const lease = new RpcProcessLease(this, proc);
+        this.leases.set(proc, lease);
+        return lease;
+    }
+    /** @internal Called only by RpcProcessLease.release(). */
+    releaseLease(lease) {
+        if (lease.released)
+            return;
+        const proc = lease.process;
+        if (this.leases.get(proc) !== lease) {
+            lease.markReleased();
+            return;
+        }
+        this.leases.delete(proc);
+        lease.markReleased();
+        if (this.decommissioning.has(proc) && proc.process.exitCode === null && !proc.process.killed) {
+            // Keep the marker until the exit event removes the process. Otherwise a
+            // concurrent acquisition could lease the dying process before SIGTERM lands.
+            console.log(`[pool] Decommissioning pi#${proc.id} after completed operation`);
+            proc.process.kill("SIGTERM");
+        }
+    }
+    decommission(proc) {
+        if (proc.process.exitCode !== null || this.decommissioning.has(proc))
+            return "ignored";
+        this.decommissioning.add(proc);
+        if (this.leases.has(proc))
+            return "draining";
+        proc.process.kill("SIGTERM");
+        return "killed";
+    }
+    /** Evict an idle process from a different cwd to free capacity. */
+    evictIdleDifferentCwd(targetCwd) {
         for (const [cwd, procs] of this.pools) {
             if (cwd === targetCwd)
                 continue;
-            const victim = procs.find((p) => p.process.exitCode === null && !busySet.has(p));
+            const victim = procs.find((proc) => this.isAvailable(proc));
             if (!victim)
                 continue;
             console.log(`[pool] Evicting idle pi#${victim.id} from cwd ${cwd} to make room for ${targetCwd}`);
-            victim.process.kill("SIGTERM");
+            this.decommission(victim);
             return victim;
         }
         return null;
     }
-    /**
-     * Pre-warm the pool with processes for the given cwd.
-     */
-    /**
-     * Pre-warm the pool with processes for the given cwd.
-     * Spawns are staggered: each process must be ready (via get_state RPC)
-     * before the next one is spawned. This prevents lock contention on
-     * shared resources like auth.json during startup.
-     */
+    /** Immediately kill one process while keeping it unavailable until exit. */
+    forceKill(proc) {
+        if (proc.process.exitCode !== null)
+            return false;
+        this.decommissioning.add(proc);
+        return proc.process.kill("SIGKILL");
+    }
+    /** Kill idle processes now and mark leased processes for kill on release. */
+    decommissionAll() {
+        let killed = 0;
+        let draining = 0;
+        for (const proc of this.getAllProcesses()) {
+            const result = this.decommission(proc);
+            if (result === "killed")
+                killed += 1;
+            if (result === "draining")
+                draining += 1;
+        }
+        return { killed, draining };
+    }
     async prewarm(cwd) {
-        const existing = this.pools.get(cwd)?.filter((p) => p.process.exitCode === null).length ?? 0;
+        const existing = this.pools.get(cwd)?.filter((proc) => proc.process.exitCode === null).length ?? 0;
         const needed = Math.min(this.prewarmCount, this.maxProcesses) - existing;
         for (let i = 0; i < needed; i++) {
             if (this.totalProcesses >= this.maxProcesses)
                 break;
             const proc = this.spawn(cwd);
-            if (i < needed - 1) {
-                // Wait for this process to be ready before spawning the next one
+            if (i < needed - 1)
                 await this.waitForReady(proc);
-            }
         }
     }
-    /**
-     * Send an RPC command to a process and wait for a response.
-     */
     sendRpc(proc, command, timeoutMs) {
         if (!proc.process || proc.process.exitCode !== null) {
             return Promise.reject(new Error("RPC process is dead"));
@@ -248,6 +305,9 @@ export class ProcessPool {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 proc.pendingRequests.delete(id);
+                // A timed-out RPC may still be executing. Never return that process to
+                // the idle pool where a new session command could overlap with it.
+                this.decommission(proc);
                 reject(new Error(`Timeout waiting for RPC response to ${command.type}`));
             }, timeout);
             proc.pendingRequests.set(id, {
@@ -263,9 +323,6 @@ export class ProcessPool {
             proc.process.stdin.write(JSON.stringify(fullCommand) + "\n");
         });
     }
-    /**
-     * Send an RPC command and throw if it fails.
-     */
     async sendRpcChecked(proc, command) {
         const response = await this.sendRpc(proc, command);
         if (!response?.success) {

package/dist/server/server/rest-api.js CHANGED Viewed

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, readdirSync, watchFile } from "node:fs";
 import { unlink } from "node:fs/promises";
 import path from "node:path";
-import { buildSessionContext, parseSessionEntries } from "@mariozechner/pi-coding-agent";
+import { parseSessionEntries } from "@earendil-works/pi-coding-agent";
 import { SessionIndex } from "./session-index.js";
 import { LocalSettingsStore } from "./local-settings.js";
 let localSettingsStore;
@@ -37,60 +37,11 @@ async function readJsonBody(req) {
     return JSON.parse(raw || "{}");
 }
 export function registerRestApi(app, options = {}) {
-    const traceStore = options.traceStore;
     localSettingsStore = options.localSettingsStore ?? new LocalSettingsStore();
     sessionIndex = new SessionIndex({
         cwdDisplayFormatter: (cwd) => localSettingsStore.formatCwdTitle(cwd),
     });
     startLocalSettingsWatcher(options.onLocalSettingsReloaded);
-    app.post("/api/debug/load-trace/event", async (req, res) => {
-        try {
-            if (!traceStore) {
-                res.status(404).json({ error: "Tracing disabled" });
-                return;
-            }
-            const chunks = [];
-            for await (const chunk of req)
-                chunks.push(chunk);
-            const body = JSON.parse(Buffer.concat(chunks).toString() || "{}");
-            const traceId = String(body.traceId || req.headers["x-pi-trace-id"] || "");
-            if (!traceId) {
-                res.status(400).json({ error: "Missing traceId" });
-                return;
-            }
-            traceStore.record(traceId, {
-                ts: new Date().toISOString(),
-                source: "frontend",
-                kind: body.durationMs != null ? "span" : "instant",
-                name: String(body.name || "frontend_event"),
-                durationMs: typeof body.durationMs === "number" ? body.durationMs : undefined,
-                attrs: body.attrs && typeof body.attrs === "object" ? body.attrs : undefined,
-            });
-            res.json({ ok: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-    app.get("/api/debug/load-trace/latest", (_req, res) => {
-        if (!traceStore) {
-            res.status(404).json({ error: "Tracing disabled" });
-            return;
-        }
-        res.json({ traces: traceStore.getLatest() });
-    });
-    app.get("/api/debug/load-trace/:traceId", (req, res) => {
-        if (!traceStore) {
-            res.status(404).json({ error: "Tracing disabled" });
-            return;
-        }
-        const trace = traceStore.get(req.params.traceId);
-        if (!trace) {
-            res.status(404).json({ error: "Trace not found" });
-            return;
-        }
-        res.json(trace);
-    });
     app.get("/api/sessions", async (_req, res) => {
         try {
             res.json(await sessionIndex.listSessions());
@@ -175,32 +126,14 @@ export function registerRestApi(app, options = {}) {
                 res.status(404).json({ error: "Session not found" });
                 return;
             }
-            await unlink(sessionPath);
-            res.json({ success: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-    app.get("/api/sessions/messages", (req, res) => {
-        try {
-            const sessionPath = req.query.path;
-            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
-                res.status(400).json({ error: "Missing or invalid session path" });
-                return;
+            const remove = () => unlink(sessionPath);
+            if (options.runSessionMutation) {
+                await options.runSessionMutation(sessionPath, "delete session", remove);
             }
-            if (!existsSync(sessionPath)) {
-                res.status(404).json({ error: "Session file not found" });
-                return;
+            else {
+                await remove();
             }
-            const content = readFileSync(sessionPath, "utf8");
-            const entries = parseSessionEntries(content);
-            const context = buildSessionContext(entries);
-            res.json({
-                messages: context.messages,
-                model: context.model,
-                thinkingLevel: context.thinkingLevel,
-            });
+            res.json({ success: true });
         }
         catch (err) {
             res.status(500).json({ error: err.message });