@naisys/hub 3.0.0-beta.18 → 3.0.0-beta.19

package/.env.example

@@ -1,5 +1,5 @@
 # Hub server port
-HUB_PORT=3101
+SERVER_PORT=3101
 
-# NAISYS folder for logs and auto-generated TLS certificates
+# NAISYS folder for logs and file uploads
 NAISYS_FOLDER="~/.naisys"

package/dist/handlers/hubAttachmentService.js

@@ -7,221 +7,207 @@ import { pipeline, Writable } from "stream";
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 /**
  * HTTP attachment upload/download service.
- * Registers a `request` handler on the raw HTTPS server for `/attachments` paths.
- * Non-matching paths are ignored so Socket.IO still works.
+ * Registers Fastify routes for `/hub/attachments` paths.
  */
-export function createHubAttachmentService(httpServer, { hubDb }, logService) {
+export function createHubAttachmentService(fastify, { hubDb }, logService) {
     const naisysFolder = process.env.NAISYS_FOLDER || "";
-    httpServer.on("request", (req, res) => {
-        const url = new URL(req.url || "", `https://${req.headers.host || "localhost"}`);
-        const pathname = url.pathname;
-        if (pathname === "/hub/attachments" && req.method === "POST") {
-            handleUpload(url, req, res).catch((err) => {
-                logService.error(`[Hub:Attachment] Upload error: ${err}`);
-                if (!res.writableEnded) {
-                    res.writeHead(500, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Internal server error" }));
-                }
-            });
-        }
-        else if (pathname.startsWith("/hub/attachments/") &&
-            pathname !== "/hub/attachments/" &&
-            req.method === "GET") {
-            handleDownload(pathname, req, res).catch((err) => {
-                logService.error(`[Hub:Attachment] Download error: ${err}`);
-                if (!res.writableEnded) {
-                    res.writeHead(500, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Internal server error" }));
-                }
-            });
-        }
-        // Non-matching paths: do nothing — let Socket.IO handle them
-    });
     async function resolveUserByApiKey(apiKey) {
         const user = await hubDb.users.findUnique({ where: { api_key: apiKey } });
         return user?.id ?? null;
     }
-    async function handleUpload(url, req, res) {
-        const apiKey = extractBearerToken(req.headers.authorization);
-        const filename = url.searchParams.get("filename");
-        const fileSizeStr = url.searchParams.get("filesize");
-        const fileHash = url.searchParams.get("filehash");
-        const purpose = url.searchParams.get("purpose");
-        if (!apiKey) {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Missing Authorization header" }));
-            return;
-        }
-        if (!filename || !fileSizeStr || !fileHash || !purpose) {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                error: "Missing required query params: filename, filesize, filehash, purpose",
-            }));
-            return;
-        }
-        if (purpose !== "mail" && purpose !== "context") {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                error: 'Invalid purpose. Must be "mail" or "context"',
-            }));
-            return;
-        }
-        const fileSize = parseInt(fileSizeStr, 10);
-        if (isNaN(fileSize) || fileSize <= 0) {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid filesize" }));
-            return;
-        }
-        if (fileSize > MAX_FILE_SIZE) {
-            res.writeHead(413, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                error: `File too large. Max size: ${MAX_FILE_SIZE} bytes`,
-            }));
-            return;
-        }
-        const userId = await resolveUserByApiKey(apiKey);
-        if (userId == null) {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid API key" }));
-            return;
-        }
-        // Stream to temp file, then move to content-addressable path
-        const tmpDir = join(naisysFolder, "tmp", "hub", "attachments");
-        mkdirSync(tmpDir, { recursive: true });
-        const tmpPath = join(tmpDir, `${Date.now()}_${userId}_${Math.random().toString(36).slice(2)}`);
-        const hash = createHash("sha256");
-        let bytesWritten = 0;
-        const fileStream = createWriteStream(tmpPath);
-        const success = await new Promise((resolve) => {
-            const sizeChecker = new Writable({
-                write(chunk, _encoding, callback) {
-                    bytesWritten += chunk.length;
-                    if (bytesWritten > MAX_FILE_SIZE) {
-                        callback(new Error("File exceeds size limit"));
-                        return;
+    // Upload route — encapsulated so the raw content-type parser doesn't leak
+    fastify.register((scope, _opts, done) => {
+        // Prevent Fastify from consuming the request body — we stream it to disk
+        scope.removeAllContentTypeParsers();
+        scope.addContentTypeParser("*", (_request, _payload, cb) => {
+            cb(null);
+        });
+        scope.post("/hub/attachments", async (request, reply) => {
+            try {
+                const apiKey = extractBearerToken(request.headers.authorization);
+                if (!apiKey) {
+                    return reply
+                        .code(401)
+                        .send({ error: "Missing Authorization header" });
+                }
+                const url = new URL(request.url, `https://${request.headers.host || "localhost"}`);
+                const filename = url.searchParams.get("filename");
+                const fileSizeStr = url.searchParams.get("filesize");
+                const fileHash = url.searchParams.get("filehash");
+                const purpose = url.searchParams.get("purpose");
+                if (!filename || !fileSizeStr || !fileHash || !purpose) {
+                    return reply.code(400).send({
+                        error: "Missing required query params: filename, filesize, filehash, purpose",
+                    });
+                }
+                if (purpose !== "mail" && purpose !== "context") {
+                    return reply.code(400).send({
+                        error: 'Invalid purpose. Must be "mail" or "context"',
+                    });
+                }
+                const fileSize = parseInt(fileSizeStr, 10);
+                if (isNaN(fileSize) || fileSize <= 0) {
+                    return reply.code(400).send({ error: "Invalid filesize" });
+                }
+                if (fileSize > MAX_FILE_SIZE) {
+                    return reply.code(413).send({
+                        error: `File too large. Max size: ${MAX_FILE_SIZE} bytes`,
+                    });
+                }
+                const userId = await resolveUserByApiKey(apiKey);
+                if (userId == null) {
+                    return reply.code(401).send({ error: "Invalid API key" });
+                }
+                // Stream to temp file, then move to content-addressable path
+                const tmpDir = join(naisysFolder, "tmp", "hub", "attachments");
+                mkdirSync(tmpDir, { recursive: true });
+                const tmpPath = join(tmpDir, `${Date.now()}_${userId}_${Math.random().toString(36).slice(2)}`);
+                const hash = createHash("sha256");
+                let bytesWritten = 0;
+                const fileStream = createWriteStream(tmpPath);
+                // Stream the raw request body (not consumed by Fastify thanks to our parser)
+                const req = request.raw;
+                const success = await new Promise((resolve) => {
+                    const sizeChecker = new Writable({
+                        write(chunk, _encoding, callback) {
+                            bytesWritten += chunk.length;
+                            if (bytesWritten > MAX_FILE_SIZE) {
+                                callback(new Error("File exceeds size limit"));
+                                return;
+                            }
+                            hash.update(chunk);
+                            fileStream.write(chunk, callback);
+                        },
+                        final(callback) {
+                            fileStream.end(callback);
+                        },
+                    });
+                    pipeline(req, sizeChecker, (err) => {
+                        if (err) {
+                            fileStream.destroy();
+                            try {
+                                unlinkSync(tmpPath);
+                            }
+                            catch {
+                                /* ignore */
+                            }
+                            resolve(false);
+                        }
+                        else {
+                            resolve(true);
+                        }
+                    });
+                });
+                if (!success) {
+                    return reply
+                        .code(413)
+                        .send({ error: "File exceeds size limit during upload" });
+                }
+                // Verify hash
+                const computedHash = hash.digest("hex");
+                if (computedHash !== fileHash) {
+                    try {
+                        unlinkSync(tmpPath);
+                    }
+                    catch {
+                        /* ignore */
                     }
-                    hash.update(chunk);
-                    fileStream.write(chunk, callback);
-                },
-                final(callback) {
-                    fileStream.end(callback);
-                },
-            });
-            pipeline(req, sizeChecker, (err) => {
-                if (err) {
-                    fileStream.destroy();
+                    return reply.code(400).send({
+                        error: `Hash mismatch. Expected: ${fileHash}, got: ${computedHash}`,
+                    });
+                }
+                // Move to content-addressable path: attachments/hub/<first2>/<next2>/<fullhash>
+                const storageDir = join(naisysFolder, "attachments", "hub", computedHash.slice(0, 2), computedHash.slice(2, 4));
+                mkdirSync(storageDir, { recursive: true });
+                const storagePath = join(storageDir, computedHash);
+                if (existsSync(storagePath)) {
+                    // Dedup: identical file already on disk, discard temp
                     try {
                         unlinkSync(tmpPath);
                     }
                     catch {
                         /* ignore */
                     }
-                    resolve(false);
                 }
                 else {
-                    resolve(true);
+                    renameSync(tmpPath, storagePath);
                 }
-            });
-        });
-        if (!success) {
-            res.writeHead(413, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "File exceeds size limit during upload" }));
-            return;
-        }
-        // Verify hash
-        const computedHash = hash.digest("hex");
-        if (computedHash !== fileHash) {
-            try {
-                unlinkSync(tmpPath);
-            }
-            catch {
-                /* ignore */
-            }
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                error: `Hash mismatch. Expected: ${fileHash}, got: ${computedHash}`,
-            }));
-            return;
-        }
-        // Move to content-addressable path: attachments/hub/<first2>/<next2>/<fullhash>
-        const storageDir = join(naisysFolder, "attachments", "hub", computedHash.slice(0, 2), computedHash.slice(2, 4));
-        mkdirSync(storageDir, { recursive: true });
-        const storagePath = join(storageDir, computedHash);
-        if (existsSync(storagePath)) {
-            // Dedup: identical file already on disk, discard temp
-            try {
-                unlinkSync(tmpPath);
+                // Create DB record
+                const record = await hubDb.attachments.create({
+                    data: {
+                        public_id: randomBytes(8).toString("base64url").slice(0, 10),
+                        filepath: storagePath,
+                        filename,
+                        file_size: bytesWritten,
+                        file_hash: computedHash,
+                        purpose: purpose,
+                        uploaded_by: userId,
+                    },
+                });
+                const attachmentId = record.id;
+                logService.log(`[Hub:Attachment] Uploaded attachment ${attachmentId}: ${filename} (${bytesWritten} bytes) by user ${userId}`);
+                return reply.send({ id: attachmentId });
             }
-            catch {
-                /* ignore */
+            catch (err) {
+                logService.error(`[Hub:Attachment] Upload error: ${err}`);
+                return reply.code(500).send({ error: "Internal server error" });
             }
-        }
-        else {
-            renameSync(tmpPath, storagePath);
-        }
-        // Create DB record
-        const record = await hubDb.attachments.create({
-            data: {
-                public_id: randomBytes(8).toString("base64url").slice(0, 10),
-                filepath: storagePath,
-                filename,
-                file_size: bytesWritten,
-                file_hash: computedHash,
-                purpose: purpose,
-                uploaded_by: userId,
-            },
         });
-        const attachmentId = record.id;
-        logService.log(`[Hub:Attachment] Uploaded attachment ${attachmentId}: ${filename} (${bytesWritten} bytes) by user ${userId}`);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ id: attachmentId }));
-    }
-    async function handleDownload(pathname, req, res) {
-        const apiKey = extractBearerToken(req.headers.authorization);
+        done();
+    });
+    // Download routes
+    async function handleDownload(publicId, request, reply) {
+        const apiKey = extractBearerToken(request.headers.authorization);
         if (!apiKey) {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Missing Authorization header" }));
-            return;
+            return reply.code(401).send({ error: "Missing Authorization header" });
         }
         const userId = await resolveUserByApiKey(apiKey);
         if (userId == null) {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid API key" }));
-            return;
+            return reply.code(401).send({ error: "Invalid API key" });
         }
-        // Parse public ID from /hub/attachments/<publicId> or /hub/attachments/<publicId>/<filename>
-        const segments = pathname.slice("/hub/attachments/".length).split("/");
-        const publicId = segments[0];
         if (!publicId) {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Missing attachment ID" }));
-            return;
+            return reply.code(400).send({ error: "Missing attachment ID" });
         }
         const attachment = await hubDb.attachments.findUnique({
             where: { public_id: publicId },
         });
         if (!attachment) {
-            res.writeHead(404, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Attachment not found" }));
-            return;
+            return reply.code(404).send({ error: "Attachment not found" });
         }
         if (!existsSync(attachment.filepath)) {
-            res.writeHead(404, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Attachment file missing from disk" }));
-            return;
+            return reply
+                .code(404)
+                .send({ error: "Attachment file missing from disk" });
         }
         const stat = statSync(attachment.filepath);
         const contentType = mimeFromFilename(attachment.filename);
         const disposition = contentType.startsWith("image/")
             ? "inline"
             : "attachment";
-        res.writeHead(200, {
-            "Content-Type": contentType,
-            "Content-Disposition": `${disposition}; filename="${attachment.filename.replace(/"/g, '\\"')}"`,
-            "Content-Length": stat.size,
-        });
+        reply
+            .header("Content-Type", contentType)
+            .header("Content-Disposition", `${disposition}; filename="${attachment.filename.replace(/"/g, '\\"')}"`)
+            .header("Content-Length", stat.size);
         const readStream = createReadStream(attachment.filepath);
-        readStream.pipe(res);
+        return reply.send(readStream);
     }
+    fastify.get("/hub/attachments/:publicId/:filename", async (request, reply) => {
+        try {
+            return await handleDownload(request.params.publicId, request, reply);
+        }
+        catch (err) {
+            logService.error(`[Hub:Attachment] Download error: ${err}`);
+            return reply.code(500).send({ error: "Internal server error" });
+        }
+    });
+    fastify.get("/hub/attachments/:publicId", async (request, reply) => {
+        try {
+            return await handleDownload(request.params.publicId, request, reply);
+        }
+        catch (err) {
+            logService.error(`[Hub:Attachment] Download error: ${err}`);
+            return reply.code(500).send({ error: "Internal server error" });
+        }
+    });
 }
 //# sourceMappingURL=hubAttachmentService.js.map

package/dist/naisysHub.js

@@ -1,8 +1,8 @@
-import { ensureDotEnv, expandNaisysFolder } from "@naisys/common-node";
+import { createDualLogger, ensureDotEnv, expandNaisysFolder, runSetupWizard, } from "@naisys/common-node";
 import { createHubDatabaseService } from "@naisys/hub-database";
 import { program } from "commander";
 import dotenv from "dotenv";
-import http from "http";
+import Fastify from "fastify";
 import { Server } from "socket.io";
 import { fileURLToPath } from "url";
 import { createHubAccessKeyService } from "./handlers/hubAccessKeyService.js";
@@ -21,7 +21,6 @@ import { createHubUserService } from "./handlers/hubUserService.js";
 import { loadOrCreateAccessKey } from "./services/accessKeyService.js";
 import { seedAgentConfigs } from "./services/agentRegistrar.js";
 import { createHostRegistrar } from "./services/hostRegistrar.js";
-import { createHubServerLog } from "./services/hubServerLog.js";
 import { createNaisysServer } from "./services/naisysServer.js";
 /**
  * Starts the Hub server with sync service.
@@ -30,9 +29,9 @@ import { createNaisysServer } from "./services/naisysServer.js";
 export const startHub = async (startupType, startSupervisor, plugins, startupAgentPath) => {
     try {
         // Create log service first
-        const logService = createHubServerLog(startupType);
+        const logService = createDualLogger("hub-server.log");
         logService.log(`[Hub] Starting Hub server in ${startupType} mode...`);
-        const hubPort = Number(process.env.HUB_PORT) || 3101;
+        const serverPort = Number(process.env.SERVER_PORT) || 3101;
         // Load or generate hub access key for client authentication
         const hubAccessKey = loadOrCreateAccessKey();
         const naisysFolder = process.env.NAISYS_FOLDER || "";
@@ -43,11 +42,12 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         await seedAgentConfigs(hubDatabaseService, logService, startupAgentPath);
         // Create host registrar for tracking NAISYS instance connections
         const hostRegistrar = await createHostRegistrar(hubDatabaseService);
-        // Create HTTP server and Socket.IO instance (TLS is handled by the reverse proxy)
-        const httpServer = http.createServer();
-        // Register HTTP attachment upload/download handler before Socket.IO
-        createHubAttachmentService(httpServer, hubDatabaseService, logService);
-        const io = new Server(httpServer, {
+        // Create Fastify instance (TLS is handled by the reverse proxy)
+        const fastify = Fastify();
+        // Register HTTP attachment upload/download routes
+        createHubAttachmentService(fastify, hubDatabaseService, logService);
+        // Attach Socket.IO to the underlying HTTP server
+        const io = new Server(fastify.server, {
             path: "/hub/socket.io",
             cors: {
                 origin: "*", // In production, restrict this
@@ -79,30 +79,28 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         const agentService = createHubAgentService(naisysServer, hubDatabaseService, logService, heartbeatService, sendMailService, hostRegistrar);
         // Register hub mail service for mail events from NAISYS instances
         createHubMailService(naisysServer, hubDatabaseService, logService, heartbeatService, sendMailService, agentService, costService, configService);
-        // Start listening
-        await new Promise((resolve, reject) => {
-            httpServer.once("error", reject);
-            httpServer.listen(hubPort, () => {
-                httpServer.removeListener("error", reject);
-                logService.log(`[Hub] Server listening on port ${hubPort}`);
-                resolve();
-            });
-        });
-        logService.log(`[Hub] Running on http://localhost:${hubPort}/hub, logs written to file`);
-        logService.disableConsole();
         /**
          * There should be no dependency between supervisor and hub
          * Sharing the same process space is to save 150 mb of node.js runtime memory on small servers
          */
-        let supervisorPort;
         if (startSupervisor) {
             // Don't import the whole fastify web server module tree unless needed
             // Use variable to avoid compile-time type dependency on @naisys/supervisor (allows parallel builds)
             const supervisorModule = "@naisys/supervisor";
-            const { startServer } = (await import(supervisorModule));
-            supervisorPort = await startServer("hosted", plugins, hubPort);
+            const { supervisorPlugin } = (await import(supervisorModule));
+            await fastify.register(supervisorPlugin, {
+                plugins,
+                serverPort,
+                hosted: true,
+            });
         }
-        return { hubPort, supervisorPort };
+        // Start listening
+        await fastify.listen({ port: serverPort, host: "0.0.0.0" });
+        logService.log(`[Hub] Running on http://localhost:${serverPort}/hub, logs written to file`);
+        if (startupType === "hosted") {
+            logService.disableConsole();
+        }
+        return { serverPort };
     }
     catch (err) {
         console.error("[Hub] Failed to start hub server:", err);
@@ -112,16 +110,36 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
 // Start server if this file is run directly
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
     dotenv.config({ quiet: true });
-    await ensureDotEnv(new URL("../.env.example", import.meta.url));
+    const hubWizardConfig = {
+        title: "NAISYS Hub Setup",
+        sections: [
+            {
+                type: "fields",
+                comment: "Hub server configuration",
+                fields: [
+                    { key: "NAISYS_FOLDER", label: "NAISYS Data Folder" },
+                    { key: "SERVER_PORT", label: "Server Port" },
+                ],
+            },
+        ],
+    };
+    const hubExampleUrl = new URL("../.env.example", import.meta.url);
+    if (process.argv.includes("--setup")) {
+        const { default: path } = await import("path");
+        await runSetupWizard(path.resolve(".env"), hubExampleUrl, hubWizardConfig);
+        process.exit(0);
+    }
+    await ensureDotEnv(hubExampleUrl, hubWizardConfig);
     expandNaisysFolder();
     program
         .argument("[agent-path]", "Path to agent configuration file to seed the database (optional)")
         .option("--supervisor", "Start Supervisor web server")
         .option("--erp", "Start ERP web app (requires --supervisor)")
+        .option("--setup", "Run interactive setup wizard")
         .parse();
     const plugins = [];
     if (program.opts().erp)
         plugins.push("erp");
-    void startHub("standalone", program.opts().supervisor, plugins, program.args[0]);
+    void startHub("standalone", program.opts().supervisor, plugins, program.args[0] || ".");
 }
 //# sourceMappingURL=naisysHub.js.map

package/dist/services/hostRegistrar.js

@@ -4,13 +4,20 @@ export async function createHostRegistrar({ hubDb }) {
     const hostsById = new Map();
     // Seed the cache from the database
     const rows = await hubDb.hosts.findMany({
-        select: { id: true, name: true, restricted: true, host_type: true },
+        select: {
+            id: true,
+            name: true,
+            restricted: true,
+            host_type: true,
+            last_version: true,
+        },
     });
     for (const row of rows) {
         hostsById.set(row.id, {
             hostName: row.name,
             restricted: row.restricted,
             hostType: row.host_type,
+            lastVersion: row.last_version ?? "",
         });
     }
     /**
@@ -18,7 +25,7 @@ export async function createHostRegistrar({ hubDb }) {
      * updates last_active on every call.
      * @returns The host's autoincrement id
      */
-    async function registerHost(hostName, hostType, lastIp) {
+    async function registerHost(hostName, hostType, lastIp, clientVersion) {
         hostName = toUrlSafeKey(hostName);
         const existing = await hubDb.hosts.findUnique({
             where: { name: hostName },
@@ -30,12 +37,14 @@ export async function createHostRegistrar({ hubDb }) {
                     last_active: new Date().toISOString(),
                     host_type: hostType,
                     last_ip: lastIp,
+                    last_version: clientVersion,
                 },
             });
             hostsById.set(existing.id, {
                 hostName,
                 restricted: existing.restricted,
                 hostType,
+                lastVersion: clientVersion,
             });
             return existing.id;
         }
@@ -44,10 +53,16 @@ export async function createHostRegistrar({ hubDb }) {
                 name: hostName,
                 host_type: hostType,
                 last_ip: lastIp,
+                last_version: clientVersion,
                 last_active: new Date().toISOString(),
             },
         });
-        hostsById.set(created.id, { hostName, restricted: false, hostType });
+        hostsById.set(created.id, {
+            hostName,
+            restricted: false,
+            hostType,
+            lastVersion: clientVersion,
+        });
         return created.id;
     }
     /** Returns all known hosts (from DB + any newly registered) */
@@ -57,12 +72,19 @@ export async function createHostRegistrar({ hubDb }) {
             hostName: entry.hostName,
             restricted: entry.restricted,
             hostType: entry.hostType,
+            lastVersion: entry.lastVersion,
         }));
     }
     /** Re-read all hosts from DB and replace the in-memory cache */
     async function refreshHosts() {
         const rows = await hubDb.hosts.findMany({
-            select: { id: true, name: true, restricted: true, host_type: true },
+            select: {
+                id: true,
+                name: true,
+                restricted: true,
+                host_type: true,
+                last_version: true,
+            },
         });
         hostsById.clear();
         for (const row of rows) {
@@ -70,6 +92,7 @@ export async function createHostRegistrar({ hubDb }) {
                 hostName: row.name,
                 restricted: row.restricted,
                 hostType: row.host_type,
+                lastVersion: row.last_version ?? "",
             });
         }
     }

package/dist/services/naisysServer.js

@@ -70,7 +70,8 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
         }
         try {
             const hostType = (typeof rawHostType === "string" ? rawHostType : "naisys");
-            const hostId = await hostRegistrar.registerHost(hostName, hostType, socket.handshake.address);
+            const resolvedVersion = typeof clientVersion === "string" ? clientVersion : "";
+            const hostId = await hostRegistrar.registerHost(hostName, hostType, socket.handshake.address, resolvedVersion);
             // Reject duplicate naisys connections (supervisors may have multiple)
             if (hostType === "naisys" && naisysConnections.has(hostId)) {
                 logService.log(`[Hub] Connection rejected: host '${hostName}' is already connected`);
@@ -79,8 +80,7 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
             socket.data.hostId = hostId;
             socket.data.hostName = hostName;
             socket.data.hostType = hostType;
-            socket.data.clientVersion =
-                typeof clientVersion === "string" ? clientVersion : "";
+            socket.data.clientVersion = resolvedVersion;
             next();
         }
         catch (err) {

package/dist/version.js

@@ -1,7 +1,7 @@
-import { getGitCommitHash } from "@naisys/common-node";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { getGitCommitHash } from "@naisys/common-node";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Read the hub's own package.json (one level up from dist/)
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naisys/hub",
-  "version": "3.0.0-beta.18",
+  "version": "3.0.0-beta.19",
   "description": "NAISYS Hub - Adds persistence and multi-instance coordination to NAISYS",
   "type": "module",
   "main": "dist/naisysHub.js",
@@ -30,7 +30,7 @@
     "!dist/**/*.d.ts.map"
   ],
   "peerDependencies": {
-    "@naisys/supervisor": "3.0.0-beta.18"
+    "@naisys/supervisor": "3.0.0-beta.19"
   },
   "peerDependenciesMeta": {
     "@naisys/supervisor": {
@@ -38,13 +38,13 @@
     }
   },
   "dependencies": {
-    "@naisys/common": "3.0.0-beta.18",
-    "@naisys/common-node": "3.0.0-beta.18",
-    "@naisys/hub-database": "3.0.0-beta.18",
-    "@naisys/hub-protocol": "3.0.0-beta.18",
+    "@naisys/common": "3.0.0-beta.19",
+    "@naisys/common-node": "3.0.0-beta.19",
+    "@naisys/hub-database": "3.0.0-beta.19",
+    "@naisys/hub-protocol": "3.0.0-beta.19",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
-    "pino": "^10.3.1",
+    "fastify": "^5.8.2",
     "socket.io": "^4.8.3"
   },
   "devDependencies": {

package/dist/services/hubServerLog.js

@@ -1,47 +0,0 @@
-import path from "path";
-import pino from "pino";
-/**
- * Creates a log service for the hub.
- * In hosted mode, logs to a file using pino.
- * In standalone mode, uses console.log.
- */
-export function createHubServerLog(startupType) {
-    if (startupType === "hosted") {
-        const logPath = path.join(process.env.NAISYS_FOLDER || "", "logs", "hub-server.log");
-        const logger = pino({
-            level: "info",
-            transport: {
-                target: "pino/file",
-                options: {
-                    destination: logPath,
-                    mkdir: true,
-                },
-            },
-        });
-        let consoleEnabled = true;
-        return {
-            log: (message) => {
-                logger.info(message);
-                if (consoleEnabled) {
-                    console.log(message);
-                }
-            },
-            error: (message) => {
-                logger.error(message);
-                if (consoleEnabled) {
-                    console.error(message);
-                }
-            },
-            disableConsole: () => {
-                consoleEnabled = false;
-            },
-        };
-    }
-    // Standalone mode - use console
-    return {
-        log: (message) => console.log(message),
-        error: (message) => console.error(message),
-        disableConsole: () => { },
-    };
-}
-//# sourceMappingURL=hubServerLog.js.map