mslxdff 0.1.11 → 0.1.13

package/bin/mslxdff.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
-import { readFileSync, existsSync, statSync, watch, openSync, closeSync, mkdirSync } from "node:fs";
+import { readFileSync, existsSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join, basename } from "node:path";
 import { startServer, resolvePort } from "../src/server.js";
+import { DEFAULT_PORT } from "../src/state.js";
 import { createRouter } from "../src/routes.js";
 import { createUpstreamClient } from "../src/upstream.js";
 import { createModelsService } from "../src/models.js";
@@ -11,8 +12,9 @@ import { loadToken, refreshToken, setPort, getPort, loadGroupsJoined, saveGroups
 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 { createEventBus } from "../src/events.js";
 import { createGroupsService, createBansService, refreshGroupMembers, syncPeersFromMembers } from "../src/groups.js";
-import { logDir, recentCalls, lastError, appendCall, appendError, appendEvent, eventsFile, recentEvents } from "../src/logs.js";
+import { logDir, recentCalls, lastError, appendCall, appendError, appendEvent, recentEvents } from "../src/logs.js";
 
 const logs = { appendCall, appendError, appendEvent };
 
@@ -130,11 +132,22 @@ if (args.includes("-model") || args.includes("-models")) {
   process.exit(0);
 }
 
-// -debug: live-follow the daemon's event stream (requests, upstream errors,
-// peer forwards, peer errors, results) for investigation
+// -debug: stop the background daemon and run the server in THIS terminal
+// (foreground), printing every event to stdout in real time via the in-memory
+// event bus — no filesystem polling. Ctrl+C / SIGTERM restarts the daemon in
+// the background, then exits. See the daemon body below for the stream wiring.
 if (args.includes("-debug") || args.includes("--debug")) {
-  await liveDebug();
-  process.exit(0);
+  const recent = recentEvents(100);
+  if (recent.length) {
+    console.log(`--- last ${recent.length} event(s) ---`);
+    for (const e of recent) console.log(fmtEvent(e));
+  }
+  console.log("--- live (Ctrl+C: stop debugging and restore background daemon) ---");
+  const { stopped, pid } = stopDaemon();
+  if (stopped) console.log(`[debug] stopped background daemon (pid ${pid})`);
+  process.env.MSLXDFF_DEBUG = "1";
+  process.env.MSLXDFF_DAEMON = "1";
+  // fall through to the daemon body below — no process.exit() here
 }
 
 // -creategroup <name> | -group create <name> | -group sync | -group leave <name> | -group list |
@@ -405,8 +418,34 @@ const peers = createPeersService({ cooldownMs: peerCooldownMs(), heatMs: peerHea
 const groups = createGroupsService({});
 const bans = createBansService({ windowMs: banWindowMs(), threshold: banThreshold() });
 
-const router = createRouter({ token, upstream, models, auto, logs, peers, maxHops: maxHopsValue(), groups, bans });
-const srv = startServer({ router });
+const isDebug = process.env.MSLXDFF_DEBUG === "1";
+const bus = createEventBus();
+const router = createRouter({ token, upstream, models, auto, logs, peers, maxHops: maxHopsValue(), groups, bans, bus });
+const srv = startServer({ router, signals: !isDebug });
+
+// -debug: push every event straight to this terminal.
+if (isDebug) {
+  bus.subscribe((e) => {
+    try {
+      console.log(fmtEvent(e));
+    } catch {
+      // malformed event — skip
+    }
+  });
+  // Ctrl+C / SIGTERM: restore the background daemon, then exit.
+  const restore = () => {
+    console.log("\n[debug] restoring background daemon...");
+    try {
+      const restoredPid = startDaemon([]);
+      console.log(`[debug] daemon restored (pid ${restoredPid})`);
+    } catch (err) {
+      console.error(`[debug] could not restore daemon: ${err.message}`);
+    }
+    setTimeout(() => process.exit(0), 300);
+  };
+  process.on("SIGINT", restore);
+  process.on("SIGTERM", restore);
+}
 
 await srv.ready();
 models.startAutoRefresh();
@@ -706,80 +745,8 @@ function fmtEvent(e) {
   }
 }
 
-// Live-follow the daemon's event stream: print the recent tail, then stream
-// new lines as they are appended (Ctrl+C to exit).
-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(dir, { recursive: true });
-      closeSync(openSync(file, "a"));
-    } catch {
-      console.error(`cannot create event file: ${file}`);
-      process.exit(1);
-    }
-  }
-  const recent = recentEvents(100);
-  if (recent.length) {
-    console.log(`--- last ${recent.length} event(s) ---`);
-    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 = () => {
-    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(dir, { recursive: true });
-    watch(dir, (_evt, filename) => {
-      if (!filename || basename(String(filename)) !== basename(file)) return;
-      pump();
-    });
-  } catch {
-    console.error(`cannot watch event dir: ${dir} (falling back to polling only)`);
-  }
-  // Poll is the source of truth; 200ms keeps human-perceived latency negligible.
-  setInterval(pump, 200);
-  pump();
-  await new Promise(() => {}); // run until Ctrl+C
-}
-
-function fmtTs(iso) {  if (!iso) return "-";
+function fmtTs(iso) {
+  if (!iso) return "-";
   try {
     return new Date(iso).toISOString().replace("T", " ").slice(5, 19);
   } catch {

package/package.json

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

package/src/daemon.js

@@ -24,10 +24,14 @@ export function startDaemon(args = []) {
   const dir = daemonDir();
   mkdirSync(dir, { recursive: true });
   const logFd = openSync(logFile(), "a", 0o600);
+  const env = { ...process.env, MSLXDFF_DAEMON: "1" };
+  // a -debug foreground session wouldn't pass MSLXDFF_DEBUG to the
+  // background daemon it restores (that flag means "print events to stdout")
+  delete env.MSLXDFF_DEBUG;
   const child = spawn(process.execPath, [entry, ...args, "--daemon"], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
-    env: { ...process.env, MSLXDFF_DAEMON: "1" },
+    env,
   });
   child.unref();
   return child.pid;

package/src/events.js

@@ -0,0 +1,39 @@
+// In-memory event bus for live debugging: routes.js emits, -debug streams
+// over HTTP. Keeps a small ring buffer so late subscribers can catch up.
+
+const MAX_BUFFERED = 500;
+
+export function createEventBus() {
+  let buffer = [];
+  const listeners = new Set();
+
+  return {
+    // emit an event to every current subscriber (sync, never throws)
+    emit(event) {
+      buffer.push(event);
+      if (buffer.length > MAX_BUFFERED) buffer.splice(0, buffer.length - MAX_BUFFERED);
+      for (const fn of listeners) {
+        try {
+          fn(event);
+        } catch {
+          // subscriber errors must never break the request path
+        }
+      }
+    },
+    // subscribe; returns an unsubscribe fn
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    // buffered events since start (or from offset), consumed left-to-right
+    replay({ since = 0 } = {}) {
+      return buffer.slice(since);
+    },
+    replayAll() {
+      return buffer.slice();
+    },
+    size() {
+      return buffer.length;
+    },
+  };
+}

package/src/routes.js

@@ -6,12 +6,13 @@ import { DEFAULT_MAX_HOPS } from "./peers.js";
 
 export const errMsg = (err) => String(err?.message || err);
 
-export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans }) {
+export function createRouter({ token, upstream, models, auto, logs, peers, maxHops = DEFAULT_MAX_HOPS, groups, bans, bus }) {
   return async function router(req, res) {
     const method = req.method || "GET";
     const path = (req.url || "").split("?")[0];
 
     const route = ROUTES.find((r) => r.method === method && r.path === path);
+
     if (!route) return notFound(res);
 
     if (route.requiresAuth && !authorized(req, token)) {
@@ -20,7 +21,7 @@ export function createRouter({ token, upstream, models, auto, logs, peers, maxHo
       return json(res, 401, { error: "Unauthorized" });
     }
 
-    await route.handler({ req, res, upstream, models, auto, logs, peers, maxHops, groups, bans, token });
+    await route.handler({ req, res, upstream, models, auto, logs, peers, maxHops, groups, bans, token, bus });
   };
 }
 
@@ -175,7 +176,7 @@ const ROUTES = [
     method: "POST",
     path: "/v1/chat/completions",
     requiresAuth: true,
-    handler: async ({ req, res, upstream, auto, logs, peers, maxHops }) => {
+    handler: async ({ req, res, upstream, auto, logs, peers, maxHops, bus }) => {
       let body;
       try {
         body = await readBody(req);
@@ -205,7 +206,11 @@ const ROUTES = [
         logs?.appendCall({ model, auto: useAuto, status, durationMs: Date.now() - startedAt, stream: Boolean(body.stream) });
       const logError = (model, status, message) =>
         logs?.appendError({ model, auto: useAuto, status, message });
-      const evt = (type, data) => logs?.appendEvent?.({ type, ...data, model: data.model ?? requested, auto: useAuto, durationMs: Date.now() - startedAt });
+      const evt = (type, data) => {
+        const entry = { ts: Date.now(), type, ...data, model: data.model ?? requested, auto: useAuto, durationMs: Date.now() - startedAt };
+        if (bus) bus.emit(entry);
+        logs?.appendEvent?.(entry);
+      };
       evt("request", { hops, ip: clientIp(req), stream: Boolean(body.stream), prompt: summarizePrompt(body) });
 
       let lastErr = null;

package/src/server.js

@@ -1,7 +1,7 @@
 import { createServer as httpCreateServer } from "node:http";
 import { DEFAULT_PORT, getPort } from "./state.js";
 
-export function startServer({ router }, port = resolvePort()) {
+export function startServer({ router, signals = true }, port = resolvePort()) {
   const server = httpCreateServer((req, res) => {
     router(req, res).catch((err) => {
       res.statusCode = 500;
@@ -19,10 +19,15 @@ export function startServer({ router }, port = resolvePort()) {
   const close = () =>
     new Promise((resolve) => {
       server.close(resolve);
+      // SSE debug streams keep connections open — force-close so shutdown
+      // never waits on them.
+      server.closeAllConnections?.();
     });
 
-  process.on("SIGINT", close);
-  process.on("SIGTERM", close);
+  if (signals) {
+    process.on("SIGINT", close);
+    process.on("SIGTERM", close);
+  }
 
   return { server, ready, close };
 }