@datafrog-io/n2n-nexus 0.3.3 → 0.3.4

package/build/config.js

@@ -15,7 +15,7 @@ const getArg = (k) => {
 const hasFlag = (k) => args.includes(k) || args.includes(k.charAt(1) === "-" ? k : k.substring(0, 2));
 // --- CLI Commands Handlers ---
 if (hasFlag("--help") || hasFlag("-h")) {
-    console.log(`
+    console.error(`
 n2ns Nexus 🚀 - Local Digital Asset Hub (MCP Server) v${pkg.version}
 
 USAGE:
@@ -46,7 +46,7 @@ ENVIRONMENT VARIABLES:
     process.exit(0);
 }
 if (hasFlag("--version") || hasFlag("-v")) {
-    console.log(pkg.version);
+    console.error(pkg.version);
     process.exit(0);
 }
 // --- Path Normalization Logic ---
@@ -80,15 +80,33 @@ function getDefaultDataDir() {
 /**
  * Probe a port to see if it's a Nexus Host
  */
-async function probeHost(port) {
+/**
+ * Probe a port to see if it's a Nexus Host using the Custom Handshake Protocol
+ */
+async function probeHost(port, myId) {
     return new Promise((resolve) => {
-        const req = http.get(`http://127.0.0.1:${port}/hello`, { timeout: 500 }, (res) => {
+        const postData = JSON.stringify({
+            clientVersion: pkg.version,
+            instanceId: myId
+        });
+        const req = http.request({
+            hostname: "127.0.0.1",
+            port: port,
+            path: "/nexus/handshake",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(postData)
+            },
+            timeout: 500
+        }, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk);
             res.on("end", () => {
                 try {
                     const info = JSON.parse(data);
                     if (info.service === "n2n-nexus" && info.role === "host") {
+                        // console.error(`[Nexus Handshake] Connected to Host v${info.serverVersion} (Protocol ${info.protocol})`);
                         resolve({ isNexus: true, rootStorage: info.rootStorage });
                     }
                     else {
@@ -105,6 +123,8 @@ async function probeHost(port) {
             req.destroy();
             resolve({ isNexus: false });
         });
+        req.write(postData);
+        req.end();
     });
 }
 /**
@@ -124,11 +144,12 @@ async function isHostAutoElection(root) {
     while (true) {
         // Phase 1: Probe-First - Check if any Host already exists (Concurrent Batch Scan)
         const BATCH_SIZE = 20;
+        const myId = getArg("--id") || `candidate-${Math.random().toString(36).substring(2, 6)}`;
         for (let batchStart = startPort; batchStart <= endPort; batchStart += BATCH_SIZE) {
             const batchEnd = Math.min(batchStart + BATCH_SIZE - 1, endPort);
             const promises = [];
             for (let port = batchStart; port <= batchEnd; port++) {
-                promises.push(probeHost(port).then(res => ({ port, ...res })));
+                promises.push(probeHost(port, myId).then(res => ({ port, ...res })));
             }
             const results = await Promise.all(promises);
             const found = results.find(r => r.isNexus);
@@ -140,26 +161,33 @@ async function isHostAutoElection(root) {
         for (let port = startPort; port <= endPort; port++) {
             const result = await new Promise((resolve) => {
                 const server = http.createServer((req, res) => {
-                    if (req.url === "/hello") {
-                        res.writeHead(200, { "Content-Type": "application/json" });
-                        res.end(JSON.stringify({
-                            service: "n2n-nexus",
-                            role: "host",
-                            version: pkg.version,
-                            rootStorage: root
-                        }));
+                    // HANDSHAKE ENDPOINT
+                    if (req.method === "POST" && req.url === "/nexus/handshake") {
+                        let body = "";
+                        req.on("data", chunk => body += chunk);
+                        req.on("end", () => {
+                            try {
+                                const _clientInfo = JSON.parse(body);
+                                // console.error(`[Nexus Handshake] Client connected: ${_clientInfo.instanceId} (v${_clientInfo.clientVersion})`);
+                            }
+                            catch { /* ignore malformed */ }
+                            res.writeHead(200, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({
+                                service: "n2n-nexus",
+                                protocol: "v1", // Nexus Handshake Protocol v1
+                                role: "host",
+                                serverVersion: pkg.version,
+                                rootStorage: root,
+                                status: "ready"
+                            }));
+                        });
                         return;
                     }
                     res.writeHead(404);
                     res.end();
                 });
-                server.on("error", (err) => {
-                    if (err.code === "EADDRINUSE") {
-                        resolve({ isHost: false });
-                    }
-                    else {
-                        resolve({ isHost: false });
-                    }
+                server.on("error", (_err) => {
+                    resolve({ isHost: false });
                 });
                 server.listen(port, "0.0.0.0", () => {
                     resolve({ isHost: true, server });
@@ -169,18 +197,16 @@ async function isHostAutoElection(root) {
                 return { isHost: true, port, server: result.server };
             }
             // Phase 3: Bind failed - another Guest won. Wait then join winner.
-            await new Promise(r => setTimeout(r, 10000)); // Give winner 10s to start /hello
-            const probe = await probeHost(port);
+            await new Promise(r => setTimeout(r, 2000)); // Short wait for winner to stabilize
+            const probe = await probeHost(port, myId);
             if (probe.isNexus) {
                 return { isHost: false, port, rootStorage: probe.rootStorage };
             }
-            // If still not Nexus, try next port (occupied by non-Nexus service)
+            // If still not Nexus, try next port
         }
         // Fallback: All ports occupied - progressive backoff retry
-        // First 5 attempts: 1 minute interval, then 2 minute interval
-        const waitTime = retryCount < 5 ? 60000 : 120000;
-        const intervalStr = retryCount < 5 ? "1 minute" : "2 minutes";
-        console.error(`[Nexus] All ports ${startPort}-${endPort} occupied. Retry #${retryCount + 1} in ${intervalStr}...`);
+        const waitTime = retryCount < 5 ? 5000 : 30000;
+        console.error(`[Nexus] All ports ${startPort}-${endPort} occupied. Retry #${retryCount + 1} in ${waitTime / 1000}s...`);
         await new Promise(r => setTimeout(r, waitTime));
         retryCount++;
     }

package/build/index.js

@@ -141,6 +141,16 @@ class NexusServer {
             catch { /* ignore */ }
             process.exit(0);
         };
+        // Global Error Handlers to prevent process exit on background errors
+        process.on("uncaughtException", (err) => {
+            console.error("[Nexus CRITICAL] Uncaught Exception:", err);
+            // Attempt to log to disk if possible, but keep process alive if safe
+            // For a Hub, staying alive is often preferred over crashing
+        });
+        process.on("unhandledRejection", (reason, promise) => {
+            console.error("[Nexus WARNING] Unhandled Rejection at:", promise, "reason:", reason);
+            // Do not exit. Background tasks (like file sync) often trigger this.
+        });
         process.on("SIGINT", () => shutdown("SIGINT"));
         process.on("SIGTERM", () => shutdown("SIGTERM"));
         if (CONFIG.isHost && hostServer) {
@@ -262,7 +272,7 @@ class NexusServer {
                                 try {
                                     process.stdout.write(dataLine.substring(6) + "\n");
                                 }
-                                catch { }
+                                catch { /* ignore stdout errors */ }
                             }
                         }
                     });

package/build/storage/index.js

@@ -13,7 +13,10 @@ export class StorageManager {
     static get projectsRoot() { return path.join(CONFIG.rootStorage, "projects"); }
     static get registryFile() { return path.join(CONFIG.rootStorage, "registry.json"); }
     static get archivesDir() { return path.join(CONFIG.rootStorage, "archives"); }
+    static initialized = false;
     static async init() {
+        if (this.initialized)
+            return;
         await fs.mkdir(CONFIG.rootStorage, { recursive: true });
         await fs.mkdir(this.globalDir, { recursive: true });
         await fs.mkdir(this.projectsRoot, { recursive: true });
@@ -32,6 +35,10 @@ export class StorageManager {
         catch {
             // SQLite may not be available or database not ready - will be initialized on first use
         }
+        this.initialized = true;
+    }
+    static resetInit() {
+        this.initialized = false;
     }
     /**
      * Proactively reads and validates JSON.

package/build/storage/tasks.js

@@ -11,10 +11,13 @@ function generateTaskId() {
     const random = Math.random().toString(36).substring(2, 6);
     return `task_${timestamp}_${random}`;
 }
+let initialized = false;
 /**
  * Initialize the tasks table (run migrations)
  */
 export function initTasksTable() {
+    if (initialized)
+        return;
     const db = getDatabase();
     const TASKS_SCHEMA = `
     CREATE TABLE IF NOT EXISTS tasks (
@@ -50,6 +53,10 @@ export function initTasksTable() {
         // Trigger may already exist in older SQLite versions without IF NOT EXISTS support
     }
     console.error("[Nexus] Tasks table initialized");
+    initialized = true;
+}
+export function resetTasksInit() {
+    initialized = false;
 }
 /**
  * Create a new task

package/docs/CHANGELOG_zh.md

@@ -2,6 +2,14 @@
 
 本项目的所有重大变更都将记录在此文件中。
 
+## [0.3.4] - 2026-01-10
+### 协议与稳定性
+- **新握手协议**: 引入 `POST /nexus/handshake` 替代旧版 `/hello`。支持严格的客户端/服务端版本校验和稳健的 Host 探测。
+- **全局错误安全网**: 增加了 `uncaughtException` 和 `unhandledRejection` 处理器，防止后台任务错误导致进程退出，确保 Hub 的高可用性。
+- **修复 (EOF 错误)**: 解决了由于 SQLite 非幂等初始化导致的“连接关闭：EOF”崩溃问题。
+- **修复 (僵尸 Host)**: 改进了 Guest 的 Host检测逻辑，消除了死循环重试。
+- **测试覆盖**: 新增 `guest_connection.test.ts` 验证 Guest-Host SSE 集成。
+
 ## [0.3.3] - 2026-01-10
 ### 🔄 零配置持久化 (Zero-Config Persistence)
 - **支持 XDG Base Directory**: 将存储位置从不稳定的 `node_modules` 迁移至系统标准的 User Data 路径：

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datafrog-io/n2n-nexus",
-    "version": "0.3.3",
+    "version": "0.3.4",
     "description": "Modular MCP Server for multi-AI assistant coordination",
     "main": "build/index.js",
     "type": "module",