@evandu/super-pi 0.1.80 → 0.1.81

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:09:25.847Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "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);