@naisys/hub 3.0.0-beta.10

package/dist/services/naisysServer.js

@@ -0,0 +1,164 @@
+import { createNaisysConnection } from "./naisysConnection.js";
+/**
+ * Creates the NAISYS namespace server that accepts NAISYS instance connections.
+ */
+export function createNaisysServer(nsp, initialHubAccessKey, logService, hostRegistrar) {
+    let hubAccessKey = initialHubAccessKey;
+    // Track connected NAISYS instances (keyed by hostId)
+    const naisysConnections = new Map();
+    // Track connected supervisor instances (multiple allowed, all share one hostId)
+    const supervisorConnections = [];
+    // Generic event handlers registry - maps event name to set of registered handlers
+    const eventHandlers = new Map();
+    function registerEvent(event, handler, schema) {
+        if (!eventHandlers.has(event)) {
+            eventHandlers.set(event, new Set());
+        }
+        eventHandlers.get(event).add({ handler, schema });
+    }
+    // Unregister an event handler
+    function unregisterEvent(event, handler) {
+        const handlers = eventHandlers.get(event);
+        if (handlers) {
+            for (const registered of handlers) {
+                if (registered.handler === handler) {
+                    handlers.delete(registered);
+                    break;
+                }
+            }
+        }
+    }
+    // Emit an event to all registered handlers, validating data if schema provided
+    function raiseEvent(event, hostId, ...args) {
+        const handlers = eventHandlers.get(event);
+        if (handlers) {
+            for (const { handler, schema } of handlers) {
+                // If schema is provided and we have data, validate it
+                if (schema && args.length > 0) {
+                    const result = schema.safeParse(args[0]);
+                    if (!result.success) {
+                        logService.error(`[Hub] Schema validation failed for event '${event}' from ${hostId}: ${JSON.stringify(result.error.issues)}`);
+                        continue; // Skip this handler if validation fails
+                    }
+                    // Call handler with validated data
+                    handler(hostId, result.data, ...args.slice(1));
+                }
+                else {
+                    handler(hostId, ...args);
+                }
+            }
+        }
+    }
+    function sendMessage(hostId, event, payload, ack) {
+        const connection = naisysConnections.get(hostId);
+        if (!connection) {
+            return false;
+        }
+        connection.sendMessage(event, payload, ack);
+        return true;
+    }
+    // Authentication middleware
+    nsp.use(async (socket, next) => {
+        const { hubAccessKey: clientAccessKey, hostName, hostType: rawHostType, } = socket.handshake.auth;
+        if (!clientAccessKey || clientAccessKey !== hubAccessKey) {
+            logService.log(`[Hub] Connection rejected: invalid access key from ${socket.handshake.address}`);
+            return next(new Error("Invalid access key"));
+        }
+        if (!hostName) {
+            logService.log(`[Hub] Connection rejected: missing hostName`);
+            return next(new Error("Missing hostName"));
+        }
+        try {
+            const hostType = (typeof rawHostType === "string" ? rawHostType : "naisys");
+            const hostId = await hostRegistrar.registerHost(hostName, hostType, socket.handshake.address);
+            // Reject duplicate naisys connections (supervisors may have multiple)
+            if (hostType === "naisys" && naisysConnections.has(hostId)) {
+                logService.log(`[Hub] Connection rejected: host '${hostName}' is already connected`);
+                return next(new Error(`Host '${hostName}' already has an active connection`));
+            }
+            socket.data.hostId = hostId;
+            socket.data.hostName = hostName;
+            socket.data.hostType = hostType;
+            next();
+        }
+        catch (err) {
+            logService.error(`[Hub] Connection rejected: failed to register host ${hostName}: ${err}`);
+            return next(new Error("NAISYS instance registration failed"));
+        }
+    });
+    // Handle new connections
+    nsp.on("connection", (socket) => {
+        const { hostId, hostName, hostType } = socket.data;
+        // Create connection handler for this socket, passing our emit function
+        const connection = createNaisysConnection(socket, {
+            hostId,
+            hostName,
+            connectedAt: new Date(),
+            hostType,
+        }, raiseEvent, logService);
+        if (hostType === "supervisor") {
+            supervisorConnections.push(connection);
+        }
+        else {
+            naisysConnections.set(hostId, connection);
+        }
+        raiseEvent("client_connected", hostId, connection);
+        logService.log(`[Hub] Active connections: naisys=${naisysConnections.size}, supervisors=${supervisorConnections.length}`);
+        // Clean up on disconnect
+        socket.on("disconnect", () => {
+            if (hostType === "supervisor") {
+                const idx = supervisorConnections.indexOf(connection);
+                if (idx !== -1)
+                    supervisorConnections.splice(idx, 1);
+            }
+            else {
+                naisysConnections.delete(hostId);
+            }
+            raiseEvent("client_disconnected", hostId);
+            logService.log(`[Hub] Active connections: naisys=${naisysConnections.size}, supervisors=${supervisorConnections.length}`);
+        });
+    });
+    /** Update the hub access key used for authenticating new connections */
+    function updateHubAccessKey(newKey) {
+        hubAccessKey = newKey;
+    }
+    /** Disconnect all connected clients */
+    function disconnectAllClients() {
+        for (const connection of naisysConnections.values()) {
+            connection.disconnect();
+        }
+        for (const connection of supervisorConnections) {
+            connection.disconnect();
+        }
+    }
+    /** Broadcast an event to all supervisor connections */
+    function broadcastToSupervisors(event, payload) {
+        for (const conn of supervisorConnections) {
+            conn.sendMessage(event, payload);
+        }
+    }
+    /** Broadcast an event to all connections (naisys + supervisors) */
+    function broadcastToAll(event, payload) {
+        for (const conn of naisysConnections.values()) {
+            conn.sendMessage(event, payload);
+        }
+        for (const conn of supervisorConnections) {
+            conn.sendMessage(event, payload);
+        }
+    }
+    // Return control interface
+    return {
+        registerEvent,
+        unregisterEvent,
+        sendMessage,
+        broadcastToSupervisors,
+        broadcastToAll,
+        getConnectedClients: () => Array.from(naisysConnections.values()),
+        getConnectionByHostId: (hostId) => naisysConnections.get(hostId),
+        getConnectionCount: () => naisysConnections.size,
+        getSupervisorConnectionCount: () => supervisorConnections.length,
+        updateHubAccessKey,
+        disconnectAllClients,
+    };
+}
+//# sourceMappingURL=naisysServer.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@naisys/hub",
+  "version": "3.0.0-beta.10",
+  "description": "NAISYS Hub - Adds persistence and multi-instance coordination to NAISYS",
+  "type": "module",
+  "main": "dist/naisysHub.js",
+  "bin": {
+    "naisys-hub": "bin/naisys-hub"
+  },
+  "exports": {
+    ".": "./dist/naisysHub.js",
+    "./services/hubServerLog": "./dist/services/hubServerLog.js",
+    "./services/runnerServer": "./dist/services/runnerServer.js"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "dev": "tsx watch src/naisysHub.ts",
+    "start": "node dist/naisysHub.js",
+    "build": "tsc",
+    "type-check": "tsc --noEmit",
+    "npm:publish:dryrun": "npm publish --dry-run",
+    "npm:publish": "npm publish --access public"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "!dist/**/*.map",
+    "!dist/**/*.d.ts",
+    "!dist/**/*.d.ts.map"
+  ],
+  "peerDependencies": {
+    "@naisys/supervisor": "3.0.0-beta.10"
+  },
+  "peerDependenciesMeta": {
+    "@naisys/supervisor": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@naisys/common": "3.0.0-beta.10",
+    "@naisys/common-node": "3.0.0-beta.10",
+    "@naisys/hub-database": "3.0.0-beta.10",
+    "@naisys/hub-protocol": "3.0.0-beta.10",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "pino": "^10.3.1",
+    "socket.io": "^4.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}