mslxdff 0.1.9 → 0.1.11

package/bin/mslxdff.js

@@ -8,7 +8,7 @@ import { createRouter } from "../src/routes.js";
 import { createUpstreamClient } from "../src/upstream.js";
 import { createModelsService } from "../src/models.js";
 import { loadToken, refreshToken, setPort, getPort, loadGroupsJoined, saveGroupsJoined, loadModelErrors } from "../src/state.js";
-import { startDaemon, stopDaemon, writePid, pidFile, logFile, readPid } from "../src/daemon.js";
+import { startDaemon, stopDaemon, writePid, pidFile, logFile, readPid, readPidVersion, isPidAlive } from "../src/daemon.js";
 import { createAutoSelector } from "../src/auto.js";
 import { createPeersService } from "../src/peers.js";
 import { createGroupsService, createBansService, refreshGroupMembers, syncPeersFromMembers } from "../src/groups.js";
@@ -303,6 +303,26 @@ async function syncAllJoinedGroups({ peers, groups }) {
   return results;
 }
 
+// Upgrade-aware handling of a running daemon: keep it when it already runs
+// our version, otherwise stop it so the spawn below takes over. Cleans up
+// stale pid files (daemon died without -stop).
+function stopDaemonIfOutdated() {
+  const pid = readPid();
+  if (!pid) return;
+  if (!isPidAlive(pid)) {
+    console.log(`daemon pid ${pid} is stale (not running) — starting fresh`);
+    return;
+  }
+  const runningVersion = readPidVersion();
+  if (runningVersion === VERSION) return;
+  console.log(
+    runningVersion
+      ? `daemon running v${runningVersion} — upgrading to v${VERSION}, restarting...`
+      : `daemon version unknown — restarting with v${VERSION}...`
+  );
+  stopDaemon();
+}
+
 // -port N: persist the port, then restart the daemon on it if one is running.
 // Skip when we ARE the daemon child (it already carries the port via args).
 const portArg = argValue("-port", "--port");
@@ -330,6 +350,7 @@ if (args.includes("-d") || args.includes("--daemon")) {
   if (!process.env.MSLXDFF_DAEMON) {
     // foreground: spawn the detached background instance, then wait for health
     const port = effectivePort();
+    stopDaemonIfOutdated();
     const spawnedPid = startDaemon(args.filter((a) => a !== "-d" && a !== "--daemon"));
     await waitForHealth(port, 4000);
     console.log(`mslxdff daemon started (pid ${spawnedPid})`);
@@ -343,12 +364,14 @@ if (args.includes("-d") || args.includes("--daemon")) {
 // Bare run: show status + help when the daemon is already up; otherwise spawn it
 // as a background daemon and exit — never holds the terminal (npx-friendly).
 if (!process.env.MSLXDFF_DAEMON) {
-  if (readPid()) {
+  const pid = readPid();
+  if (pid && isPidAlive(pid) && readPidVersion() === VERSION) {
     await printStatus();
     printHelp();
     process.exit(0);
   }
   const port = effectivePort();
+  stopDaemonIfOutdated();
   const spawnedPid = startDaemon([]);
   await waitForHealth(port, 4000);
   console.log(`mslxdff v${VERSION} started as a background daemon (pid ${spawnedPid})`);
@@ -388,7 +411,7 @@ const srv = startServer({ router });
 await srv.ready();
 models.startAutoRefresh();
 if (process.env.MSLXDFF_DAEMON) {
-  writePid(process.pid);
+  writePid(process.pid, VERSION);
 }
 const addr = srv.server.address();
 const host = addr.address === "0.0.0.0" || addr.address === "::" ? "localhost" : addr.address;
@@ -688,9 +711,10 @@ function fmtEvent(e) {
 async function liveDebug() {
   const file = eventsFile();
   // ensure the event file exists so watch() doesn't fail on a fresh daemon dir
+  const dir = dirname(file);
   if (!existsSync(file)) {
     try {
-      mkdirSync(dirname(file), { recursive: true });
+      mkdirSync(dir, { recursive: true });
       closeSync(openSync(file, "a"));
     } catch {
       console.error(`cannot create event file: ${file}`);
@@ -703,48 +727,54 @@ async function liveDebug() {
     for (const e of recent) console.log(fmtEvent(e));
   }
   console.log("--- live (Ctrl+C to exit) ---");
+  console.log(`watching: ${file}`);
   if (!existsSync(file)) console.log("(no events yet — trigger a chat request to see the flow)");
 
   let pos = existsSync(file) ? statSync(file).size : 0;
   let buf = "";
   const pump = () => {
-    if (!existsSync(file)) {
-      pos = 0;
-      buf = "";
-      return;
-    }
-    const size = statSync(file).size;
-    if (size < pos) {
-      pos = 0; // file trimmed/rewritten: re-follow from the start of what remains
-      buf = "";
-    }
-    if (size === pos) return;
-    buf += readFileSync(file, "utf8").slice(pos);
-    pos = size;
-    const lines = buf.split("\n");
-    buf = lines.pop() || "";
-    for (const l of lines) {
-      if (!l.trim()) continue;
-      try {
-        console.log(fmtEvent(JSON.parse(l)));
-      } catch {
-        // partial/corrupt line while trimming — skip
+    try {
+      if (!existsSync(file)) {
+        pos = 0;
+        buf = "";
+        return;
+      }
+      const size = statSync(file).size;
+      if (size < pos) {
+        pos = 0; // file trimmed/rewritten: re-follow from the start of what remains
+        buf = "";
       }
+      if (size === pos) return;
+      buf += readFileSync(file, "utf8").slice(pos);
+      pos = size;
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (const l of lines) {
+        if (!l.trim()) continue;
+        try {
+          console.log(fmtEvent(JSON.parse(l)));
+        } catch {
+          // partial/corrupt line while trimming — skip
+        }
+      }
+    } catch (err) {
+      console.error(`[debug] poll error: ${err.message}`);
     }
   };
+  // fs.watch is unreliable across platforms for freshly-created/rotated files,
+  // so polling is the source of truth (200ms); the directory watch just adds
+  // low-latency wake-ups and silently degrades when it misbehaves.
   try {
-    mkdirSync(dirname(file), { recursive: true });
-    watch(dirname(file), (_evt, filename) => {
+    mkdirSync(dir, { recursive: true });
+    watch(dir, (_evt, filename) => {
       if (!filename || basename(String(filename)) !== basename(file)) return;
       pump();
     });
   } catch {
-    console.error(`cannot watch event dir: ${dirname(file)}`);
-    process.exit(1);
+    console.error(`cannot watch event dir: ${dir} (falling back to polling only)`);
   }
-  // fs.watch is unreliable for freshly-created files on Windows — poll as a
-  // safety net so events are never missed.
-  setInterval(pump, 250);
+  // Poll is the source of truth; 200ms keeps human-perceived latency negligible.
+  setInterval(pump, 200);
   pump();
   await new Promise(() => {}); // run until Ctrl+C
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/daemon.js

@@ -33,19 +33,36 @@ export function startDaemon(args = []) {
   return child.pid;
 }
 
-export function writePid(pid) {
+export function writePid(pid, version) {
   const dir = daemonDir();
   mkdirSync(dir, { recursive: true });
-  writeFileSync(pidFile(), String(pid), { mode: 0o600 });
+  writeFileSync(pidFile(), version ? `${pid}\n${version}` : String(pid), { mode: 0o600 });
 }
 
 export function readPid() {
   if (!existsSync(pidFile())) return null;
   const raw = readFileSync(pidFile(), "utf8").trim();
-  const n = Number(raw);
+  const n = Number(raw.split("\n")[0]);
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
+export function readPidVersion() {
+  if (!existsSync(pidFile())) return null;
+  const raw = readFileSync(pidFile(), "utf8");
+  const lines = raw.split("\n");
+  return lines.length > 1 && lines[1].trim() ? lines[1].trim() : null;
+}
+
+// Best-effort liveness check (signal 0); ESRCH means the process is gone.
+export function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+
 export function stopDaemon() {
   const pid = readPid();
   if (!pid) return { stopped: false, reason: "no pid file" };