@datafrog-io/n2n-nexus 0.3.7 → 0.4.0

package/README.md

@@ -92,9 +92,9 @@
 ```
 
 - **Zero Config**: Just run `npx @datafrog-io/n2n-nexus` - no `--id` or `--host` required.
-- **Auto Election**: First instance binds port 5688 and becomes Host; others join as Guests.
-- **Cross-Project Sync**: All IDEs share the same Hub, enabling real-time cross-project meetings.
-- **Hot Failover**: If Host disconnects, a Guest automatically promotes within 10 seconds.
+- **Immediate Handshake**: Stdio connects instantly (<10ms) for static requests (`tools/list`), buffering dynamic requests until election completes.
+- **Parallel Election**: Concurrent port scanning ensures Host/Guest resolution in <300ms.
+- **Hot Failover**: If Host disconnects, a Guest automatically promotes itself to Host and others reconnect.
 
 ## 🚀 Quick Start
 

package/build/config/index.js

@@ -7,7 +7,6 @@ import { fileURLToPath } from "url";
 import { FILE_ENCODING, PACKAGE_JSON } from "../constants.js";
 import { getArg, hasFlag } from "./cli.js";
 import { getRootPath } from "./paths.js";
-import { isHostAutoElection } from "../network/election.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Load version from package.json
 const pkgPath = path.resolve(__dirname, `../../${PACKAGE_JSON}`);
@@ -66,16 +65,27 @@ function getAutoProjectName() {
     const suffix = Math.random().toString(36).substring(2, 6);
     return `${base}-${suffix}`;
 }
-// Run election at module load
+// Run election at module load - REMOVED for Online First architecture
+// const rootPath = getRootPath();
+// const election = await isHostAutoElection(rootPath);
+// const projectName = getAutoProjectName();
+// export const hostServer = election.server;
+// Mutable Config for Online First
 const rootPath = getRootPath();
-const election = await isHostAutoElection(rootPath);
 const projectName = getAutoProjectName();
-export const hostServer = election.server;
 export const CONFIG = {
     instanceId: getArg("--id") || projectName,
-    isHost: election.isHost,
-    rootStorage: election.isHost ? rootPath : (election.rootStorage || rootPath),
-    port: election.port
+    isHost: false, // Default to Guest until elected
+    rootStorage: rootPath, // Default to local until updated
+    port: 0 // Will be set after election
 };
+// Export mutable hostServer container
+export let hostServer;
+export function updateConfig(update) {
+    Object.assign(CONFIG, update);
+}
+export function setHostServer(server) {
+    hostServer = server;
+}
 // Re-export for Guest reconnection
 export { isHostAutoElection } from "../network/election.js";

package/build/constants.js

@@ -13,7 +13,7 @@ export const NEXUS_HOST = "0.0.0.0";
 export const PORT_RANGE_START = 5688;
 export const PORT_RANGE_END = 5800;
 // Timeouts (milliseconds)
-export const HANDSHAKE_TIMEOUT = 500;
+export const HANDSHAKE_TIMEOUT = 200;
 export const HEARTBEAT_INTERVAL = 30000;
 // Task cleanup
 export const TASK_CLEANUP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days

package/build/index.js

@@ -3,98 +3,54 @@
  * n2ns Nexus: Unified Project Asset & Collaboration Hub
  *
  * Modular MCP Server for multi-AI assistant coordination.
+ * Refactored for Robust Host-Guest Architecture (v2).
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
-import { CONFIG, hostServer, pkg } from "./config/index.js";
+import { CONFIG, pkg, updateConfig, setHostServer, isHostAutoElection } from "./config/index.js";
 import { StorageManager } from "./storage/index.js";
 import { TOOL_DEFINITIONS, handleToolCall } from "./tools/index.js";
 import { listResources, getResourceContent } from "./resources/index.js";
 import { sanitizeErrorMessage } from "./utils/error.js";
 import { checkHostPermission } from "./utils/auth.js";
 import { SERVICE_NAME } from "./constants.js";
-import { startHost, startGuest } from "./network/index.js";
+import { startHost } from "./network/index.js";
 class NexusServer {
     server;
     currentProject = null;
     sseTransports = new Map();
+    // Election State
+    isElectionDone = false;
+    role = "PENDING";
+    requestBuffer = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    guestClient = null; // Will be set if Guest
     constructor() {
         this.server = new Server({ name: SERVICE_NAME, version: pkg.version }, { capabilities: { resources: {}, tools: {}, prompts: {} } });
         this.setupHandlers();
     }
+    /**
+     * "Static Pass-through" Handlers
+     * These handlers are registered immediately and can respond BEFORE election.
+     * Dynamic requests are buffered.
+     */
     setupHandlers() {
-        // --- Resource Listing ---
-        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            try {
-                return await listResources();
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                throw new McpError(ErrorCode.InternalError, `Nexus Registry Error: ${sanitizeErrorMessage(msg)}`);
-            }
-        });
-        // --- Resource Reading ---
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            try {
-                const result = await getResourceContent(request.params.uri, this.currentProject);
-                if (!result) {
-                    throw new McpError(ErrorCode.InvalidRequest, `Resource not found: ${request.params.uri}`);
-                }
-                return { contents: [{ uri: request.params.uri, ...result }] };
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                throw new McpError(ErrorCode.InternalError, `Nexus Read Error: ${sanitizeErrorMessage(msg)}`);
-            }
-        });
-        // --- Tool Listing ---
+        // --- 1. Static: Tool Listing (SAFE TO REPLY IMMEDIATELY) ---
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return { tools: TOOL_DEFINITIONS };
         });
-        // --- Tool Calling ---
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const agentId = CONFIG.instanceId;
+        // --- 2. Static: Resource Listing (SAFE TO REPLY IMMEDIATELY) ---
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
             try {
-                // Special handling for switch_project
-                if (request.params.name === "switch_project") {
-                    const args = request.params.arguments;
-                    if (args.project_id) {
-                        const manifest = await StorageManager.getProjectManifest(args.project_id);
-                        if (manifest) {
-                            this.currentProject = args.project_id;
-                            return { content: [{ type: "text", text: `Switched to project: ${args.project_id}` }] };
-                        }
-                    }
-                    return { content: [{ type: "text", text: `Project '${args.project_id}' not found.` }] };
-                }
-                // Host permission check for privileged tools
-                const hostOnlyTools = ["delete_project", "rename_project", "clear_global_logs", "archive_meeting"];
-                if (hostOnlyTools.includes(request.params.name)) {
-                    try {
-                        checkHostPermission(request.params.name);
-                    }
-                    catch {
-                        return { content: [{ type: "text", text: `[Permission Denied] Tool '${request.params.name}' requires Host privileges.` }] };
-                    }
-                }
-                // Delegate to tool handler
-                const ctx = {
-                    currentProject: this.currentProject,
-                    setCurrentProject: (id) => { this.currentProject = id; },
-                    notifyResourceUpdate: (_uri) => { }
-                };
-                const result = await handleToolCall(request.params.name, request.params.arguments, ctx);
-                return result;
+                return await listResources();
             }
             catch (error) {
                 const msg = error instanceof Error ? error.message : String(error);
-                return {
-                    content: [{ type: "text", text: sanitizeErrorMessage(`Tool Error: ${msg}`) }],
-                    isError: true
-                };
+                throw new McpError(ErrorCode.InternalError, `Nexus Registry Error: ${sanitizeErrorMessage(msg)}`);
             }
         });
-        // --- Prompt Listing ---
+        // --- 3. Static: Prompt Listing ---
         this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
             return {
                 prompts: [
@@ -105,64 +61,299 @@ class NexusServer {
                 ]
             };
         });
-        // --- Prompt Getting ---
+        // --- 4. Dynamic: Tool Calling (BUFFERED) ---
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            // Attempt to retrieve Request ID from extra info or cast request
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reqId = request.id || extra?.id || `req-${Date.now()}`;
+            if (!this.isElectionDone) {
+                // Buffer!
+                return new Promise((resolve, reject) => {
+                    this.requestBuffer.push({
+                        method: "tools/call",
+                        params: request.params,
+                        requestId: reqId,
+                        resolve,
+                        reject
+                    });
+                });
+            }
+            // Route based on Role
+            if (this.role === "HOST") {
+                return this.handleHostToolCall(request.params, reqId);
+            }
+            else {
+                return this.forwardToHost("tools/call", request.params);
+            }
+        });
+        // --- 5. Dynamic: Read Resource (BUFFERED) ---
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            if (!this.isElectionDone) {
+                return new Promise((resolve, reject) => {
+                    this.requestBuffer.push({
+                        method: "resources/read",
+                        params: request.params,
+                        resolve,
+                        reject
+                    });
+                });
+            }
+            if (this.role === "HOST") {
+                return this.handleHostReadResource(request.params);
+            }
+            else {
+                return this.forwardToHost("resources/read", request.params);
+            }
+        });
+        // --- 6. Dynamic: Get Prompt (BUFFERED) ---
         this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            if (request.params.name === "nexus_status") {
-                const registry = await StorageManager.listRegistry();
-                const projectCount = Object.keys(registry.projects).length;
-                const logs = await StorageManager.getRecentLogs(5);
-                return {
-                    messages: [{
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: `Nexus Hub Status:
-- Role: ${CONFIG.isHost ? "Host" : "Guest"}
+            if (!this.isElectionDone) {
+                return new Promise((resolve, reject) => {
+                    this.requestBuffer.push({
+                        method: "prompts/get",
+                        params: request.params,
+                        resolve,
+                        reject
+                    });
+                });
+            }
+            if (this.role === "HOST") {
+                // Local logic for prompt
+                if (request.params.name === "nexus_status") {
+                    const registry = await StorageManager.listRegistry();
+                    const projectCount = Object.keys(registry.projects).length;
+                    const logs = await StorageManager.getRecentLogs(5);
+                    return {
+                        messages: [{
+                                role: "user",
+                                content: {
+                                    type: "text",
+                                    text: `Nexus Hub Status:
+- Role: Host
 - Instance: ${CONFIG.instanceId}
 - Port: ${CONFIG.port}
 - Active Projects: ${projectCount}
 - Recent Activity: ${logs.length} entries`
-                            }
-                        }]
-                };
+                                }
+                            }]
+                    };
+                }
+                throw new McpError(ErrorCode.InvalidRequest, `Prompt not found: ${request.params.name}`);
+            }
+            else {
+                return this.forwardToHost("prompts/get", request.params);
             }
-            throw new McpError(ErrorCode.InvalidRequest, `Prompt not found: ${request.params.name}`);
         });
     }
+    // --- Host Logic Implementation ---
+    async handleHostReadResource(params) {
+        try {
+            const result = await getResourceContent(params.uri, this.currentProject);
+            if (!result) {
+                throw new McpError(ErrorCode.InvalidRequest, `Resource not found: ${params.uri}`);
+            }
+            return { contents: [{ uri: params.uri, ...result }] };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new McpError(ErrorCode.InternalError, `Nexus Read Error: ${sanitizeErrorMessage(msg)}`);
+        }
+    }
+    async handleHostToolCall(params, requestId) {
+        try {
+            // Special handling for switch_project
+            if (params.name === "switch_project") {
+                const args = params.arguments;
+                if (args.project_id) {
+                    const manifest = await StorageManager.getProjectManifest(args.project_id);
+                    if (manifest) {
+                        this.currentProject = args.project_id;
+                        return { content: [{ type: "text", text: `Switched to project: ${args.project_id}` }] };
+                    }
+                }
+                return { content: [{ type: "text", text: `Project '${args.project_id}' not found.` }] };
+            }
+            // Host permission check
+            const hostOnlyTools = ["delete_project", "rename_project", "clear_global_logs", "archive_meeting"];
+            if (hostOnlyTools.includes(params.name)) {
+                try {
+                    checkHostPermission(params.name);
+                }
+                catch {
+                    return { content: [{ type: "text", text: `[Permission Denied] Tool '${params.name}' requires Host privileges.` }] };
+                }
+            }
+            const ctx = {
+                currentProject: this.currentProject,
+                setCurrentProject: (id) => { this.currentProject = id; },
+                notifyResourceUpdate: (_uri) => {
+                    // TODO: Notify all clients via SSE
+                },
+                requestId // Pass the ID to the context
+            };
+            const result = await handleToolCall(params.name, params.arguments, ctx);
+            return result;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            const idPrefix = requestId ? `[Req:${requestId}] ` : "";
+            // We return a text response for tool errors to maintain conversation flow, but flag it as error
+            return {
+                content: [{ type: "text", text: sanitizeErrorMessage(`${idPrefix}Tool Error: ${msg}`) }],
+                isError: true
+            };
+        }
+    }
+    // --- Guest Logic Implementation ---
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async forwardToHost(method, params) {
+        if (!this.guestClient)
+            throw new Error("Guest Client not initialized");
+        // Delegate to the Guest Client to making the HTTP call
+        return this.guestClient.sendRequest(method, params);
+    }
+    // --- Lifecycle ---
+    async run() {
+        this.setupShutdownHandlers();
+        // 1. IMMEDIATE: Connect Stdio (Handshake Ready)
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error(`[Nexus] Stdio Connected (Pending Election)...`);
+        // 2. Start Election (Parallel)
+        isHostAutoElection(CONFIG.rootStorage).then(async (election) => {
+            console.error(`[Nexus] Election Finished. Role: ${election.isHost ? "HOST" : "GUEST"}`);
+            this.role = election.isHost ? "HOST" : "GUEST";
+            this.isElectionDone = true;
+            // Global Config Update
+            updateConfig({
+                isHost: election.isHost,
+                port: election.port,
+                rootStorage: election.isHost ? CONFIG.rootStorage : (election.rootStorage || CONFIG.rootStorage)
+            });
+            if (election.isHost && election.server) {
+                // --- HOST MODE ---
+                if (election.server)
+                    setHostServer(election.server);
+                await startHost(election.server, {
+                    config: CONFIG,
+                    pkg,
+                    mcpServer: this.server,
+                    sseTransports: this.sseTransports
+                });
+                // Flush Buffer (Process locally)
+                this.flushBufferAsHost();
+            }
+            else {
+                // --- GUEST MODE ---
+                // We do NOT close the Stdio server. We keep it to receive requests from IDE.
+                // But we start the Guest Client to forward those requests.
+                const { createGuestClient } = await import("./network/guest.js");
+                this.guestClient = createGuestClient(election.port, CONFIG.instanceId, () => {
+                    this.handleReElection();
+                });
+                // Flush Buffer (Forward to Host)
+                this.flushBufferAsGuest();
+            }
+        }).catch(err => {
+            console.error(`[Nexus CRITICAL] Election failed:`, err);
+            // In case of failure, reject all buffered requests
+            this.requestBuffer.forEach(req => req.reject(new Error("Nexus Startup Failed")));
+            process.exit(1);
+        });
+    }
+    flushBufferAsHost() {
+        console.error(`[Nexus] Flushing ${this.requestBuffer.length} buffered requests (Local)...`);
+        while (this.requestBuffer.length > 0) {
+            const req = this.requestBuffer.shift();
+            if (!req)
+                break;
+            // Re-route to local handlers based on method
+            if (req.method === "tools/call") {
+                this.handleHostToolCall(req.params, req.requestId).then(req.resolve).catch(req.reject);
+            }
+            else if (req.method === "resources/read") {
+                this.handleHostReadResource(req.params).then(req.resolve).catch(req.reject);
+            }
+            else {
+                // Generic handling or error
+                req.reject(new Error(`Unknown buffered method: ${req.method}`));
+            }
+        }
+    }
+    flushBufferAsGuest() {
+        console.error(`[Nexus] Flushing ${this.requestBuffer.length} buffered requests (Remote)...`);
+        while (this.requestBuffer.length > 0) {
+            const req = this.requestBuffer.shift();
+            if (!req)
+                break;
+            this.forwardToHost(req.method, req.params).then(req.resolve).catch(req.reject);
+        }
+    }
     setupShutdownHandlers() {
         const shutdown = async (signal) => {
             console.error(`\n[Nexus] Received ${signal}. Shutting down...`);
             try {
-                const msg = `Nexus Session Terminated (IDE Closed).`;
-                await StorageManager.addGlobalLog(`SYSTEM:${CONFIG.instanceId}`, msg, "UPDATE");
-                console.error(`[Nexus:${CONFIG.instanceId}] Goodbye!`);
+                if (this.role === "HOST") {
+                    await StorageManager.addGlobalLog(`SYSTEM:${CONFIG.instanceId}`, `Nexus Host Terminated (${signal}).`, "UPDATE");
+                }
+                if (this.guestClient && typeof this.guestClient.close === 'function') {
+                    this.guestClient.close();
+                }
             }
             catch { /* ignore */ }
             process.exit(0);
         };
-        process.on("uncaughtException", (err) => {
-            console.error("[Nexus CRITICAL] Uncaught Exception:", err);
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            console.error("[Nexus WARNING] Unhandled Rejection at:", promise, "reason:", reason);
-        });
         process.on("SIGINT", () => shutdown("SIGINT"));
         process.on("SIGTERM", () => shutdown("SIGTERM"));
     }
-    async run() {
-        this.setupShutdownHandlers();
-        const context = {
-            config: CONFIG,
-            pkg,
-            mcpServer: this.server,
-            sseTransports: this.sseTransports
-        };
-        if (CONFIG.isHost && hostServer) {
-            await startHost(hostServer, context);
-        }
-        else {
-            await startGuest(CONFIG.port, context);
+    handleReElection() {
+        console.error(`[Nexus] Host Unreachable! Triggering Auto-Re-Election...`);
+        // 1. Reset State
+        this.role = "PENDING";
+        this.isElectionDone = false;
+        if (this.guestClient) {
+            if (typeof this.guestClient.close === 'function')
+                this.guestClient.close();
+            this.guestClient = null;
         }
+        // 2. Retry Election
+        // Use a short random delay to avoid collision if multiple Guests retry at once
+        const delay = Math.floor(Math.random() * 500) + 200;
+        setTimeout(() => {
+            // 3. Re-run startup logic (simplified inline version of run() election part)
+            isHostAutoElection(CONFIG.rootStorage).then(async (election) => {
+                console.error(`[Nexus] Re-Election Finished. New Role: ${election.isHost ? "HOST" : "GUEST"}`);
+                this.role = election.isHost ? "HOST" : "GUEST";
+                this.isElectionDone = true;
+                updateConfig({
+                    isHost: election.isHost,
+                    port: election.port,
+                    rootStorage: election.isHost ? CONFIG.rootStorage : (election.rootStorage || CONFIG.rootStorage)
+                });
+                if (election.isHost && election.server) {
+                    if (election.server)
+                        setHostServer(election.server);
+                    await startHost(election.server, {
+                        config: CONFIG,
+                        pkg,
+                        mcpServer: this.server,
+                        sseTransports: this.sseTransports
+                    });
+                    this.flushBufferAsHost();
+                }
+                else {
+                    const { createGuestClient } = await import("./network/guest.js");
+                    this.guestClient = createGuestClient(election.port, CONFIG.instanceId, () => {
+                        this.handleReElection();
+                    });
+                    this.flushBufferAsGuest();
+                }
+            }).catch(err => {
+                console.error("[Nexus] Re-Election Failed:", err);
+                // Retry again? Or just die? Let's retry indefinitely for now.
+                setTimeout(() => this.handleReElection(), 2000);
+            });
+        }, delay);
     }
 }
 const server = new NexusServer();

package/build/network/election.js

@@ -62,33 +62,92 @@ export async function probeHost(port, myId) {
  * 1. Try to bind → Success → I am Host
  * 2. Bind fails → Try handshake → Success → I am Guest
  * 3. Handshake fails → Port occupied by non-Nexus → Next port
+ *
+ * Optimized for speed: Fast-fail on bind, short timeout on handshake.
+ */
+/**
+ * Automatic Host Election
+ *
+ * Strategy:
+ * 1. Parallel Scan (0-200ms): Race to bind or handshake on the first batch of ports.
+ * 2. Sequential Scan: If all preferred ports are busy/zombie, try remaining ports.
+ * 3. Fallback: Bind to port 0 (OS assigned) to guarantee isolation.
  */
 export async function isHostAutoElection(_root, blacklistPorts = []) {
     const startPort = PORT_RANGE_START;
     const endPort = PORT_RANGE_END;
     const myId = getArg("--id") || `node-${Math.random().toString(36).substring(2, 6)}`;
-    for (let port = startPort; port <= endPort; port++) {
+    // 1. Parallel Scan of first 5 ports (High Probability Zone)
+    const BATCH_SIZE = 5;
+    const batchEnd = Math.min(startPort + BATCH_SIZE, endPort);
+    const checks = [];
+    for (let port = startPort; port < batchEnd; port++) {
         if (blacklistPorts.includes(port))
             continue;
-        // 1. Try to bind port
-        const bindResult = await new Promise((resolve) => {
-            const server = http.createServer();
-            server.on("error", () => resolve({ success: false }));
-            server.listen(port, NEXUS_HOST, () => resolve({ success: true, server }));
-        });
-        if (bindResult.success) {
-            // Bind success → I am Host
-            return { isHost: true, port, server: bindResult.server };
+        checks.push(checkPort(port, myId));
+    }
+    try {
+        // Wait for all checks to complete, then pick the first valid result (Win-Win)
+        const results = await Promise.all(checks);
+        // Priority: Prefer Host (Bind Success) over Guest (Existing Nexus) if both happen?
+        // Actually, 'checkPort' tries Bind FIRST, then Handshake.
+        // So if we get a result from checkPort, it's a definitive state for that port.
+        // We pick the first non-null result based on port order (implicitly by array index if we iterated, but here we scan).
+        const winner = results.find(r => r !== null);
+        if (winner) {
+            return winner;
         }
-        // 2. Bind failed → Try handshake
+    }
+    catch {
+        // Continue to sequential
+    }
+    // 2. Sequential Scan for the rest (Low Probability)
+    for (let port = batchEnd; port <= endPort; port++) {
+        if (blacklistPorts.includes(port))
+            continue;
+        const result = await checkPort(port, myId);
+        if (result)
+            return result;
+    }
+    // 3. Fallback: Isolated Host
+    // 3. Fallback: Isolated Host
+    console.error(`[Nexus] Preferred ports ${startPort}-${endPort} busy. Starting isolated Host...`);
+    const fallbackServer = http.createServer();
+    const fallbackPort = await new Promise((resolve, reject) => {
+        fallbackServer.listen(0, NEXUS_HOST, () => {
+            const addr = fallbackServer.address();
+            if (addr && typeof addr !== 'string')
+                resolve(addr.port);
+            else
+                reject("Failed to bind fallback port");
+        });
+    });
+    return { isHost: true, port: fallbackPort, server: fallbackServer };
+}
+/**
+ * Atomic Port Check:
+ * Returns result if we successfully Bind (Host) or Handshake (Guest).
+ * Returns null if port is busy with non-Nexus service.
+ */
+async function checkPort(port, myId) {
+    // A. Try Bind
+    const bindResult = await new Promise((resolve) => {
+        const server = http.createServer();
+        server.on("error", () => resolve({ success: false }));
+        server.listen(port, NEXUS_HOST, () => resolve({ success: true, server }));
+    });
+    if (bindResult.success) {
+        return { isHost: true, port, server: bindResult.server };
+    }
+    // B. Try Handshake (if bind failed)
+    try {
         const probe = await probeHost(port, myId);
         if (probe.isNexus) {
-            // Handshake success → I am Guest
             return { isHost: false, port, rootStorage: probe.rootStorage };
         }
-        // 3. Handshake failed → Port occupied by non-Nexus → Continue
     }
-    // All ports unavailable
-    console.error(`[Nexus] All ports ${startPort}-${endPort} occupied by non-Nexus processes.`);
-    throw new Error("No available port for Nexus");
+    catch {
+        // Handshake failed/timeout
+    }
+    return null;
 }

package/build/network/guest.js

@@ -1,110 +1,263 @@
-/**
- * Guest Mode Client
- *
- * Connects to a Host server via SSE and proxies stdio.
- */
 import http from "http";
 import { NEXUS_HOST } from "../constants.js";
-import { isHostAutoElection } from "./election.js";
-import { startHost } from "./host.js";
-/**
- * Start Guest mode - connect to Host and proxy stdio
- */
-export async function startGuest(targetPort, context) {
-    const { config, mcpServer, sseTransports } = context;
-    const guestId = config.instanceId;
-    const reconnect = async () => {
-        console.error("[Nexus Guest] Lost connection to Host. Attempting to become new Host...");
-        const result = await isHostAutoElection(config.rootStorage);
-        if (result.isHost && result.server) {
-            // Bind success → I become Host
-            console.error(`[Nexus] Promoted to Host on port ${result.port}!`);
-            config.isHost = true;
-            config.port = result.port;
-            await startHost(result.server, {
-                config,
-                pkg: context.pkg,
-                mcpServer,
-                sseTransports: sseTransports
-            });
+export class GuestClient {
+    targetPort;
+    guestId;
+    sessionId = null;
+    requestQueue = [];
+    pendingRequests = new Map();
+    isConnected = false;
+    reconnectTimer = null;
+    sseRequest = null;
+    onReElectionNeeded = null;
+    connectionFailures = 0;
+    constructor(targetPort, guestId, onReElectionNeeded) {
+        this.targetPort = targetPort;
+        this.guestId = guestId;
+        this.onReElectionNeeded = onReElectionNeeded || null;
+        this.start();
+    }
+    /**
+     * Public API to send a request (buffered if not connected)
+     */
+    async sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            if (this.sessionId) {
+                this.doPost(method, params, resolve, reject);
+            }
+            else {
+                this.requestQueue.push({ method, params, resolve, reject });
+            }
+        });
+    }
+    /**
+     * Terminate the client (useful for testing/shutdown)
+     */
+    close() {
+        this.isConnected = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
         }
-        else {
-            // Bind failed → Another Guest became Host → Connect to it
-            console.error(`[Nexus] Found new Host at ${result.port}. Reconnecting...`);
-            config.port = result.port;
-            startGuest(result.port, context);
+        this.pendingRequests.forEach(p => p.reject(new Error("GuestClient closed")));
+        this.pendingRequests.clear();
+        if (this.sseRequest) {
+            this.sseRequest.destroy();
+            this.sseRequest = null;
         }
-    };
-    const connect = () => {
-        process.stdin.removeAllListeners("data");
-        console.error(`[Nexus:${guestId}] Connecting to Host at ${targetPort}...`);
-        let sessionId = null;
-        let pendingStdin = [];
-        let sseBuffer = "";
-        // Client connection should use 127.0.0.1 if host is 0.0.0.0
+    }
+    start() {
+        console.error(`[Nexus:${this.guestId}] Connecting to Host at ${this.targetPort}...`);
+        // Connect SSE
         const connectHost = NEXUS_HOST === "0.0.0.0" ? "127.0.0.1" : NEXUS_HOST;
-        const forwardToHost = (chunk) => {
-            if (!sessionId) {
-                pendingStdin.push(chunk);
+        const options = {
+            hostname: connectHost,
+            port: this.targetPort,
+            path: `/mcp?id=${encodeURIComponent(this.guestId)}`,
+            method: "GET",
+            headers: {
+                "Accept": "text/event-stream",
+                "Connection": "keep-alive"
+            }
+        };
+        const req = http.request(options, (res) => {
+            if (res.statusCode !== 200) {
+                console.error(`[Nexus Guest] Handshake failed: ${res.statusCode}`);
+                this.scheduleReconnect(true); // Treat as failure
                 return;
             }
+            this.isConnected = true;
+            this.connectionFailures = 0; // Reset counter
+            // Setup robust stream reading
+            const state = { buffer: "" };
+            res.on("data", (chunk) => this.handleSSEChunk(chunk.toString(), state));
+            res.on("end", () => {
+                console.error("[Nexus Guest] Connection closed (end) by Host.");
+                this.isConnected = false;
+                this.scheduleReconnect(true);
+            });
+            res.on("close", () => {
+                if (this.isConnected) {
+                    console.error("[Nexus Guest] Connection closed (close) by Host.");
+                    this.isConnected = false;
+                    this.scheduleReconnect(true);
+                }
+            });
+        });
+        req.on("close", () => {
+            if (this.isConnected) {
+                console.error("[Nexus Guest] Request closed.");
+                this.isConnected = false;
+                this.scheduleReconnect(true);
+            }
+        });
+        req.on("error", (err) => {
+            const code = err.code;
+            console.error(`[Nexus Guest] Connect error: ${err.message} (Code: ${code})`);
+            this.isConnected = false;
+            // Check for connection refusal (Host down) or Reset
+            if (code === 'ECONNREFUSED' || code === 'ECONNRESET') {
+                this.scheduleReconnect(true);
+            }
+            else {
+                this.scheduleReconnect(false); // Maybe temporary network blip
+            }
+        });
+        req.end();
+        this.sseRequest = req;
+    }
+    handleSSEChunk(chunk, state) {
+        state.buffer += chunk;
+        const lines = state.buffer.split("\n");
+        // Keep the last partial line in buffer
+        state.buffer = lines.pop() || "";
+        let eventType = "message";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                // Empty line = Event dispatch
+                eventType = "message"; // reset
+                continue;
+            }
+            if (trimmed.startsWith("event: ")) {
+                eventType = trimmed.substring(7).trim();
+            }
+            else if (trimmed.startsWith("data: ")) {
+                const data = trimmed.substring(6);
+                this.processEvent(eventType, data);
+            }
+        }
+    }
+    processEvent(type, data) {
+        if (type === "endpoint") {
+            const match = data.match(/sessionId=([a-f0-9-]+)/);
+            if (match) {
+                this.sessionId = match[1];
+                this.flushQueue();
+            }
+        }
+        else if (type === "message") {
             try {
-                const req = http.request({
-                    hostname: connectHost,
-                    port: targetPort,
-                    path: `/mcp?sessionId=${sessionId}&id=${encodeURIComponent(guestId)}`,
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" }
-                });
-                req.on("error", () => { });
-                req.write(chunk);
-                req.end();
+                const msg = JSON.parse(data);
+                // 1. Handle Responses to our Requests
+                if (msg.id !== undefined && this.pendingRequests.has(msg.id)) {
+                    const { resolve, reject } = this.pendingRequests.get(msg.id);
+                    this.pendingRequests.delete(msg.id);
+                    if (msg.error) {
+                        reject(msg.error);
+                    }
+                    else {
+                        resolve(msg.result);
+                    }
+                    return;
+                }
+                // 2. Handle Notifications (log to stdout)
+                // If it's a notification (no id) or we aren't tracking it
+                if (!msg.id) {
+                    process.stdout.write(JSON.stringify(msg) + "\n");
+                }
+            }
+            catch {
+                // Fallback for non-JSON messages?
+                // process.stdout.write(data + "\n");
             }
-            catch { /* suppress */ }
+        }
+    }
+    async doPost(method, params, resolve, reject) {
+        if (!this.sessionId)
+            return;
+        const id = Math.floor(Math.random() * 1000000); // Req ID
+        const payload = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params
         };
-        const stdioHandler = (chunk) => forwardToHost(chunk);
-        process.stdin.on("data", stdioHandler);
-        http.get(`http://${connectHost}:${targetPort}/mcp?id=${encodeURIComponent(guestId)}`, (res) => {
-            res.on("data", (chunk) => {
-                sseBuffer += chunk.toString();
-                const lines = sseBuffer.split("\n");
-                sseBuffer = lines.pop() || ""; // Keep trailing incomplete line
-                for (const line of lines) {
-                    const cleanLine = line.trim();
-                    if (!cleanLine)
-                        continue;
-                    if (cleanLine.startsWith("data: ")) {
-                        const content = cleanLine.substring(6);
-                        // Check if this is the endpoint/session assignment
-                        if (!sessionId && content.includes("sessionId=")) {
-                            const match = content.match(/sessionId=([a-f0-9-]+)/);
-                            if (match) {
-                                sessionId = match[1];
-                                // console.error(`[Nexus:${guestId}] Session established: ${sessionId}`);
-                                // Flush pending messages
-                                const toFlush = [...pendingStdin];
-                                pendingStdin = [];
-                                toFlush.forEach(forwardToHost);
+        // Track request
+        this.pendingRequests.set(id, { resolve, reject });
+        const postData = JSON.stringify(payload);
+        const connectHost = NEXUS_HOST === "0.0.0.0" ? "127.0.0.1" : NEXUS_HOST;
+        const req = http.request({
+            hostname: connectHost,
+            port: this.targetPort,
+            path: `/mcp?sessionId=${this.sessionId}`,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(postData)
+            }
+        }, (res) => {
+            let data = "";
+            res.on("data", c => data += c);
+            res.on("end", () => {
+                try {
+                    // 202 Accepted -> Expect response via SSE later
+                    if (res.statusCode === 202) {
+                        return;
+                    }
+                    if (res.statusCode !== 200) {
+                        this.pendingRequests.delete(id);
+                        reject(new Error(`Host returned ${res.statusCode}: ${data}`));
+                        return;
+                    }
+                    // 200 OK -> Response might be in body
+                    if (data) {
+                        const json = JSON.parse(data);
+                        if (json.id !== undefined && this.pendingRequests.has(json.id)) {
+                            // Resolved immediately
+                            this.pendingRequests.delete(json.id);
+                            if (json.error) {
+                                reject(json.error);
                             }
-                        }
-                        else if (content) {
-                            // Assume JSON-RPC message
-                            try {
-                                process.stdout.write(content + "\n");
+                            else {
+                                resolve(json.result);
                             }
-                            catch { /* ignore */ }
                         }
                     }
                 }
+                catch (e) {
+                    this.pendingRequests.delete(id);
+                    reject(e);
+                }
             });
-            res.on("end", () => {
-                process.stdin.removeAllListeners("data");
-                reconnect();
-            });
-        }).on("error", () => {
-            process.stdin.removeAllListeners("data");
-            reconnect();
         });
-    };
-    connect();
+        req.on("error", (e) => {
+            this.pendingRequests.delete(id);
+            reject(e);
+        });
+        req.write(postData);
+        req.end();
+    }
+    flushQueue() {
+        console.error(`[Nexus Guest] Session established (${this.sessionId}). Flushing ${this.requestQueue.length} requests...`);
+        while (this.requestQueue.length > 0) {
+            const req = this.requestQueue.shift();
+            if (req)
+                this.doPost(req.method, req.params, req.resolve, req.reject);
+        }
+    }
+    scheduleReconnect(isHardFailure = false) {
+        if (this.reconnectTimer)
+            return;
+        this.sessionId = null;
+        if (isHardFailure) {
+            this.connectionFailures++;
+        }
+        // If Host is offline, initiate Re-Election almost immediately if callback provided.
+        // We use a small threshold > 0 to avoid blips, but for test speed, 1 is fine if it's ECONNREFUSED.
+        if (this.onReElectionNeeded && isHardFailure) {
+            console.error(`[Nexus Guest] Connection lost/refused. Triggering Re-Election.`);
+            this.onReElectionNeeded();
+            return;
+        }
+        const delay = this.connectionFailures > 5 ? 5000 : 1000;
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            this.start();
+        }, delay);
+    }
+}
+// Factory function to maintain compatibility with index.ts
+export function createGuestClient(port, id, onReElectionNeeded) {
+    return new GuestClient(port, id, onReElectionNeeded);
 }

package/build/network/index.js

@@ -3,4 +3,4 @@
  */
 export { isHostAutoElection, probeHost } from "./election.js";
 export { startHost } from "./host.js";
-export { startGuest } from "./guest.js";
+export { createGuestClient } from "./guest.js";

package/build/resources/index.js

@@ -95,6 +95,7 @@ export async function getResourceContent(uri, currentProject) {
  * Uses resourceTemplates instead - AI should query registry first.
  */
 export async function listResources() {
+    await StorageManager.init(); // Ensure storage is ready (Online First)
     const registry = await StorageManager.listRegistry();
     const projectCount = Object.keys(registry.projects).length;
     return {

package/build/tools/definitions.js

@@ -95,6 +95,18 @@ const ALL_TOOLS = [
         }
     },
     // --- Global Collaboration ---
+    {
+        name: "search_projects",
+        description: "Search project registry by name or description. Use this instead of reading the full registry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                limit: { type: "integer", default: 10 }
+            },
+            required: ["query"]
+        }
+    },
     {
         name: "get_global_topology",
         description: "Default: project list + stats. With projectId: detailed subgraph.",

package/build/tools/handlers.js

@@ -22,7 +22,8 @@ export async function handleToolCall(name, toolArgs, ctx) {
     }
     catch (e) {
         const error = e;
-        throw new McpError(ErrorCode.InvalidParams, `Schema validation failed: ${error.message}`);
+        const idPrefix = ctx.requestId ? `[Req:${ctx.requestId}] ` : "";
+        throw new McpError(ErrorCode.InvalidParams, `${idPrefix}Schema validation failed: ${error.message}`);
     }
     switch (name) {
         case "register_session_context":
@@ -31,6 +32,8 @@ export async function handleToolCall(name, toolArgs, ctx) {
             return handleSyncProjectAssets(validatedArgs, ctx);
         case "upload_project_asset":
             return handleUploadAsset(validatedArgs, ctx);
+        case "search_projects":
+            return handleSearchProjects(validatedArgs);
         case "get_global_topology":
             return handleGetTopology(validatedArgs);
         case "send_message":
@@ -225,6 +228,34 @@ async function handleRenameProject(args, ctx) {
             }]
     };
 }
+async function handleSearchProjects(args) {
+    if (!args.query)
+        throw new McpError(ErrorCode.InvalidParams, "Query is required.");
+    const limit = args.limit || 10;
+    const registry = await StorageManager.listRegistry();
+    const query = args.query.toLowerCase();
+    // Search in ID, Name, and Description
+    const matches = Object.entries(registry.projects)
+        .filter(([id, p]) => id.toLowerCase().includes(query) ||
+        (p.name && p.name.toLowerCase().includes(query)) ||
+        (p.summary && p.summary.toLowerCase().includes(query)))
+        .map(([id, p]) => ({
+        id: id,
+        name: p.name || id,
+        description: p.summary
+    }))
+        .slice(0, limit);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    query: args.query,
+                    count: matches.length,
+                    results: matches
+                }, null, 2)
+            }]
+    };
+}
 // --- Global Handlers ---
 async function handleGetTopology(args) {
     const topo = await StorageManager.calculateTopology(args?.projectId);

package/build/tools/schemas.js

@@ -68,6 +68,13 @@ export const TopologySchema = z.object({
     projectId: ProjectIdSchema.optional().describe("Focus on specific project's subgraph. Omit for summary list.")
 });
 export const EmptySchema = z.object({});
+/**
+ * 5. search_projects
+ */
+export const SearchProjectsSchema = z.object({
+    query: z.string().min(1, "Query is required"),
+    limit: z.number().int().positive().optional().default(10)
+});
 /**
  * 7. send_message
  */
@@ -206,6 +213,10 @@ export const TOOL_REGISTRY = {
         description: "Project topology. Default: list summary. With projectId: detailed subgraph.",
         schema: TopologySchema
     },
+    search_projects: {
+        description: "Search project registry by name or description. Use this instead of reading the full registry.",
+        schema: SearchProjectsSchema
+    },
     send_message: {
         description: "Post a message to the Nexus collaboration space. If an active meeting exists, the message is automatically routed to that meeting. Otherwise, it goes to the global discussion log. Use this for proposals, decisions, or general coordination.",
         schema: SendMessageSchema

package/docs/ARCHITECTURE.md

@@ -61,3 +61,18 @@ To ensure clarity and prevent collisions in the flat local namespace, all Projec
 | `bot_` | Bots (Discord, Slack, DingTalk, etc.) | `bot_auto-moderator` |
 | `infra_` | Infrastructure as Code, CI/CD, DevOps scripts | `infra_k8s-config` |
 | `doc_` | Pure technical handbooks, strategies, roadmaps | `doc_coding-guide` |
+
+## 🌐 Host-Guest Network Architecture (v2)
+
+### Zero-Config Startup & Election
+The system aims for a "magic" user experience where multiple instances on the same machine automatically discover each other without manual configuration.
+
+1.  **Parallel Race Election**: Upon startup, every instance scans the first 5 ports (5688-5692) concurrently (<300ms).
+2.  **Role Resolution**:
+    *   **Host**: If a port is free, the instance binds it and becomes the Host.
+    *   **Guest**: If a Host is found, the instance connects via SSE (Server-Sent Events) and becomes a Guest.
+3.  **Immediate Handshake**: The `StdioServerTransport` connects immediately (<10ms) to the IDE. Static requests (`tools/list`) are served locally, preventing IDE timeouts. Dynamic requests are **buffered** until the election concludes.
+
+### Failover & Resilience
+*   **Smart Proxy**: Guest instances proxy IDE requests to the Host via HTTP/SSE. They handle backpressure and buffering to prevent data loss during connection blips.
+*   **Auto-Failover**: If the Host process terminates (e.g., user closes the Host IDE window), Guest instances detect the connection loss (via `ECONNREFUSED` or SSE `end`) and trigger a **Re-Election**. One of the surviving Guests will promote itself to become the new Host, restoring the cluster automatically.

package/docs/ARCHITECTURE_zh.md

@@ -41,3 +41,18 @@ Nexus_Storage/
 **自我修复 (Self-healing)**: 核心数据文件（如 `registry.json`, `discussion.json`）具备自动检测与修复机制。如果文件损坏或意外丢失，系统会自动重建初始状态，确保服务不中断。
 
 **多并发安全 (Concurrency Safety)**: 对共享文件（`discussion.json`, `registry.json`）的所有写入操作均受 `AsyncMutex` 锁保护，防止多个 AI 代理同时通信时发生竞争条件。
+
+## 🌐 Host-Guest 网络架构 (v2)
+
+### 零配置启动与选举
+系统旨在提供“魔法般”的用户体验，同一台机器上的多个实例无需手动配置即可自动发现并组网。
+
+1.  **并行竞速选举**: 启动时，每个实例并发扫描前 5 个端口 (5688-5692) (<300ms)。
+2.  **角色解析**:
+    *   **Host**: 如果发现空闲端口，实例绑定该端口并成为 Host。
+    *   **Guest**: 如果发现已有 Host，实例通过 SSE (Server-Sent Events) 连接并成为 Guest。
+3.  **立即握手**: `StdioServerTransport` 对 IDE 的连接是立即完成的 (<10ms)。静态请求（如 `tools/list`）由本地直接响应，避免 IDE 超时；动态请求被**缓冲**，直到选举完成。
+
+### 故障转移与高可用
+*   **智能代理 (Smart Proxy)**: Guest 实例通过 HTTP/SSE 将 IDE 请求代理给 Host。它们处理背压和缓冲，防止网络抖动导致数据丢失。
+*   **自动故障转移**: 如果 Host 进程终止（例如用户关闭了 Host IDE 窗口），Guest 实例会检测到连接断开（通过 `ECONNREFUSED` 或 SSE `end`），并触发 **重新选举**。其中一个幸存的 Guest 将自动晋升为新的 Host，自动恢复集群服务。

package/docs/ASSISTANT_GUIDE.md

@@ -1,4 +1,4 @@
-# Nexus 助手协作指令 (v0.3.0)
+# Nexus Assistant Guide
 
 你现在是 **n2ns Nexus** 协作网络的一员。该系统集成了实时通信、结构化资产管理、**异步任务流 (Task Primitives)** 以及 **全局 Hub 架构 (v0.3.0)**，所有操作均落地在本地文件系统。
 

package/docs/CHANGELOG_zh.md

@@ -2,6 +2,19 @@
 
 本项目的所有重大变更都将记录在此文件中。
 
+## [0.4.0] - 2026-01-14
+### 🚀 高可用与高扩展 (High Availability & Scalability)
+- **Failover Mechanism**: 实现了自动的 Guest-to-Host 故障转移。如果 Host 进程意外退出，Guest 会检测到端口/锁释放并立即接管 Host 角色，同时保证数据持久性。
+- **Progressive Discovery**: 新增 `search_projects` 工具。允许 AI 根据意图搜索相关项目，而无需读取包含 1000+ 项目的完整注册表，大幅节省 Token。
+- **Immediate Handshake**: 实现了请求缓冲机制 (Request Buffering)，允许 Server 在 Host 选举 (~300ms) 完成前就立即接受 (<10ms) IDE 的请求，彻底解决了启动时的竞态条件。
+- **Stability**: 增加了针对进程故障转移 (`tests/failover.test.ts`) 和请求缓冲 (`tests/buffered_requests.test.ts`) 的端到端测试。
+
+## [0.3.9] - 2026-01-14
+### 🚀 故障切换与立即握手
+- **立即握手**: 实现了基于缓冲区的设计，Stdio 启动后 <10ms 内即可响应，不再阻塞 IDE 等待选举。
+- **自动故障切换**: 新增了 `Failover` 机制。如果 Host 进程被杀或崩溃，存活的 Guest 会在检测到连接断开后立即触发重新选举，并自动晋升为新 Host。
+- **零配置 V2**: 进一步优化了启动流程，完全无需用户干预即可组建高可用集群。
+
 ## [0.3.5] - 2026-01-10
 ### 协议与稳定性
 - **修复 (僵尸 Host)**: 实现了“智能重试”和“重新选举”逻辑。如果 Guest 反复连接到僵尸 Host（握手成功但 SSE 断开），现在会自动触发重新选举流程，将坏端口加入黑名单，并在必要时在从端口上将自身提升为 Host。

package/docs/README_zh.md

@@ -92,9 +92,9 @@
 ```
 
 - **零配置**: 只需运行 `npx @datafrog-io/n2n-nexus` — 无需 `--id` 或 `--host`。
-- **自动选举**: 首个实例绑定 5688 端口成为 Host；其余自动加入为 Guest。
-- **跨项目同步**: 所有 IDE 共享同一个 Hub，实现实时跨项目会议。
-- **热故障转移**: 若 Host 断开，Guest 将在 10 秒内自动升迁。
+- **立即握手**: Stdio 瞬间响应 (<10ms) 静态请求 (`tools/list`)，动态请求自动缓冲。
+- **并行选举**: 并发端口探测保证选举过程在 <300ms 完成。
+- **热故障转移**: 若 Host 断开，Guest 自动检测并选举成为新 Host，实现自动修复。
 
 ## 🚀 快速启动
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datafrog-io/n2n-nexus",
-    "version": "0.3.7",
+    "version": "0.4.0",
     "description": "Modular MCP Server for multi-AI assistant coordination",
     "main": "build/index.js",
     "type": "module",
@@ -41,6 +41,7 @@
         "start": "node build/index.js",
         "dev": "tsc -w",
         "test": "vitest run",
+        "test:integration": "vitest run tests/integration.test.ts tests/failover.test.ts tests/meeting.test.ts tests/guest_connection.test.ts",
         "lint": "eslint src/**",
         "prepublishOnly": "npm run build"
     },