@naisys/hub 3.0.0-beta.10

package/dist/handlers/hubSendMailService.js

@@ -0,0 +1,126 @@
+import { HubEvents, } from "@naisys/hub-protocol";
+/** Pure send-mail service with no auto-start logic, breaking the circular dependency */
+export function createHubSendMailService(naisysServer, { hubDb }, heartbeatService) {
+    /** Send a mail message directly by user IDs */
+    async function sendMail(params) {
+        const now = new Date();
+        // Build participants string from usernames (sorted alphabetically)
+        const allUserIds = [
+            ...new Set([params.fromUserId, ...params.recipientUserIds]),
+        ];
+        const users = await hubDb.users.findMany({
+            where: { id: { in: allUserIds } },
+            select: { username: true },
+        });
+        const participants = users
+            .map((u) => u.username)
+            .sort()
+            .join(",");
+        // Atomic transaction: create message, link attachments, add recipients, update notifications
+        const message = await hubDb.$transaction(async (hubTx) => {
+            const msg = await hubTx.mail_messages.create({
+                data: {
+                    from_user_id: params.fromUserId,
+                    host_id: params.hostId,
+                    kind: params.kind,
+                    participants,
+                    subject: params.subject,
+                    body: params.body,
+                    created_at: now,
+                },
+            });
+            // Link uploaded attachments to the new message via junction table
+            if (params.attachmentIds?.length) {
+                // Verify all attachment IDs exist
+                const found = await hubTx.attachments.findMany({
+                    where: { id: { in: params.attachmentIds } },
+                    select: { id: true },
+                });
+                if (found.length !== params.attachmentIds.length) {
+                    const foundIds = new Set(found.map((a) => a.id));
+                    const missing = params.attachmentIds.filter((id) => !foundIds.has(id));
+                    throw new Error(`Attachments not found: ${missing.join(", ")}`);
+                }
+                await hubTx.mail_attachments.createMany({
+                    data: params.attachmentIds.map((attId) => ({
+                        message_id: msg.id,
+                        attachment_id: attId,
+                    })),
+                });
+            }
+            await hubTx.mail_recipients.createMany({
+                data: params.recipientUserIds.map((userId) => ({
+                    message_id: msg.id,
+                    user_id: userId,
+                    type: "to",
+                    created_at: now,
+                })),
+            });
+            // Add sender as 'from' recipient for archive tracking (pre-read since they wrote it)
+            if (!params.recipientUserIds.includes(params.fromUserId)) {
+                await hubTx.mail_recipients.create({
+                    data: {
+                        message_id: msg.id,
+                        user_id: params.fromUserId,
+                        type: "from",
+                        read_at: now,
+                        created_at: now,
+                    },
+                });
+            }
+            const notificationField = params.kind === "chat" ? "latest_chat_id" : "latest_mail_id";
+            await hubTx.user_notifications.updateMany({
+                where: { user_id: { in: params.recipientUserIds } },
+                data: { [notificationField]: msg.id },
+            });
+            return msg;
+        });
+        const heartbeatField = params.kind === "chat" ? "latestChatId" : "latestMailId";
+        for (const userId of params.recipientUserIds) {
+            heartbeatService.updateAgentNotification(userId, heartbeatField, message.id);
+        }
+        heartbeatService.throttledPushAgentsStatus();
+        const targetHostIds = new Set();
+        for (const userId of params.recipientUserIds) {
+            for (const hId of heartbeatService.findHostsForAgent(userId)) {
+                targetHostIds.add(hId);
+            }
+        }
+        if (targetHostIds.size > 0) {
+            const payload = {
+                recipientUserIds: params.recipientUserIds,
+                kind: params.kind,
+            };
+            for (const targetHostId of targetHostIds) {
+                naisysServer.sendMessage(targetHostId, HubEvents.MAIL_RECEIVED, payload);
+            }
+        }
+        // Query attachment metadata for the push if there are attachments
+        let attachments;
+        if (params.attachmentIds?.length) {
+            const rows = await hubDb.attachments.findMany({
+                where: { id: { in: params.attachmentIds } },
+                select: { public_id: true, filename: true, file_size: true },
+            });
+            attachments = rows.map((r) => ({
+                id: r.public_id,
+                filename: r.filename,
+                fileSize: r.file_size,
+            }));
+        }
+        // Push full message data to supervisor connections
+        naisysServer.broadcastToSupervisors(HubEvents.MAIL_PUSH, {
+            recipientUserIds: params.recipientUserIds,
+            fromUserId: params.fromUserId,
+            kind: params.kind,
+            messageId: message.id,
+            subject: params.subject,
+            body: params.body,
+            createdAt: now.toISOString(),
+            participants,
+            attachments,
+        });
+    }
+    return { sendMail };
+}
+//# sourceMappingURL=hubSendMailService.js.map

package/dist/handlers/hubUserService.js

@@ -0,0 +1,62 @@
+import { HubEvents } from "@naisys/hub-protocol";
+/** Pushes the user list to NAISYS instances when they connect or when users change */
+export function createHubUserService(naisysServer, { hubDb }, logService) {
+    async function buildUserListPayload() {
+        const dbUsers = await hubDb.users.findMany({
+            where: { archived: false },
+            select: {
+                id: true,
+                username: true,
+                enabled: true,
+                config: true,
+                lead_user_id: true,
+                api_key: true,
+                user_hosts: {
+                    select: { host_id: true },
+                },
+            },
+        });
+        const users = dbUsers.map((u) => ({
+            userId: u.id,
+            username: u.username,
+            enabled: u.enabled,
+            leadUserId: u.lead_user_id || undefined,
+            config: JSON.parse(u.config),
+            assignedHostIds: u.user_hosts.length > 0
+                ? u.user_hosts.map((uh) => uh.host_id)
+                : undefined,
+            apiKey: u.api_key || undefined,
+        }));
+        return { success: true, users };
+    }
+    async function broadcastUserList() {
+        try {
+            const payload = await buildUserListPayload();
+            logService.log(`[Hub:Users] Broadcasting ${payload.users?.length ?? 0} users to all clients`);
+            naisysServer.broadcastToAll(HubEvents.USERS_UPDATED, payload);
+        }
+        catch (error) {
+            logService.error(`[Hub:Users] Error broadcasting user list: ${error}`);
+        }
+    }
+    // Push user list to newly connected clients
+    naisysServer.registerEvent(HubEvents.CLIENT_CONNECTED, async (hostId, connection) => {
+        try {
+            const payload = await buildUserListPayload();
+            logService.log(`[Hub:Users] Pushing ${payload.users?.length ?? 0} users to instance ${hostId}`);
+            connection.sendMessage(HubEvents.USERS_UPDATED, payload);
+        }
+        catch (error) {
+            logService.error(`[Hub:Users] Error querying users for instance ${hostId}: ${error}`);
+            connection.sendMessage(HubEvents.USERS_UPDATED, {
+                success: false,
+                error: String(error),
+            });
+        }
+    });
+    // Broadcast user list to all clients when users are created/edited
+    naisysServer.registerEvent(HubEvents.USERS_CHANGED, async () => {
+        await broadcastUserList();
+    });
+}
+//# sourceMappingURL=hubUserService.js.map

package/dist/naisysHub.js

@@ -0,0 +1,126 @@
+import { expandNaisysFolder } from "@naisys/common-node";
+import { createHubDatabaseService } from "@naisys/hub-database";
+import { program } from "commander";
+import dotenv from "dotenv";
+import http from "http";
+import { Server } from "socket.io";
+import { fileURLToPath } from "url";
+import { createHubAccessKeyService } from "./handlers/hubAccessKeyService.js";
+import { createHubAgentService } from "./handlers/hubAgentService.js";
+import { createHubAttachmentService } from "./handlers/hubAttachmentService.js";
+import { createHubConfigService } from "./handlers/hubConfigService.js";
+import { createHubCostService } from "./handlers/hubCostService.js";
+import { createHubHeartbeatService } from "./handlers/hubHeartbeatService.js";
+import { createHubHostService } from "./handlers/hubHostService.js";
+import { createHubLogService } from "./handlers/hubLogService.js";
+import { createHubMailService } from "./handlers/hubMailService.js";
+import { createHubModelsService } from "./handlers/hubModelsService.js";
+import { createHubRunService } from "./handlers/hubRunService.js";
+import { createHubSendMailService } from "./handlers/hubSendMailService.js";
+import { createHubUserService } from "./handlers/hubUserService.js";
+import { seedAgentConfigs } from "./services/agentRegistrar.js";
+import { loadOrCreateAccessKey } from "./services/accessKeyService.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.
+ * Can be called standalone or inline from naisys with --integrated-hub flag.
+ */
+export const startHub = async (startupType, startSupervisor, plugins, startupAgentPath) => {
+    try {
+        // Create log service first
+        const logService = createHubServerLog(startupType);
+        logService.log(`[Hub] Starting Hub server in ${startupType} mode...`);
+        const hubPort = Number(process.env.HUB_PORT) || 3101;
+        // Load or generate hub access key for client authentication
+        const hubAccessKey = loadOrCreateAccessKey();
+        const naisysFolder = process.env.NAISYS_FOLDER || "";
+        logService.log(`[Hub] Hub access key located at: ${naisysFolder}/cert/hub-access-key`);
+        // Schema version for sync protocol - should match NAISYS instance
+        const hubDatabaseService = await createHubDatabaseService();
+        // Seed database with agent configs from yaml files (one-time, skips if non-empty)
+        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, {
+            path: "/hub/socket.io",
+            cors: {
+                origin: "*", // In production, restrict this
+                methods: ["GET", "POST"],
+            },
+        });
+        const naisysServer = createNaisysServer(io, hubAccessKey, logService, hostRegistrar);
+        // Register hub access key rotation handler
+        createHubAccessKeyService(naisysServer, logService);
+        // Register hub config service for config_get requests from NAISYS instances
+        const configService = await createHubConfigService(naisysServer, hubDatabaseService, logService);
+        // Register hub user service for user_list requests from NAISYS instances
+        createHubUserService(naisysServer, hubDatabaseService, logService);
+        // Register hub models service for seeding and broadcasting models
+        await createHubModelsService(naisysServer, hubDatabaseService, logService);
+        // Register hub host service for broadcasting connected host list
+        createHubHostService(naisysServer, hostRegistrar, logService);
+        // Register hub run service for session_create/session_increment requests
+        createHubRunService(naisysServer, hubDatabaseService, logService);
+        // Register hub heartbeat service for NAISYS instance heartbeat tracking
+        const heartbeatService = createHubHeartbeatService(naisysServer, hubDatabaseService, logService);
+        // Register hub log service for log_write events from NAISYS instances
+        createHubLogService(naisysServer, hubDatabaseService, logService, heartbeatService);
+        // Register hub cost service for cost_write events from NAISYS instances
+        const costService = createHubCostService(naisysServer, hubDatabaseService, logService, heartbeatService, configService);
+        // Register hub send mail service (pure mail sending, no auto-start logic)
+        const sendMailService = createHubSendMailService(naisysServer, hubDatabaseService, heartbeatService);
+        // Register hub agent service for agent_start requests routed to target hosts
+        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);
+        }
+        return { hubPort, supervisorPort };
+    }
+    catch (err) {
+        console.error("[Hub] Failed to start hub server:", err);
+        process.exit(1);
+    }
+};
+// Start server if this file is run directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    dotenv.config({ quiet: true });
+    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)")
+        .parse();
+    const plugins = [];
+    if (program.opts().erp)
+        plugins.push("erp");
+    void startHub("standalone", program.opts().supervisor, plugins, program.args[0]);
+}
+//# sourceMappingURL=naisysHub.js.map

package/dist/services/accessKeyService.js

@@ -0,0 +1,32 @@
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+/**
+ * Loads existing hub access key from NAISYS_FOLDER/cert/hub-access-key
+ * or generates a new random key. The access key is used by clients to
+ * authenticate their Socket.IO connections to the hub.
+ */
+export function loadOrCreateAccessKey() {
+    const naisysFolder = process.env.NAISYS_FOLDER || "";
+    const certDir = join(naisysFolder, "cert");
+    const accessKeyPath = join(certDir, "hub-access-key");
+    if (existsSync(accessKeyPath)) {
+        return readFileSync(accessKeyPath, "utf-8").trim();
+    }
+    mkdirSync(certDir, { recursive: true });
+    const accessKey = randomBytes(32).toString("hex");
+    writeFileSync(accessKeyPath, accessKey, { mode: 0o600 });
+    return accessKey;
+}
+/**
+ * Rotates the hub access key by generating a new random secret.
+ * Writes the new key to disk and returns it.
+ */
+export function rotateAccessKey() {
+    const naisysFolder = process.env.NAISYS_FOLDER || "";
+    const accessKeyPath = join(naisysFolder, "cert", "hub-access-key");
+    const newAccessKey = randomBytes(32).toString("hex");
+    writeFileSync(accessKeyPath, newAccessKey, { mode: 0o600 });
+    return newAccessKey;
+}
+//# sourceMappingURL=accessKeyService.js.map

package/dist/services/agentRegistrar.js

@@ -0,0 +1,53 @@
+import { toUrlSafeKey } from "@naisys/common";
+import { loadAgentConfigs } from "@naisys/common-node";
+import { randomBytes, randomUUID } from "crypto";
+/** Seeds agent configs from YAML files into an empty database. Skips if users already exist. */
+export async function seedAgentConfigs({ hubDb }, logService, startupAgentPath) {
+    // Check if users table already has rows (seed-once pattern)
+    const count = await hubDb.users.count();
+    const hasUsers = count > 0;
+    if (hasUsers) {
+        logService.log("[Hub:AgentRegistrar] Agents already seeded");
+        return;
+    }
+    // Default to CWD when no path specified (matches standalone hub behavior)
+    const users = loadAgentConfigs(startupAgentPath || "");
+    await seedUsersToDatabase(hubDb, logService, users);
+}
+async function seedUsersToDatabase(hubDb, logService, users) {
+    // First pass: create all users, build loader userId → DB id map
+    const loaderIdToDbId = new Map();
+    for (const user of users.values()) {
+        const safeUsername = toUrlSafeKey(user.username);
+        const dbUser = await hubDb.users.create({
+            data: {
+                uuid: randomUUID(),
+                username: safeUsername,
+                title: user.config.title,
+                config: JSON.stringify({ ...user.config, username: safeUsername }),
+                api_key: randomBytes(32).toString("hex"),
+            },
+        });
+        loaderIdToDbId.set(user.userId, dbUser.id);
+        await hubDb.user_notifications.create({
+            data: {
+                user_id: dbUser.id,
+            },
+        });
+    }
+    // Second pass: update lead_user_id relationships
+    for (const user of users.values()) {
+        if (user.leadUserId !== undefined) {
+            const dbId = loaderIdToDbId.get(user.userId);
+            const leadDbId = loaderIdToDbId.get(user.leadUserId);
+            if (dbId !== undefined && leadDbId !== undefined) {
+                await hubDb.users.update({
+                    where: { id: dbId },
+                    data: { lead_user_id: leadDbId },
+                });
+            }
+        }
+    }
+    logService.log(`[Hub:AgentRegistrar] Seeded ${users.size} users into database`);
+}
+//# sourceMappingURL=agentRegistrar.js.map

package/dist/services/hostRegistrar.js

@@ -0,0 +1,82 @@
+import { toUrlSafeKey } from "@naisys/common";
+export async function createHostRegistrar({ hubDb }) {
+    /** Cache of all known hosts keyed by id */
+    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 },
+    });
+    for (const row of rows) {
+        hostsById.set(row.id, {
+            hostName: row.name,
+            restricted: row.restricted,
+            hostType: row.host_type,
+        });
+    }
+    /**
+     * Register a NAISYS instance by name. Creates a new record if not found,
+     * updates last_active on every call.
+     * @returns The host's autoincrement id
+     */
+    async function registerHost(hostName, hostType, lastIp) {
+        hostName = toUrlSafeKey(hostName);
+        const existing = await hubDb.hosts.findUnique({
+            where: { name: hostName },
+        });
+        if (existing) {
+            await hubDb.hosts.update({
+                where: { id: existing.id },
+                data: {
+                    last_active: new Date().toISOString(),
+                    host_type: hostType,
+                    last_ip: lastIp,
+                },
+            });
+            hostsById.set(existing.id, {
+                hostName,
+                restricted: existing.restricted,
+                hostType,
+            });
+            return existing.id;
+        }
+        const created = await hubDb.hosts.create({
+            data: {
+                name: hostName,
+                host_type: hostType,
+                last_ip: lastIp,
+                last_active: new Date().toISOString(),
+            },
+        });
+        hostsById.set(created.id, { hostName, restricted: false, hostType });
+        return created.id;
+    }
+    /** Returns all known hosts (from DB + any newly registered) */
+    function getAllHosts() {
+        return Array.from(hostsById, ([hostId, entry]) => ({
+            hostId,
+            hostName: entry.hostName,
+            restricted: entry.restricted,
+            hostType: entry.hostType,
+        }));
+    }
+    /** 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 },
+        });
+        hostsById.clear();
+        for (const row of rows) {
+            hostsById.set(row.id, {
+                hostName: row.name,
+                restricted: row.restricted,
+                hostType: row.host_type,
+            });
+        }
+    }
+    return {
+        registerHost,
+        getAllHosts,
+        refreshHosts,
+    };
+}
+//# sourceMappingURL=hostRegistrar.js.map

package/dist/services/hubServerLog.js

@@ -0,0 +1,47 @@
+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

package/dist/services/naisysConnection.js

@@ -0,0 +1,45 @@
+/**
+ * Handles the lifecycle of a single NAISYS instance connection to the hub.
+ * Each connected NAISYS instance gets its own NaisysConnection instance.
+ */
+export function createNaisysConnection(socket, connectionInfo, raiseEvent, logService) {
+    const { hostId, hostName, connectedAt, hostType } = connectionInfo;
+    logService.log(`[Hub:Connection] NAISYS instance connected: ${hostName} (${hostId})`);
+    // Forward all socket events to hub's emit function
+    // Note: Socket.IO passes (eventName, ...args) where last arg may be an ack callback
+    socket.onAny((eventName, ...args) => {
+        logService.log(`[Hub:Connection] Received ${eventName} from ${hostName}`);
+        // Pass all args including any ack callback (usually data and optional ack)
+        raiseEvent(eventName, hostId, ...args);
+    });
+    // Handle disconnect
+    socket.on("disconnect", (reason) => {
+        logService.log(`[Hub:Connection] NAISYS instance disconnected: ${hostName} (${hostId}) - ${reason}`);
+    });
+    /**
+     * Send a message to this client's socket.
+     * If ack callback is provided, waits for client acknowledgement.
+     */
+    function sendMessage(event, payload, ack) {
+        if (ack) {
+            socket.emit(event, payload, ack);
+        }
+        else {
+            socket.emit(event, payload);
+        }
+    }
+    /** Forcefully disconnect this client */
+    function disconnect() {
+        socket.disconnect(true);
+    }
+    return {
+        sendMessage,
+        disconnect,
+        getHostId: () => hostId,
+        getHostName: () => hostName,
+        getConnectedAt: () => connectedAt,
+        getSocketId: () => socket.id,
+        getHostType: () => hostType,
+    };
+}
+//# sourceMappingURL=naisysConnection.js.map