@evandu/super-pi 0.1.80 → 0.1.82

package/bin/super-pi.js

@@ -3,6 +3,8 @@ import { spawn } from "node:child_process";
 import { resolve } from "node:path";
 
 const entry = resolve(import.meta.dirname, "../dist/server/index.js");
+const packageRoot = resolve(import.meta.dirname, "..");
+const packagePrefix = packageRoot.match(/^(.*)[\\/]node_modules[\\/]/i)?.[1];
 
 const sub = process.argv[2]?.toLowerCase();
 const port = Number(process.env.SUPER_PI_PORT ?? 3080);
@@ -61,7 +63,8 @@ if (sub === "update") {
   // the user's shell isn't tied to the upgrade.
   console.log("Updating @evandu/super-pi via npm...");
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-  const updater = spawn(npmCmd, ["install", "-g", "@evandu/super-pi"], {
+  const updateArgs = packagePrefix ? ["install", "--prefix", packagePrefix, "@evandu/super-pi"] : ["install", "-g", "@evandu/super-pi"];
+  const updater = spawn(npmCmd, updateArgs, {
     stdio: "inherit",
     shell: process.platform === "win32",
     env: process.env,

package/dist/client/.super-pi-client-sources.json

@@ -21,5 +21,5 @@
     "src/client/types.ts": "11fd40e5784a2e765635f4f57d6edd5c97ad0eae85b1825b9da32a88d25b4db9",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-10-18T00:04:03.485Z"
+  "recordedAt": "2026-10-18T00:14:15.331Z"
 }

package/dist/server/command-handler.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { join } from "node:path";
+import { packageUpdateArgs } from "./update.js";
 /**
  * Routes client commands to appropriate application services and converts results or errors.
  */
@@ -259,7 +260,8 @@ export class CommandHandler {
             // /api/update endpoint uses runs detached. The user sees npm's output stream in their
             // terminal because stdio: inherit is what makes a CLI feel like a CLI.
             const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-            const updater = spawn(npmCmd, ["install", "-g", "@evandu/super-pi"], { stdio: "inherit", shell: process.platform === "win32", env: process.env });
+            const update = packageUpdateArgs(this.rootDir ?? import.meta.dirname);
+            const updater = spawn(npmCmd, update.args, { stdio: "inherit", shell: process.platform === "win32", env: process.env });
             updater.on("error", (error) => { console.error(`Super Pi: npm install failed: ${error instanceof Error ? error.message : "unknown error"}`); });
             updater.on("close", (code) => {
                 if (code !== 0) {

package/dist/server/http-server.js

@@ -9,6 +9,7 @@ import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
 import { gitDiff, gitLog, gitStatus } from "./git.js";
 import { verifyCapability } from "./capability.js";
+import { packageUpdateArgs } from "./update.js";
 const MIME_TYPES = {
     ".css": "text/css; charset=utf-8",
     ".html": "text/html; charset=utf-8",
@@ -427,11 +428,13 @@ export function createHttpServer(options) {
             // Use npm directly instead of `pi update` to avoid Windows detached+shell exit timing issues.
             // npm's exit code correctly reflects whether the update succeeded.
             const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-            const child = spawn(npmCmd, ["install", "-g", "@evandu/super-pi"], { stdio: "ignore", shell: process.platform === "win32", env: process.env });
+            const update = packageUpdateArgs(rootDir);
+            const child = spawn(npmCmd, update.args, { stdio: "ignore", shell: process.platform === "win32", env: process.env });
             child.on("close", (code) => {
                 if (code === 0 || code === null) {
                     console.log("Super Pi: npm install completed, triggering restart.");
                     const restart = spawn(process.execPath, [join(rootDir, "scripts", "restart-server.mjs")], { cwd: rootDir, detached: true, stdio: "ignore", env: process.env });
+                    restart.on("error", (restartError) => console.error(`Super Pi: restart after update failed: ${restartError instanceof Error ? restartError.message : String(restartError)}`));
                     restart.unref();
                 }
                 else {

package/dist/server/update.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return npm's install arguments for the package that is actually running.
+ *
+ * Pi can keep Super Pi in its own npm prefix, separate from the user's normal
+ * global npm prefix.  A bare `npm install -g` therefore may update a different
+ * copy while this process keeps serving the old one.  Installed package roots
+ * contain `node_modules/@evandu/super-pi`; walking back to the prefix makes the
+ * update target unambiguous.  Source checkouts retain the global fallback.
+ */
+export declare function packageUpdateArgs(rootDir: string): {
+    args: string[];
+    prefix?: string;
+};

package/dist/server/update.js

@@ -0,0 +1,20 @@
+import { sep } from "node:path";
+/**
+ * Return npm's install arguments for the package that is actually running.
+ *
+ * Pi can keep Super Pi in its own npm prefix, separate from the user's normal
+ * global npm prefix.  A bare `npm install -g` therefore may update a different
+ * copy while this process keeps serving the old one.  Installed package roots
+ * contain `node_modules/@evandu/super-pi`; walking back to the prefix makes the
+ * update target unambiguous.  Source checkouts retain the global fallback.
+ */
+export function packageUpdateArgs(rootDir) {
+    const marker = `${sep}node_modules${sep}`;
+    const lower = rootDir.toLowerCase();
+    const index = lower.lastIndexOf(marker);
+    if (index >= 0) {
+        const prefix = rootDir.slice(0, index);
+        return { prefix, args: ["install", "--prefix", prefix, "@evandu/super-pi"] };
+    }
+    return { args: ["install", "-g", "@evandu/super-pi"] };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,7 @@
     "dist",
     "agents",
     "bin",
+    "scripts/restart-server.mjs",
     "README.md"
   ],
   "engines": {

package/scripts/restart-server.mjs

@@ -0,0 +1,62 @@
+import { spawn, execFile } from "node:child_process";
+import { openSync, readFileSync } from "node:fs";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const port = Number(process.env.SUPER_PI_PORT ?? 3080);
+const entry = "dist/server/index.js";
+const allowedEntries = [entry, "src/server/index.ts"];
+const waitMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pidsOnPort() {
+  if (platform() === "win32") {
+    const { stdout } = await execFileAsync("netstat", ["-ano", "-p", "TCP"]);
+    return [...new Set(stdout.split(/\r?\n/).filter((line) => line.includes(`:${port}`) && /LISTENING\s+\d+/.test(line)).map((line) => line.trim().split(/\s+/).at(-1)))];
+  }
+  try { const { stdout } = await execFileAsync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"]); return stdout.trim().split(/\s+/).filter(Boolean); }
+  catch { const { stdout } = await execFileAsync("sh", ["-c", `ss -lptn 'sport = :${port}' 2>/dev/null`]); return [...new Set([...stdout.matchAll(/pid=(\d+)/g)].map((match) => match[1]))]; }
+}
+async function commandLine(pid) {
+  if (platform() === "win32") { const { stdout } = await execFileAsync("powershell", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter \"ProcessId=${pid}\").CommandLine`]); return stdout.trim(); }
+  try { return (await import("node:fs/promises")).readFile(`/proc/${pid}/cmdline`, "utf8").then((value) => value.replaceAll("\0", " ").trim()); } catch { const { stdout } = await execFileAsync("ps", ["-p", pid, "-o", "command="]); return stdout.trim(); }
+}
+async function requestShutdown() {
+  const headers = {};
+  if (process.env.SUPER_PI_ACCESS_TOKEN) headers.authorization = `Bearer ${process.env.SUPER_PI_ACCESS_TOKEN}`;
+  try { return (await fetch(`http://127.0.0.1:${port}/api/shutdown`, { method: "POST", headers, signal: AbortSignal.timeout(2000) })).status; }
+  catch { return null; }
+}
+async function waitForPortRelease(timeoutMs) {
+  for (let elapsed = 0; elapsed < timeoutMs; elapsed += 100) { if (!(await pidsOnPort()).length) return true; await waitMs(100); }
+  return false;
+}
+// On Windows a detached, console-less node.exe has no window to receive WM_CLOSE, so plain
+// taskkill (SIGTERM-like) always fails; /F (or SIGKILL elsewhere) is the only force option.
+async function forceKill(pid) {
+  console.log(`Force-killing PID ${pid} (graceful shutdown unavailable or timed out)...`);
+  if (platform() === "win32") await execFileAsync("taskkill", ["/PID", pid, "/T", "/F"]).catch((error) => console.log(`taskkill /F warning: ${error.message}`));
+  else process.kill(Number(pid), "SIGKILL");
+}
+async function stopConflicts() {
+  const pids = await pidsOnPort(); if (!pids.length) { console.log(`Port ${port} is free.`); return true; }
+  for (const pid of pids) { const cmd = await commandLine(pid); console.log(`Port ${port} is occupied by PID ${pid}: ${cmd}`); if (!allowedEntries.some((candidate) => cmd.includes(candidate))) { console.error(`Refusing to kill non-super-pi process on port ${port}: ${cmd}`); process.exitCode = 2; return false; } }
+  const status = await requestShutdown();
+  if (status !== null && status >= 200 && status < 300) {
+    console.log(`Graceful shutdown accepted (HTTP ${status}); waiting for port ${port} to release...`);
+    if (await waitForPortRelease(3000)) { console.log(`Port ${port} released after graceful shutdown.`); return true; }
+    console.log(`Graceful shutdown did not release port ${port} within 3s.`);
+  } else {
+    console.log(`Graceful shutdown unavailable (HTTP ${status ?? "no response"}); the running server may predate the shutdown endpoint.`);
+  }
+  for (const pid of await pidsOnPort()) await forceKill(pid);
+  if (await waitForPortRelease(2000)) { console.log(`Port ${port} released after force kill.`); return true; }
+  console.error(`Port ${port} is still occupied after force kill.`); process.exitCode = 1; return false;
+}
+if (await stopConflicts() === false) process.exit(2);
+console.log(`Starting ${entry} on port ${port}...`);
+const logPath = process.env.SUPER_PI_LOG ?? "restart-server.log";
+const logFd = openSync(logPath, "a");
+const child = spawn(process.execPath, [entry], { stdio: ["ignore", logFd, logFd], detached: true, env: process.env });
+child.unref();
+for (let elapsed = 0; elapsed < 10000; elapsed += 200) { try { const response = await fetch(`http://127.0.0.1:${port}/api/health`); const body = await response.json(); if (response.ok && body.status === "ok" && body.service === "super-pi") { console.log("Server ready: /api/health passed."); process.exit(0); } } catch {} await waitMs(200); }
+console.error(`Server failed readiness check. See ${logPath}:`); try { console.error(readFileSync(logPath, "utf8").slice(-8000)); } catch {} child.kill(); process.exit(1);