pi-web-ui 0.8.2 → 0.8.4

package/bin/pi-web-ui.mjs

@@ -394,7 +394,7 @@ User=${process.env.SUDO_USER ?? userInfo().username}
 WorkingDirectory=${cwd}
 ${envLines}
 ExecStart=${JSON.stringify(NODE)} ${JSON.stringify(SERVER_ENTRY)}
-Restart=on-failure
+Restart=always
 RestartSec=5
 
 [Install]

package/dist/server/agent-service.js

@@ -946,6 +946,11 @@ export class ClientSession {
     }
     /** True once updateApp succeeded — the process must restart to run new code. */
     pendingRestart = false;
+    /**
+     * Set by index.ts: called after a successful self-update; returns whether
+     * the process is going to restart itself (so the notice can say so).
+     */
+    onUpdateReady = undefined;
     /** Ask the npm registry for the latest pi-web-ui version and report it. */
     async checkUpdate() {
         const current = ClientSession.currentAppVersion();
@@ -993,10 +998,13 @@ export class ClientSession {
                     ok: true,
                     detail: out.slice(0, 400),
                 });
+                const autoRestart = this.onUpdateReady?.() ?? false;
                 this.emit({
                     type: "notice",
                     level: "info",
-                    text: "✅ 已更新 pi-web-ui，重启服务后生效（pi-web-ui server restart）",
+                    text: autoRestart
+                        ? "✅ 已更新 pi-web-ui，正在自动重启…"
+                        : "✅ 已更新 pi-web-ui，重启服务后生效（pi-web-ui server restart）",
                 });
             }
             else {
@@ -2350,6 +2358,11 @@ export class AgentService {
     clients = new Map();
     pending = new Map();
     stateStore;
+    /**
+     * Set by index.ts: called by a client session after a successful
+     * self-update; returns whether the process will restart itself.
+     */
+    onUpdateReady = undefined;
     constructor(cwd, sessionDirRoot, stateFile) {
         this.cwd = cwd;
         this.sessionDirRoot = sessionDirRoot;
@@ -2395,6 +2408,8 @@ export class AgentService {
             }
         }
         cs.attachSink(send);
+        // Forward the update hook (set once by index.ts) to every session.
+        cs.onUpdateReady = this.onUpdateReady;
         return cs;
     }
     /** Remove a socket from a client's broadcast set (called on socket close). */

package/dist/server/index.js

@@ -15,6 +15,8 @@
 import { existsSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import { createServer } from "node:http";
+import { createConnection } from "node:net";
+import { spawn } from "node:child_process";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
@@ -109,6 +111,51 @@ const heartbeatTimer = setInterval(() => {
 const service = new AgentService(CWD, SESSION_DIR_ROOT, 
 // Per-client persisted UI state: last-used workspace + recent projects.
 join(DATA_DIR, "client-state.json"));
+// ---------------------------------------------------------------------------
+// Self-update auto-restart
+// ---------------------------------------------------------------------------
+// npm i -g writes new code to disk but the running process keeps the old
+// code in memory — so a successful in-app update hands the process over:
+//   macOS launchd (KeepAlive) and systemd (Restart) relaunch us on exit;
+//   foreground runs get a replacement child that waits for our port to free.
+// Docker containers can't self-restart (the orchestrator owns that), so they
+// keep the manual-restart notice.
+const RESTART_CHILD_ENV = "PI_WEB_RESTART_CHILD";
+function scheduleUpdateRestart() {
+    const isLaunchd = process.platform === "darwin" && process.ppid === 1;
+    const isSystemd = process.platform === "linux" && !!process.env.INVOCATION_ID;
+    const inDocker = existsSync("/.dockerenv");
+    if (isLaunchd || isSystemd || inDocker) {
+        // Supervisors relaunch on exit; Docker restarts externally. Nothing to
+        // spawn — just exit after the notice has flushed.
+        if (isLaunchd || isSystemd) {
+            setTimeout(() => {
+                console.log("update applied — auto-restarting…");
+                if (isSystemd) {
+                    // Non-zero exit: legacy units use Restart=on-failure.
+                    process.exit(3);
+                }
+                void shutdown();
+            }, 1500);
+            return true;
+        }
+        return false;
+    }
+    // Foreground / Windows: spawn a replacement from the updated install and
+    // exit. Same stdio (logs keep flowing), same args/env (port, cwd, data
+    // dir…); the child waits for this port to free before binding.
+    setTimeout(() => {
+        console.log("update applied — spawning replacement…");
+        spawn(process.execPath, process.argv.slice(1), {
+            stdio: "inherit",
+            env: { ...process.env, [RESTART_CHILD_ENV]: "1" },
+            ...(process.platform === "win32" ? { windowsHide: true } : {}),
+        });
+        void shutdown();
+    }, 1500);
+    return true;
+}
+service.onUpdateReady = scheduleUpdateRestart;
 wss.on("connection", (ws) => {
     let clientId = null;
     let closed = false;
@@ -279,6 +326,29 @@ wss.on("connection", (ws) => {
             service.detach(clientId, send);
     });
 });
+// When spawned by the old process as an auto-restart replacement, wait for
+// the old instance to release the port before binding (it exits right after
+// spawning us). Probe by attempting a connection: refused = free.
+if (process.env[RESTART_CHILD_ENV] === "1") {
+    const deadline = Date.now() + 20_000;
+    const portFree = () => new Promise((resolve) => {
+        const sock = createConnection({ port: PORT, host: "127.0.0.1" });
+        sock.once("connect", () => {
+            sock.destroy();
+            resolve(false); // busy — old instance still up
+        });
+        sock.once("error", () => resolve(true)); // refused → free
+        sock.setTimeout(500, () => {
+            sock.destroy();
+            resolve(false);
+        });
+    });
+    while (Date.now() < deadline) {
+        if (await portFree())
+            break;
+        await new Promise((r) => setTimeout(r, 300));
+    }
+}
 httpServer.listen(PORT, () => {
     console.log("");
     console.log("  ⚡ pi-web-ui — web chat for the pi coding agent");

package/dist/server/terminals.js

@@ -137,7 +137,10 @@ function shellEnv() {
 // and node-pty throws the generic "posix_spawnp failed". Locally-built
 // copies (build/Release) are fine; every `npm install` that picks the prebuild
 // — e.g. `npm i -g pi-web-ui`, which is what system-service installs run — is
-// broken until the bit is restored. Self-heal at startup, best-effort.
+// broken until the bit is restored. Self-heal at startup AND lazily before
+// every spawn (an `npm i -g` while the server is running replaces the helper
+// under the running process, so the startup-only repair misses it).
+// Best-effort: a read-only node_modules just keeps the old failure.
 const require = createRequire(import.meta.url);
 /** Absolute paths of every node-pty spawn-helper this install can exec. */
 function spawnHelperPaths() {
@@ -294,6 +297,9 @@ export class TerminalManager {
             this.fail(id, `目录不存在：${abs}`);
             return false;
         }
+        // node-pty's spawn-helper may have lost its +x bit since the last repair
+        // (e.g. a global npm install replaced the helper while this server runs).
+        repairSpawnHelperPermissions();
         let pty;
         try {
             pty = spawn(SHELL, SHELL_ARGS, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-web-ui",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Web chat interface for the pi coding agent, powered by the pi SDK (@earendil-works/pi-coding-agent) — one-command run, Docker/systemd/launchd deployable",
   "license": "MIT",
   "type": "module",