@seqyuan/annovibe 0.8.12 → 0.8.14

package/bin/pi-web.js

@@ -12,6 +12,10 @@ const fs = require("fs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const os = require("os");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
+const http = require("http");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const net = require("net");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const readline = require("readline");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const { parseArgs } = require("util");
@@ -19,6 +23,8 @@ const { parseArgs } = require("util");
 const bcrypt = require("bcryptjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const https = require("https");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { randomBytes } = require("crypto");
 
 const pkgDir = path.join(__dirname, "..");
 const nextDir = path.join(pkgDir, ".next");
@@ -35,6 +41,12 @@ const STOP_TERM_TIMEOUT_MS = 6000;
 const STOP_KILL_TIMEOUT_MS = 2000;
 const PROCESS_TITLE = "annovibe";
 const NEXT_PROCESS_TITLE = "annovibe-next";
+const AUTO_RESTART_ENABLED = !/^(0|false|no)$/i.test(process.env.ANNOVIBE_AUTO_RESTART ?? "1");
+const AUTO_RESTART_POLL_MS = parsePositiveInt(process.env.ANNOVIBE_AUTO_RESTART_POLL_MS, 60_000);
+const AUTO_RESTART_IDLE_GRACE_MS = parsePositiveInt(process.env.ANNOVIBE_AUTO_RESTART_IDLE_GRACE_MS, 10_000);
+const AUTO_RESTART_MAX_WAIT_MS = parsePositiveInt(process.env.ANNOVIBE_AUTO_RESTART_MAX_WAIT_MS, 30 * 60_000);
+const AUTO_RESTART_WAIT_FOR_PORT_MS = parsePositiveInt(process.env.ANNOVIBE_AUTO_RESTART_WAIT_FOR_PORT_MS, 30_000);
+const INTERNAL_RUNTIME_TIMEOUT_MS = 3000;
 
 // Resolve next's CLI entry
 let nextBin;
@@ -79,10 +91,132 @@ function getUrl(host, listenPort) {
   return `http://${host ?? "localhost"}:${listenPort}`;
 }
 
+function getServerArgs() {
+  return [getCommandPath(), "__server", "--port", String(port), ...(hostname ? ["--hostname", hostname] : [])];
+}
+
+function getServerCommand() {
+  return `${getCommandPath()} __server --port ${port}${hostname ? ` --hostname ${hostname}` : ""}`;
+}
+
 function nowIso() {
   return new Date().toISOString();
 }
 
+function parsePositiveInt(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readPackageVersion(packageDir) {
+  try {
+    const installedPkg = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf8"));
+    return typeof installedPkg.version === "string" ? installedPkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+function getInstalledPackageDir() {
+  try {
+    return path.resolve(path.dirname(fs.realpathSync(getCommandPath())), "..");
+  } catch {
+    return pkgDir;
+  }
+}
+
+function readInstalledVersion() {
+  const dirs = [getInstalledPackageDir(), pkgDir];
+  for (const dir of dirs) {
+    const version = readPackageVersion(dir);
+    if (version) return version;
+  }
+  return null;
+}
+
+function getRuntimeConnectHost(host) {
+  if (!host || host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::" || host === "[::]") return "::1";
+  return String(host).replace(/^\[(.*)\]$/, "$1");
+}
+
+function canBindPort(listenPort, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    let settled = false;
+    const done = (available) => {
+      if (settled) return;
+      settled = true;
+      resolve(available);
+    };
+    server.unref();
+    server.once("error", () => done(false));
+    server.once("listening", () => {
+      server.close(() => done(true));
+    });
+    server.listen(Number(listenPort), host ? String(host) : undefined);
+  });
+}
+
+async function waitForPortAvailable(listenPort, host, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (await canBindPort(listenPort, host)) return true;
+    await sleep(250);
+  }
+  return canBindPort(listenPort, host);
+}
+
+function fetchRuntimeStatus(internalToken) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      resolve(status);
+    };
+    const req = http.request({
+      hostname: getRuntimeConnectHost(hostname),
+      port: Number(port),
+      path: "/api/internal/runtime",
+      method: "GET",
+      timeout: INTERNAL_RUNTIME_TIMEOUT_MS,
+      headers: {
+        "x-annovibe-internal-token": internalToken,
+      },
+    }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        finish(null);
+        return;
+      }
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        data += chunk;
+        if (data.length > 1024 * 1024) req.destroy();
+      });
+      res.on("end", () => {
+        try {
+          finish(JSON.parse(data));
+        } catch {
+          finish(null);
+        }
+      });
+    });
+    req.on("error", () => finish(null));
+    req.on("timeout", () => {
+      req.destroy();
+      finish(null);
+    });
+    req.end();
+  });
+}
+
 function setStableProcessTitle(title) {
   process.title = title;
   try {
@@ -338,6 +472,10 @@ function renderState(state, json = false) {
     supervisorPid: supervisorAlive ? state.supervisorPid : null,
     nextPid: nextAlive ? state.nextPid : null,
     startedAt: supervisorAlive ? state.startedAt ?? null : null,
+    restartPending: !!state?.restartPending,
+    installedVersion: state?.installedVersion ?? null,
+    restartDetectedAt: state?.restartDetectedAt ?? null,
+    restartStartedAt: state?.restartStartedAt ?? null,
     logFile,
     stateFile,
   };
@@ -357,6 +495,9 @@ function renderState(state, json = false) {
     `supervisor pid: ${payload.supervisorPid ?? "not running"}`,
     `next pid: ${payload.nextPid ?? "unknown"}`,
     `started: ${payload.startedAt ?? "unknown"}`,
+    ...(payload.restartPending ? [
+      `restart: pending${payload.installedVersion ? ` for v${payload.installedVersion}` : ""}`,
+    ] : []),
     `log: ${payload.logFile}`,
   ].join("\n");
 }
@@ -433,17 +574,7 @@ async function startManagedServer({ quiet = false } = {}) {
     removeState();
   }
   ensureAgentDir();
-  const fd = fs.openSync(logFile, "a");
-  const child = spawn(process.execPath, [getCommandPath(), "__server", "--port", String(port), ...(hostname ? ["--hostname", hostname] : [])], {
-    cwd: pkgDir,
-    detached: true,
-    stdio: ["ignore", fd, fd],
-    env: {
-      ...process.env,
-      ANNOVIBE_MANAGED: "1",
-    },
-  });
-  fs.closeSync(fd);
+  const child = spawnDetachedServer();
   if (!child.pid) {
     throw new Error("failed to start annovibe server");
   }
@@ -451,7 +582,7 @@ async function startManagedServer({ quiet = false } = {}) {
   const state = {
     schemaVersion: 1,
     version: VERSION,
-    command: `${getCommandPath()} __server --port ${port}${hostname ? ` --hostname ${hostname}` : ""}`,
+    command: getServerCommand(),
     supervisorPid: child.pid,
     nextPid: null,
     port: String(port),
@@ -470,6 +601,23 @@ async function startManagedServer({ quiet = false } = {}) {
   return 0;
 }
 
+function spawnDetachedServer(extraEnv = {}) {
+  ensureAgentDir();
+  const fd = fs.openSync(logFile, "a");
+  const child = spawn(process.execPath, getServerArgs(), {
+    cwd: fs.existsSync(getInstalledPackageDir()) ? getInstalledPackageDir() : pkgDir,
+    detached: true,
+    stdio: ["ignore", fd, fd],
+    env: {
+      ...process.env,
+      ANNOVIBE_MANAGED: "1",
+      ...extraEnv,
+    },
+  });
+  fs.closeSync(fd);
+  return child;
+}
+
 if (cliArgs.version) {
   console.log(VERSION);
   process.exit(0);
@@ -500,6 +648,7 @@ Options:
 Environment:
   PORT                  Server port
   ANNOVIBE_PASSWORD     Set password on first start
+  ANNOVIBE_AUTO_RESTART Set 0/false/no to disable idle auto-restart after update
   PI_CODING_AGENT_DIR   Custom pi agent data directory
 `);
   process.exit(0);
@@ -718,6 +867,115 @@ function openBrowser(url) {
   openChild.unref();
 }
 
+function startAutoRestartWatcher({ child, internalToken, writeCurrentState, markRestarting }) {
+  if (!AUTO_RESTART_ENABLED) return () => {};
+
+  let pending = null;
+  let idleSince = null;
+  let restarting = false;
+  let lastWaitLogAt = 0;
+
+  const poll = async () => {
+    if (restarting) return;
+    const installedVersion = readInstalledVersion();
+    if (!installedVersion || installedVersion === VERSION) {
+      if (pending) {
+        pending = null;
+        idleSince = null;
+        writeCurrentState({ restartPending: false, installedVersion: null, restartDetectedAt: null, restartStartedAt: null });
+      }
+      return;
+    }
+
+    if (!pending || pending.installedVersion !== installedVersion) {
+      pending = {
+        installedVersion,
+        detectedAt: nowIso(),
+        detectedAtMs: Date.now(),
+      };
+      idleSince = null;
+      lastWaitLogAt = 0;
+      console.log(`annovibe auto-restart: detected installed version ${installedVersion}; current runtime is ${VERSION}`);
+      writeCurrentState({
+        restartPending: true,
+        installedVersion,
+        restartDetectedAt: pending.detectedAt,
+      });
+    }
+
+    const status = await fetchRuntimeStatus(internalToken);
+    if (!status || typeof status.busy !== "boolean") {
+      idleSince = null;
+      if (Date.now() - lastWaitLogAt >= 5 * 60_000) {
+        lastWaitLogAt = Date.now();
+        console.log("annovibe auto-restart: waiting for runtime status before restarting");
+      }
+      return;
+    }
+
+    if (status.busy) {
+      idleSince = null;
+      const waitedMs = Date.now() - pending.detectedAtMs;
+      if (Date.now() - lastWaitLogAt >= 5 * 60_000) {
+        lastWaitLogAt = Date.now();
+        const busyCount = Array.isArray(status.busySessions) ? status.busySessions.length : 0;
+        const suffix = waitedMs >= AUTO_RESTART_MAX_WAIT_MS ? "; max wait reached, still waiting for graceful idle" : "";
+        console.log(`annovibe auto-restart: update pending, waiting for ${busyCount} busy session${busyCount === 1 ? "" : "s"}${suffix}`);
+      }
+      return;
+    }
+
+    idleSince ??= Date.now();
+    if (Date.now() - idleSince < AUTO_RESTART_IDLE_GRACE_MS) return;
+
+    restarting = true;
+    let replacement;
+    try {
+      replacement = spawnDetachedServer({
+        ANNOVIBE_NO_OPEN: "1",
+        ANNOVIBE_WAIT_FOR_PORT: "1",
+      });
+    } catch (error) {
+      console.error(`annovibe auto-restart: failed to start replacement supervisor: ${error instanceof Error ? error.message : String(error)}`);
+      restarting = false;
+      return;
+    }
+    if (!replacement.pid) {
+      console.error("annovibe auto-restart: failed to start replacement supervisor");
+      restarting = false;
+      return;
+    }
+    markRestarting();
+    writeCurrentState({
+      restartPending: true,
+      installedVersion: pending.installedVersion,
+      restartDetectedAt: pending.detectedAt,
+      restartStartedAt: nowIso(),
+    });
+    console.log(`annovibe auto-restart: installed ${VERSION} -> ${pending.installedVersion}; restarting now`);
+    replacement.unref();
+    console.log(`annovibe auto-restart: replacement supervisor pid ${replacement.pid}`);
+
+    if (!(await terminatePid(child.pid))) {
+      console.error(`annovibe auto-restart: failed to stop old next pid ${child.pid}`);
+      restarting = false;
+      markRestarting(false);
+      return;
+    }
+    process.exit(0);
+  };
+
+  const timer = setInterval(() => {
+    poll().catch((error) => {
+      console.error(`annovibe auto-restart: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }, AUTO_RESTART_POLL_MS);
+  timer.unref();
+
+  poll().catch(() => {});
+  return () => clearInterval(timer);
+}
+
 async function runServerProcess() {
   setStableProcessTitle(PROCESS_TITLE);
   await maybeSetupAuth();
@@ -728,26 +986,37 @@ async function runServerProcess() {
 
   checkVersion();
 
+  if (process.env.ANNOVIBE_WAIT_FOR_PORT === "1") {
+    const available = await waitForPortAvailable(port, hostname, AUTO_RESTART_WAIT_FOR_PORT_MS);
+    if (!available) {
+      console.error(`annovibe server: port ${port} was not released within ${AUTO_RESTART_WAIT_FOR_PORT_MS}ms`);
+      process.exit(1);
+    }
+  }
+
   const url = getUrl(hostname, port);
   const nextArgs = [getCommandPath(), "__next", "--port", String(port)];
   if (hostname) nextArgs.push("--hostname", hostname);
+  const internalToken = process.env.ANNOVIBE_INTERNAL_TOKEN || randomBytes(24).toString("hex");
 
   const child = spawn(process.execPath, nextArgs, {
     cwd: pkgDir,
     stdio: ["ignore", "pipe", "pipe"],
     env: {
       ...process.env,
+      ANNOVIBE_INTERNAL_TOKEN: internalToken,
       ANNOVIBE_SUPERVISOR_PID: String(process.pid),
       ANNOVIBE_NEXT_WRAPPER: "1",
     },
   });
+  let restarting = false;
 
   const writeCurrentState = (patch = {}) => {
     const current = readState() ?? {};
     writeState({
       schemaVersion: 1,
       version: VERSION,
-      command: `${getCommandPath()} __server --port ${port}${hostname ? ` --hostname ${hostname}` : ""}`,
+      command: getServerCommand(),
       supervisorPid: process.pid,
       nextPid: child.pid ?? null,
       port: String(port),
@@ -761,6 +1030,12 @@ async function runServerProcess() {
   };
 
   writeCurrentState();
+  const stopAutoRestartWatcher = startAutoRestartWatcher({
+    child,
+    internalToken,
+    writeCurrentState,
+    markRestarting: (value = true) => { restarting = value; },
+  });
 
   let browserOpened = false;
   child.stdout.on("data", (chunk) => {
@@ -768,7 +1043,7 @@ async function runServerProcess() {
     process.stdout.write(text);
     if (!browserOpened && text.includes("Ready")) {
       browserOpened = true;
-      openBrowser(url);
+      if (process.env.ANNOVIBE_NO_OPEN !== "1") openBrowser(url);
       console.log(`\n   annovibe running at ${url}\n`);
       writeCurrentState({ readyAt: nowIso() });
     }
@@ -776,15 +1051,17 @@ async function runServerProcess() {
   child.stderr.on("data", (chunk) => process.stderr.write(chunk));
 
   const shutdown = async () => {
+    stopAutoRestartWatcher();
     await terminatePid(child.pid);
-    removeState();
+    if (!restarting) removeState();
     process.exit(0);
   };
   process.on("SIGTERM", () => { void shutdown(); });
   process.on("SIGINT", () => { void shutdown(); });
 
   child.on("exit", (code) => {
-    removeState();
+    stopAutoRestartWatcher();
+    if (!restarting) removeState();
     process.exit(code ?? 0);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seqyuan/annovibe",
-  "version": "0.8.12",
+  "version": "0.8.14",
   "description": "AI-native bioinformatics workspace by Annoroad",
   "license": "MIT",
   "bin": {