pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/pidiff/pidiff.ts

@@ -9,12 +9,12 @@
 
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as net from "node:net";
 import * as path from "node:path";
 import { createRequire } from "node:module";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { hyperlink } from "@earendil-works/pi-tui";
 import {
-  createLogger,
   checkHealth,
   ensureUiBuilt,
   spawnDaemon,
@@ -25,16 +25,21 @@ import {
   readLockfile,
   removeLockfile,
 } from "../shared/daemon-manager.js";
+import { createLogger } from "../shared/logger.js";
 import { setupHeartbeat, setupReconnectPoller } from "../shared/ws-client.js";
 import { getSetting } from "../orchestrator/project-settings.js";
+import { shouldSkipOneshotRegister } from "../shared/oneshot.js";
+import { evaluateSpawnLock } from "./spawn-lock.js";
+
+/** Re-export for callers/tests that import from pidiff. */
+export { evaluateSpawnLock } from "./spawn-lock.js";
 
 const RECONNECT_INTERVAL_MS = 5000;
 const ICON_DIFF = "";
 
-const log = createLogger(
-  path.join(process.env.HOME || "/tmp", ".pi", "pidiff-debug.log"),
-  "ext",
-);
+const log = createLogger("pidiff");
+/** String logger for daemon-manager / ws-client APIs that take `(msg: string) => void`. */
+const debugLog = (msg: string) => log.debug(msg);
 
 function isGitRepo(cwd: string): boolean {
   try { execFileSync("git", ["rev-parse", "--git-dir"], { cwd, stdio: "ignore" }); return true; } catch { return false; }
@@ -48,8 +53,35 @@ function getBranch(cwd: string): string {
   } catch { return ""; }
 }
 
+/** Return true if port can be bound on 127.0.0.1. */
+function isPortFree(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once("error", () => { try { srv.close(); } catch {} resolve(false); });
+    srv.listen(port, "127.0.0.1", () => { srv.close(() => resolve(true)); });
+  });
+}
+
+/** Reuse preferred port if free; otherwise allocate a new one. */
+async function resolveSpawnPort(preferred: number | null | undefined): Promise<number> {
+  if (!preferred) {
+    const port = await findFreePort();
+    log.debug(`allocated new port: ${port}`);
+    return port;
+  }
+  if (await isPortFree(preferred)) {
+    log.debug(`reusing lockfile port: ${preferred}`);
+    return preferred;
+  }
+  log.debug(`lockfile port ${preferred} in use, allocating new port`);
+  const port = await findFreePort();
+  log.debug(`allocated new port: ${port}`);
+  return port;
+}
+
 export function registerPidiff(pi: ExtensionAPI): void {
   if (process.env.PI_SUBAGENT_CHILD === "1") return;
+  if (shouldSkipOneshotRegister(log)) return;
 
   const projectCwd = process.cwd();
   const pidiffDisabled = !getSetting(projectCwd, "pidiff_enable");
@@ -96,21 +128,21 @@ export function registerPidiff(pi: ExtensionAPI): void {
   }
 
   function doSpawn(port: number, cwd: string): void {
-    ensureUiBuilt(import.meta.url, "pidiff-ui", log);
+    ensureUiBuilt(import.meta.url, "pidiff-ui", debugLog);
     spawnDaemon({
       serverScript: "pidiff-server.ts",
       logFile: path.join(process.env.HOME || "/tmp", ".pi", "pidiff-server.log"),
       env: { PI_PIDIFF_PORT: String(port), PI_PIDIFF_CWD: cwd },
-      log,
+      log: debugLog,
     });
   }
 
   async function connect(ctx: any) {
-    log(`connect() called, connected=${connected}, connecting=${connecting}`);
+    log.debug(`connect() called, connected=${connected}, connecting=${connecting}`);
     if (connected || connecting || shuttingDown) return;
     connecting = true;
     lastCtx = ctx;
-    if (!lockDir) { log("connect: lockDir not set (session_start not fired yet)"); connecting = false; return; }
+    if (!lockDir) { log.debug("connect: lockDir not set (session_start not fired yet)"); connecting = false; return; }
 
     // Try to discover port from lockfile
     let port = activePort;
@@ -123,12 +155,12 @@ export function registerPidiff(pi: ExtensionAPI): void {
     let running = false;
     if (port) {
       running = await checkHealth(port);
-      log(`lockfile port=${port}, healthy=${running}`);
+      log.debug(`lockfile port=${port}, healthy=${running}`);
     }
 
     if (!running) {
       if (spawning) {
-        log("daemon already spawning, waiting...");
+        log.debug("daemon already spawning, waiting...");
         connecting = false;
         return;
       }
@@ -138,8 +170,17 @@ export function registerPidiff(pi: ExtensionAPI): void {
       try {
         fs.writeFileSync(spawnLock, String(process.pid), { flag: "wx" });
       } catch {
-        // Another session is already spawning — wait for lockfile to appear
-        log("another session is spawning pidiff, waiting for lockfile...");
+        // Another session is already spawning — check if spawner is still alive
+        const lockDecision = evaluateSpawnLock(spawnLock, getSetting(ctx.cwd, "pidiff_stale_lock_timeout_ms"));
+        if (lockDecision.action === "recover" || lockDecision.action === "recover_pid_reuse") {
+          log.info("stale_spawn_lock", lockDecision.reason);
+          try { fs.unlinkSync(spawnLock); } catch {}
+          connecting = false;
+          setTimeout(() => connect(ctx), 500);
+          return;
+        }
+        // Spawner is alive — wait for it
+        log.debug("another session is spawning pidiff, waiting for lockfile...");
         for (let i = 0; i < 30; i++) {
           await new Promise(r => setTimeout(r, 1000));
           const lock = readLockfile(lockDir);
@@ -156,12 +197,12 @@ export function registerPidiff(pi: ExtensionAPI): void {
 
       spawning = true;
       try {
-        log("spawning daemon...");
-        port = await findFreePort();
-        log(`allocated free port: ${port}`);
+        log.debug("spawning daemon...");
+        // Reuse lockfile port if available — keeps URL stable across reload/restart
+        port = await resolveSpawnPort(port);
         doSpawn(port, ctx.cwd);
-        writeLockfile(lockDir, port, null, log);
-        const ready = await waitForDaemon(port, 60, log);
+        writeLockfile(lockDir, port, null, debugLog);
+        const ready = await waitForDaemon(port, getSetting(process.cwd(), "pidiff_daemon_startup_timeout_s"), debugLog);
         if (!ready) { connecting = false; return; }
       } finally {
         spawning = false;
@@ -174,11 +215,11 @@ export function registerPidiff(pi: ExtensionAPI): void {
     try {
       const _require = createRequire(import.meta.url);
       const WebSocket = _require("ws");
-      log(`connecting WebSocket to port ${activePort}...`);
+      log.debug(`connecting WebSocket to port ${activePort}...`);
       const wsClient = new WebSocket(`ws://127.0.0.1:${activePort}/ws/pi`);
 
       wsClient.on("open", () => {
-        log("WebSocket connected");
+        log.debug("WebSocket connected");
         ws = wsClient;
         connected = true;
         connecting = false;
@@ -197,14 +238,14 @@ export function registerPidiff(pi: ExtensionAPI): void {
           }));
         } catch {
           // ctx may be stale if session was replaced during WebSocket connect
-          log("skipped registration — ctx is stale");
+          log.debug("skipped registration — ctx is stale");
         }
 
         // Keepalive + dead connection detection
         if (cleanupHeartbeat) cleanupHeartbeat();
         cleanupHeartbeat = setupHeartbeat({
           ws: wsClient,
-          log,
+          log: debugLog,
           onDead: () => {
             connected = false; ws = null;
             if (!shuttingDown && lastCtx) setTimeout(() => connect(lastCtx), 1000);
@@ -216,7 +257,7 @@ export function registerPidiff(pi: ExtensionAPI): void {
         try {
           const parsed = JSON.parse(data.toString());
           if (parsed.type === "publish-review" && parsed.comments?.length > 0) {
-            log(`review received: ${parsed.comments.length} comments`);
+            log.debug(`review received: ${parsed.comments.length} comments`);
             const review = {
               source: "pidiff",
               type: "code-review",
@@ -235,25 +276,26 @@ export function registerPidiff(pi: ExtensionAPI): void {
             const message = `## pidiff: Code Review Comments\n\n\`\`\`json\n${JSON.stringify(review, null, 2)}\n\`\`\`\n\nPlease address these review comments.`;
             pi.sendUserMessage(message, { deliverAs: "followUp" });
           }
-        } catch (e: any) { log(`message handler error: ${e.message}`); }
+        } catch (e: any) { log.debug(`message handler error: ${e.message}`); }
       });
 
       wsClient.on("close", () => {
-        log("WebSocket closed");
+        log.debug("WebSocket closed");
         connected = false; ws = null; connecting = false;
         if (!shuttingDown) {
           setTimeout(() => { if (lastCtx && !shuttingDown) connect(lastCtx); }, RECONNECT_INTERVAL_MS);
         }
       });
 
-      wsClient.on("error", (e: Error) => { log(`WebSocket error: ${e.message}`); });
+      wsClient.on("error", (e: Error) => { log.debug(`WebSocket error: ${e.message}`); });
     } catch (e: any) {
-      log(`connect error: ${e.message}`);
+      log.debug(`connect error: ${e.message}`);
       connecting = false;
     }
   }
 
   // /pidiff command
+  let pidiffCmdHandler: any;
   pi.registerCommand("pidiff", {
     description: "Manage pidiff server — /pidiff start|stop|restart|status",
     getArgumentCompletions: (prefix: string) => {
@@ -265,7 +307,7 @@ export function registerPidiff(pi: ExtensionAPI): void {
       ];
       return items.filter(i => i.value.startsWith(prefix.toLowerCase()));
     },
-    handler: async (args, ctx) => {
+    handler: pidiffCmdHandler = async (args: any, ctx: any) => {
       lastCtx = ctx;
       const cmd = (args || "").trim().toLowerCase();
 
@@ -273,8 +315,8 @@ export function registerPidiff(pi: ExtensionAPI): void {
         if (ws) { try { ws.close(); } catch {} ws = null; }
         connected = false;
         const pidFile = path.join(lockDir, "pidiff.pid");
-        killDaemonByPid(pidFile, log);
-        removeLockfile(lockDir, log);
+        killDaemonByPid(pidFile, debugLog);
+        removeLockfile(lockDir, debugLog);
         activePort = 0;
         if (ctx.hasUI) { ctx.ui.setStatus("8-diff", undefined); ctx.ui.notify("pidiff server stopped", "info"); }
         return;
@@ -288,11 +330,12 @@ export function registerPidiff(pi: ExtensionAPI): void {
           if (!connected) connect(ctx);
           return;
         }
-        const port = await findFreePort();
+        // Reuse lockfile port to keep URL stable — fall back if taken
+        const port = await resolveSpawnPort(lock?.port);
         doSpawn(port, ctx.cwd);
-        writeLockfile(lockDir, port, null, log);
+        writeLockfile(lockDir, port, null, debugLog);
         if (ctx.hasUI) ctx.ui.notify("Starting pidiff server...", "info");
-        if (await waitForDaemon(port, 60, log)) {
+        if (await waitForDaemon(port, getSetting(process.cwd(), "pidiff_daemon_startup_timeout_s"), debugLog)) {
           activePort = port;
           connect(ctx);
           if (ctx.hasUI) ctx.ui.notify(`pidiff started at http://localhost:${activePort}`, "info");
@@ -306,14 +349,18 @@ export function registerPidiff(pi: ExtensionAPI): void {
         if (ws) { try { ws.close(); } catch {} ws = null; }
         connected = false;
         const pidFile = path.join(lockDir, "pidiff.pid");
-        killDaemonByPid(pidFile, log);
-        removeLockfile(lockDir, log);
+        // Reuse existing port to keep URL stable (read before removeLockfile)
+        const lock = readLockfile(lockDir);
+        const preferredPort = activePort || lock?.port || 0;
+        killDaemonByPid(pidFile, debugLog);
+        removeLockfile(lockDir, debugLog);
         await new Promise(r => setTimeout(r, 1000));
-        const port = await findFreePort();
+        // Verify preferred port is free after kill — fall back if taken by another process
+        const port = await resolveSpawnPort(preferredPort || null);
         doSpawn(port, ctx.cwd);
-        writeLockfile(lockDir, port, null, log);
+        writeLockfile(lockDir, port, null, debugLog);
         if (ctx.hasUI) ctx.ui.notify("Restarting pidiff server...", "info");
-        if (await waitForDaemon(port, 60, log)) {
+        if (await waitForDaemon(port, getSetting(process.cwd(), "pidiff_daemon_startup_timeout_s"), debugLog)) {
           activePort = port;
           connect(ctx);
           if (ctx.hasUI) ctx.ui.notify(`pidiff restarted at http://localhost:${activePort}`, "info");
@@ -333,6 +380,17 @@ export function registerPidiff(pi: ExtensionAPI): void {
     },
   });
 
+  // Expose handler to pidash for browser command dispatch
+  try {
+    if ((globalThis as any).__pidiff_pidash_listener) {
+      try { pi.events.removeListener("pidash:request-commands", (globalThis as any).__pidiff_pidash_listener); } catch {}
+    }
+    const registerWithPidash = () => pi.events.emit("pidash:register-command", { name: "pidiff", handler: pidiffCmdHandler });
+    (globalThis as any).__pidiff_pidash_listener = registerWithPidash;
+    registerWithPidash();
+    pi.events.on("pidash:request-commands", registerWithPidash);
+  } catch {}
+
   // Session lifecycle
   pi.on("session_start", async (_event, ctx) => {
     lastCtx = ctx;

package/extensions/pidiff/spawn-lock.ts

@@ -0,0 +1,62 @@
+/**
+ * Spawn-lock evaluation for pidiff daemon startup races.
+ * No pi-tui / ExtensionAPI deps — unit tests can import directly.
+ */
+import * as fs from "node:fs";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("pidiff");
+
+/**
+ * Evaluate a stale spawn lockfile and decide the recovery action.
+ * Exported for testing.
+ */
+export function evaluateSpawnLock(
+  lockPath: string,
+  staleTimeoutMs: number,
+): { action: "wait" | "recover" | "recover_pid_reuse"; reason: string } {
+  log.debug("evaluate_spawn_lock", "lockPath", lockPath, "staleTimeoutMs", staleTimeoutMs);
+  const effectiveTimeout = Math.max(staleTimeoutMs, 1000); // Floor at 1s to prevent thrashing
+  let result: { action: "wait" | "recover" | "recover_pid_reuse"; reason: string };
+
+  try {
+    const content = fs.readFileSync(lockPath, "utf-8").trim();
+    const spawnerPid = /^\d+$/.test(content) ? parseInt(content, 10) : NaN;
+
+    if (!spawnerPid || isNaN(spawnerPid)) {
+      // No valid PID — check age
+      const lockAge = Date.now() - fs.statSync(lockPath).mtimeMs;
+      if (lockAge > effectiveTimeout) {
+        result = { action: "recover", reason: `no valid PID, age ${Math.round(lockAge / 1000)}s > timeout` };
+      } else {
+        result = { action: "wait", reason: "no valid PID but lock is young" };
+      }
+    } else {
+      let isAlive = false;
+      try {
+        process.kill(spawnerPid, 0);
+        isAlive = true;
+      } catch (e: any) {
+        // EPERM = process exists but we can't signal it — treat as alive
+        isAlive = e?.code === "EPERM";
+      }
+
+      if (!isAlive) {
+        result = { action: "recover", reason: `PID ${spawnerPid} is dead` };
+      } else {
+        // PID alive — check for PID reuse (lock age > timeout)
+        const lockAge = Date.now() - fs.statSync(lockPath).mtimeMs;
+        if (lockAge > effectiveTimeout) {
+          result = { action: "recover_pid_reuse", reason: `PID ${spawnerPid} alive but lock age ${Math.round(lockAge / 1000)}s > timeout (likely PID reuse)` };
+        } else {
+          result = { action: "wait", reason: `PID ${spawnerPid} alive, lock age ${Math.round(lockAge / 1000)}s within threshold` };
+        }
+      }
+    }
+  } catch {
+    result = { action: "recover", reason: "cannot read/stat lockfile" };
+  }
+
+  log.debug("evaluate_spawn_lock", result.action, result.reason);
+  return result;
+}