@rotriz/pi-web-ui 1.2.0 → 1.4.0

package/extension.mjs

@@ -1,153 +1,64 @@
 // pi-web-ui extension entry point for the Pi coding agent.
-// Registers the /web command and starts the HTTP/SSE gateway.
+// Runs the HTTP/SSE gateway in-process (no subprocess needed).
 
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { exec, execFile } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
-import { request } from "node:http";
+import { exec } from "node:child_process";
 
 const PORT = Number(process.env.PI_WEB_PORT || process.env.PORT || 3123);
 
-// HTTP GET helper — works on Node 14+ without global fetch
-function httpGet(url) {
-  return new Promise((resolve) => {
-    const req = request(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data }));
-    });
-    req.on("error", () => resolve({ ok: false, status: 0, data: "" }));
-    req.setTimeout(3000, () => { req.destroy(); resolve({ ok: false, status: 0, data: "" }); });
-    req.end();
-  });
-}
-
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   exec(`${cmd} ${JSON.stringify(url)}`, () => {});
 }
 
-// Resolve the pi-coding-agent module path from within Pi's process context
-function findPiModulePath() {
-  try {
-    // When running inside Pi, the module is already loaded — find it via require.resolve or import.meta
-    const candidates = [];
-    // Check if pi's entry script reveals the path
-    const entry = process.argv[1] || "";
-    if (entry) {
-      const dir = dirname(entry);
-      candidates.push(join(dir, "..", "dist", "index.js"));
-      candidates.push(join(dir, "index.js"));
-      // Go up to find the package
-      let d = dir;
-      for (let i = 0; i < 5; i++) {
-        const candidate = join(d, "dist", "index.js");
-        if (existsSync(candidate)) candidates.push(candidate);
-        const pkgCandidate = join(d, "node_modules", "@earendil-works", "pi-coding-agent", "dist", "index.js");
-        if (existsSync(pkgCandidate)) candidates.push(pkgCandidate);
-        d = dirname(d);
-      }
-    }
-    // Check common global locations
-    const globalDirs = [
-      join(homedir(), ".local", "share", "fnm"),
-      "/usr/local/lib/node_modules",
-      "/usr/lib/node_modules",
-      join(homedir(), ".nvm", "versions", "node"),
-      join(homedir(), ".volta", "tools", "image", "packages"),
-    ];
-    for (const base of globalDirs) {
-      if (!existsSync(base)) continue;
-      // Recursively look for the package
-      const piPkg = "@earendil-works/pi-coding-agent/dist/index.js";
-      // Check direct path
-      const direct = join(base, piPkg);
-      if (existsSync(direct)) { candidates.push(direct); continue; }
-      // For version managers, search one level deep
-    }
-    // Also check NODE_PATH
-    if (process.env.NODE_PATH) {
-      for (const p of process.env.NODE_PATH.split(":")) {
-        const candidate = join(p, "@earendil-works", "pi-coding-agent", "dist", "index.js");
-        if (existsSync(candidate)) candidates.push(candidate);
-      }
-    }
-    for (const c of candidates) {
-      if (existsSync(c)) return c;
-    }
-  } catch {}
-  return null;
-}
-
 export default function (pi) {
-  let serverProcess = null;
-  let origin = `http://localhost:${PORT}`;
-
-  const extDir = (() => {
-    try {
-      return dirname(fileURLToPath(import.meta.url));
-    } catch {
-      return join(homedir(), ".pi", "agent", "extensions", "pi-web-ui");
-    }
-  })();
-
-  function findNode() {
-    return process.execPath;
-  }
+  let serverStarted = false;
+  let startPromise = null;
+  const origin = `http://localhost:${PORT}`;
 
   async function ensureServer() {
-    // Check if server is already running (from a previous session or manual start)
-    try {
-      const res = await httpGet(`${origin}/api/tabs`);
-      if (res.ok) return;
-    } catch {}
-
-    if (serverProcess && !serverProcess.killed) return;
-    const serverPath = join(extDir, "server.mjs");
-    if (!existsSync(serverPath)) {
-      throw new Error(`pi-web-ui server not found at ${serverPath}`);
-    }
-
-    // Resolve the pi module path and pass it to the server
-    const piModulePath = findPiModulePath();
-    const env = { ...process.env, PORT: String(PORT) };
-    if (piModulePath) env.PI_WEB_PI_MODULE = piModulePath;
-
-    // Also pass NODE_PATH so the subprocess can find global modules
-    const nodePath = [];
-    if (process.env.NODE_PATH) nodePath.push(process.env.NODE_PATH);
-    // Add the global node_modules from the current node binary
-    const nodeDir = dirname(dirname(process.execPath));
-    const globalNM = join(nodeDir, "lib", "node_modules");
-    if (existsSync(globalNM)) nodePath.push(globalNM);
-    if (nodePath.length) env.NODE_PATH = nodePath.join(":");
-
-    serverProcess = execFile(findNode(), [serverPath], {
-      cwd: process.cwd(),
-      env,
-      stdio: "ignore",
-    });
-    serverProcess.unref();
-    serverProcess.on("exit", () => { serverProcess = null; });
-
-    // Wait for the server to be ready (up to 30 seconds)
-    for (let i = 0; i < 60; i++) {
-      await new Promise((r) => setTimeout(r, 500));
+    if (serverStarted) return;
+    if (startPromise) return startPromise;
+    startPromise = (async () => {
       try {
-        const res = await httpGet(`${origin}/api/tabs`);
-        if (res.ok) return;
-      } catch {}
-    }
-    throw new Error("pi-web-ui server did not start in time");
+        // Make @earendil-works/pi-coding-agent resolvable by the server module.
+        // Since we're in Pi's process, the module is already loaded — expose it globally.
+        try {
+          const piMod = await import("@earendil-works/pi-coding-agent");
+          globalThis.__PI_MODULE__ = piMod;
+        } catch {
+          // Fallback: resolve relative to Pi's entry script
+          const entry = process.argv[1] || "";
+          if (entry) {
+            const { dirname, join } = await import("node:path");
+            const dir = dirname(entry);
+            for (const c of [join(dir, "..", "dist", "index.js"), join(dir, "index.js")]) {
+              try { globalThis.__PI_MODULE__ = await import(c); break; } catch {}
+            }
+          }
+        }
+        const { startServer } = await import("./server.mjs");
+        await startServer(PORT);
+        serverStarted = true;
+      } catch (err) {
+        if (err?.code === "EADDRINUSE") {
+          serverStarted = true;
+          return;
+        }
+        throw err;
+      } finally {
+        startPromise = null;
+      }
+    })();
+    return startPromise;
   }
 
-  async function stopServer() {
-    if (serverProcess && !serverProcess.killed) {
-      serverProcess.kill();
-      serverProcess = null;
-    }
+  async function stopServerFn() {
+    if (!serverStarted) return;
+    try {
+      const { stopServer } = await import("./server.mjs");
+      await stopServer();
+      serverStarted = false;
+    } catch {}
   }
 
   // ── Lifecycle ────────────────────────────────────────────────────────
@@ -159,7 +70,7 @@ export default function (pi) {
 
   pi.on("session_shutdown", async (event) => {
     if (event.reason === "reload" || event.reason === "quit") {
-      await stopServer();
+      await stopServerFn();
     }
   });
 
@@ -173,7 +84,7 @@ export default function (pi) {
     handler: async (args, ctx) => {
       const arg = String(args ?? "").trim().toLowerCase();
       if (arg === "stop") {
-        await stopServer();
+        await stopServerFn();
         ctx.ui?.notify?.("pi-web-ui stopped", "info");
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotriz/pi-web-ui",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Web UI extension for the Pi coding agent — browser-based session management, git integration, and task tracking",
   "type": "module",
   "license": "MIT",

package/server.mjs

@@ -19,8 +19,17 @@ const PORT = process.env.PORT || 3123;
 const CWD = process.cwd();
 const HERE = dirname(fileURLToPath(import.meta.url));
 
-// Resolve the pi-coding-agent module: env override → bare specifier → NODE_PATH → common global paths
+// ─── Pi module resolution ─────────────────────────────────────────────────
+let _piModule = null;
+
+export function initPiModule(mod) {
+  _piModule = mod;
+}
+
 async function resolvePiModule() {
+  if (_piModule) return _piModule;
+  // Check if the extension pre-loaded the module via globalThis
+  if (globalThis.__PI_MODULE__) { _piModule = globalThis.__PI_MODULE__; return _piModule; }
   const attempts = [];
   if (process.env.PI_WEB_PI_MODULE) attempts.push(process.env.PI_WEB_PI_MODULE);
   attempts.push("@earendil-works/pi-coding-agent");
@@ -30,35 +39,51 @@ async function resolvePiModule() {
     attempts.push(join(dir, "..", "dist", "index.js"));
     attempts.push(join(dir, "index.js"));
   }
-  // Try NODE_PATH entries
   if (process.env.NODE_PATH) {
     for (const p of process.env.NODE_PATH.split(":")) {
       attempts.push(join(p, "@earendil-works", "pi-coding-agent", "dist", "index.js"));
     }
   }
-  // Common global install locations
   const nodeDir = dirname(dirname(process.execPath));
   attempts.push(join(nodeDir, "lib", "node_modules", "@earendil-works", "pi-coding-agent", "dist", "index.js"));
-  // npm global prefix
   attempts.push(join(homedir(), ".local", "lib", "node_modules", "@earendil-works", "pi-coding-agent", "dist", "index.js"));
   for (const attempt of attempts) {
-    try { return await import(attempt); } catch {}
+    try { _piModule = await import(attempt); return _piModule; } catch {}
   }
   throw new Error("Could not resolve @earendil-works/pi-coding-agent. Install it globally or set PI_WEB_PI_MODULE env var.");
 }
-const pi = await resolvePiModule();
 
-const {
-  createAgentSessionRuntime,
-  createAgentSessionFromServices,
-  createAgentSessionServices,
-  DefaultResourceLoader,
-  SessionManager,
-  SettingsManager,
-  getAgentDir,
-} = pi;
+// Only auto-initialize when run directly (node server.mjs)
+const _isDirectRun = process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url));
+if (_isDirectRun) {
+  await resolvePiModule();
+} else if (globalThis.__PI_MODULE__) {
+  _piModule = globalThis.__PI_MODULE__;
+}
+
+let createAgentSessionRuntime, createAgentSessionFromServices, createAgentSessionServices,
+    DefaultResourceLoader, SessionManager, SettingsManager, getAgentDir;
+
+if (_piModule) {
+  ({ createAgentSessionRuntime, createAgentSessionFromServices, createAgentSessionServices,
+     DefaultResourceLoader, SessionManager, SettingsManager, getAgentDir } = _piModule);
+}
+
+let AGENT_DIR = null;
+
+let server = null;
+let _booted = false;
+
+async function boot() {
+  if (_booted) return;
+  if (!_piModule) {
+    if (globalThis.__PI_MODULE__) _piModule = globalThis.__PI_MODULE__;
+    else await resolvePiModule();
+    ({ createAgentSessionRuntime, createAgentSessionFromServices, createAgentSessionServices,
+       DefaultResourceLoader, SessionManager, SettingsManager, getAgentDir } = _piModule);
+  }
+  AGENT_DIR = getAgentDir();
 
-const AGENT_DIR = getAgentDir();
 
 const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
   const services = await createAgentSessionServices({ cwd });
@@ -868,7 +893,7 @@ function readBody(req) {
   });
 }
 
-const server = createServer(async (req, res) => {
+server = createServer(async (req, res) => {
   const url = new URL(req.url, `http://localhost:${PORT}`);
   const path = url.pathname;
 
@@ -1403,4 +1428,27 @@ const server = createServer(async (req, res) => {
   }
 });
 
-server.listen(PORT, () => console.log(`[pi-web-ui] listening on http://localhost:${PORT}`));
+  _booted = true;
+}
+
+// When run directly (node server.mjs), boot and listen immediately.
+const _isDirect = process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url));
+if (_isDirect) {
+  await boot();
+  server.listen(PORT, () => console.log(`[pi-web-ui] listening on http://localhost:${PORT}`));
+}
+
+export { PORT };
+export async function startServer(port) {
+  await boot();
+  return new Promise((res, rej) => {
+    server.listen(port || PORT, () => {
+      console.log(`[pi-web-ui] listening on http://localhost:${port || PORT}`);
+      res();
+    });
+    server.on("error", rej);
+  });
+}
+export async function stopServer() {
+  if (server) return new Promise((res) => server.close(() => res()));
+}