@naisys/hub 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/handlers/hubConfigService.js

@@ -1,4 +1,4 @@
-import { buildClientConfig } from "@naisys/common";
+import { buildClientConfig, builtInImageModels, builtInLlmModels, } from "@naisys/common";
 import { HubEvents } from "@naisys/hub-protocol";
 import dotenv from "dotenv";
 /** Pushes the global config to NAISYS instances when they connect or when variables change */
@@ -7,6 +7,10 @@ export async function createHubConfigService(naisysServer, { hubDb }, logService
         success: false,
         error: "Not yet loaded",
     };
+    // API key variable names referenced by built-in models — always sensitive
+    const sensitiveKeys = new Set([...builtInLlmModels, ...builtInImageModels]
+        .map((m) => m.apiKeyVar)
+        .filter(Boolean));
     // Seed DB from .env on first run
     const existing = await hubDb.variables.findMany();
     if (existing.length > 0) {
@@ -22,6 +26,7 @@ export async function createHubConfigService(naisysServer, { hubDb }, logService
                 data: entries.map(([key, value]) => ({
                     key,
                     value,
+                    sensitive: sensitiveKeys.has(key),
                     created_by: "hub",
                     updated_by: "hub",
                 })),
@@ -89,7 +94,9 @@ export async function createHubConfigService(naisysServer, { hubDb }, logService
         getConfig: () => cachedConfig,
     };
 }
-/** Create variable placeholders if they don't already exist */
+/** Create variable placeholders if they don't already exist.
+ *  If a variable already exists and `sensitive` is explicitly true,
+ *  upgrade it to sensitive (e.g. API keys seeded before model init). */
 export async function ensureVariables(hubDb, keys) {
     for (const { key, sensitive } of keys) {
         const existing = await hubDb.variables.findUnique({ where: { key } });
@@ -105,6 +112,12 @@ export async function ensureVariables(hubDb, keys) {
                 },
             });
         }
+        else if (sensitive && !existing.sensitive) {
+            await hubDb.variables.update({
+                where: { key },
+                data: { sensitive: true },
+            });
+        }
     }
 }
 //# sourceMappingURL=hubConfigService.js.map

package/dist/handlers/hubHostService.js

@@ -11,7 +11,11 @@ export function createHubHostService(naisysServer, hostRegistrar, logService) {
         const hosts = hostRegistrar.getAllHosts().map((h) => {
             const client = clientByHostId.get(h.hostId);
             return {
-                ...h,
+                hostId: h.hostId,
+                hostName: h.hostName,
+                machineId: h.machineId,
+                restricted: h.restricted,
+                hostType: h.hostType,
                 online: !!client,
                 version: client?.getClientVersion() || "",
             };

package/dist/naisysHub.js

@@ -1,4 +1,4 @@
-import { createDualLogger, ensureDotEnv, expandNaisysFolder, runSetupWizard, } from "@naisys/common-node";
+import { createDualLogger, cwdWithTilde, ensureDotEnv, expandNaisysFolder, runSetupWizard, } from "@naisys/common-node";
 import { createHubDatabaseService } from "@naisys/hub-database";
 import { program } from "commander";
 import dotenv from "dotenv";
@@ -28,6 +28,7 @@ import { createNaisysServer } from "./services/naisysServer.js";
  */
 export const startHub = async (startupType, startSupervisor, plugins, startupAgentPath) => {
     try {
+        const agentPath = startupAgentPath || ".";
         // Create log service first
         const logService = createDualLogger("hub-server.log");
         logService.log(`[Hub] Starting Hub server in ${startupType} mode...`);
@@ -39,7 +40,7 @@ export const startHub = async (startupType, startSupervisor, plugins, startupAge
         // 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);
+        await seedAgentConfigs(hubDatabaseService, logService, agentPath);
         // Create host registrar for tracking NAISYS instance connections
         const hostRegistrar = await createHostRegistrar(hubDatabaseService);
         // Create Fastify instance (TLS is handled by the reverse proxy)
@@ -117,7 +118,7 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
                 type: "fields",
                 comment: "Hub server configuration",
                 fields: [
-                    { key: "NAISYS_FOLDER", label: "NAISYS Data Folder" },
+                    { key: "NAISYS_FOLDER", label: "NAISYS Data Folder", defaultValue: cwdWithTilde() },
                     { key: "SERVER_PORT", label: "Server Port" },
                 ],
             },
@@ -127,7 +128,7 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
     if (process.argv.includes("--setup")) {
         const { default: path } = await import("path");
         await runSetupWizard(path.resolve(".env"), hubExampleUrl, hubWizardConfig);
-        process.exit(0);
+        expandNaisysFolder();
     }
     await ensureDotEnv(hubExampleUrl, hubWizardConfig);
     expandNaisysFolder();
@@ -140,6 +141,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
     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

@@ -1,4 +1,5 @@
 import { toUrlSafeKey } from "@naisys/common";
+import crypto from "node:crypto";
 export async function createHostRegistrar({ hubDb }) {
     /** Cache of all known hosts keyed by id */
     const hostsById = new Map();
@@ -7,26 +8,47 @@ export async function createHostRegistrar({ hubDb }) {
         select: {
             id: true,
             name: true,
+            machine_id: true,
             restricted: true,
             host_type: true,
             last_version: true,
+            environment: true,
         },
     });
     for (const row of rows) {
         hostsById.set(row.id, {
             hostName: row.name,
+            machineId: row.machine_id ?? "",
             restricted: row.restricted,
             hostType: row.host_type,
             lastVersion: row.last_version ?? "",
+            environment: row.environment,
         });
     }
+    /** Helper to update last_active and connection metadata for an existing host */
+    function updateCache(hostId, entry) {
+        hostsById.set(hostId, entry);
+    }
     /**
-     * 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
+     * Find the next available hostname when a collision occurs.
+     * E.g. "myhost" → "myhost-2", "myhost-3", etc.
      */
-    async function registerHost(hostName, hostType, lastIp, clientVersion) {
+    async function findAvailableHostName(baseName) {
+        let suffix = 2;
+        while (true) {
+            const candidate = `${baseName}-${suffix}`;
+            const exists = await hubDb.hosts.findUnique({
+                where: { name: candidate },
+            });
+            if (!exists)
+                return candidate;
+            suffix++;
+        }
+    }
+    /** Register a supervisor connection. Simple name-based upsert, no machineId. */
+    async function registerSupervisor(hostName, lastIp, clientVersion) {
         hostName = toUrlSafeKey(hostName);
+        const hostType = "supervisor";
         const existing = await hubDb.hosts.findUnique({
             where: { name: hostName },
         });
@@ -40,39 +62,147 @@ export async function createHostRegistrar({ hubDb }) {
                     last_version: clientVersion,
                 },
             });
-            hostsById.set(existing.id, {
+            updateCache(existing.id, {
                 hostName,
+                machineId: existing.machine_id ?? "",
                 restricted: existing.restricted,
                 hostType,
                 lastVersion: clientVersion,
+                environment: existing.environment,
             });
-            return existing.id;
+            return { hostId: existing.id, machineId: "", hostName };
+        }
+        const created = await hubDb.hosts.create({
+            data: {
+                name: hostName,
+                host_type: hostType,
+                last_ip: lastIp,
+                last_version: clientVersion,
+                last_active: new Date().toISOString(),
+            },
+        });
+        updateCache(created.id, {
+            hostName,
+            machineId: "",
+            restricted: false,
+            hostType,
+            lastVersion: clientVersion,
+            environment: null,
+        });
+        return { hostId: created.id, machineId: "", hostName };
+    }
+    /**
+     * Register a NAISYS client. If machineId is provided, looks up by machineId
+     * first (the DB hostname is authoritative after a rename). Otherwise looks up
+     * by hostname, deduplicating with a -N suffix on collision.
+     *
+     * @returns The host's id, assigned machineId, and authoritative hostname
+     */
+    async function registerNaisysClient(hostName, machineId, lastIp, clientVersion, environment) {
+        hostName = toUrlSafeKey(hostName);
+        const hostType = "naisys";
+        const environmentJson = environment ? JSON.stringify(environment) : null;
+        // --- Lookup by machineId (returning client) ---
+        if (machineId) {
+            const byMachineId = await hubDb.hosts.findUnique({
+                where: { machine_id: machineId },
+            });
+            if (byMachineId) {
+                await hubDb.hosts.update({
+                    where: { id: byMachineId.id },
+                    data: {
+                        last_active: new Date().toISOString(),
+                        host_type: hostType,
+                        last_ip: lastIp,
+                        last_version: clientVersion,
+                        ...(environmentJson !== null
+                            ? { environment: environmentJson }
+                            : {}),
+                    },
+                });
+                updateCache(byMachineId.id, {
+                    hostName: byMachineId.name,
+                    machineId,
+                    restricted: byMachineId.restricted,
+                    hostType,
+                    lastVersion: clientVersion,
+                    environment: environmentJson ?? byMachineId.environment,
+                });
+                // Return the DB hostname (may differ from what the client sent if renamed)
+                return {
+                    hostId: byMachineId.id,
+                    machineId,
+                    hostName: byMachineId.name,
+                };
+            }
+            // machineId not found in DB — fall through to name-based lookup
+        }
+        // --- Lookup by hostname ---
+        const newMachineId = machineId || crypto.randomUUID();
+        const byName = await hubDb.hosts.findUnique({
+            where: { name: hostName },
+        });
+        if (byName) {
+            if (!byName.machine_id) {
+                // Existing host without a machineId (pre-migration) — adopt it
+                await hubDb.hosts.update({
+                    where: { id: byName.id },
+                    data: {
+                        machine_id: newMachineId,
+                        last_active: new Date().toISOString(),
+                        host_type: hostType,
+                        last_ip: lastIp,
+                        last_version: clientVersion,
+                        ...(environmentJson !== null
+                            ? { environment: environmentJson }
+                            : {}),
+                    },
+                });
+                updateCache(byName.id, {
+                    hostName,
+                    machineId: newMachineId,
+                    restricted: byName.restricted,
+                    hostType,
+                    lastVersion: clientVersion,
+                    environment: environmentJson ?? byName.environment,
+                });
+                return { hostId: byName.id, machineId: newMachineId, hostName };
+            }
+            // Name collision with a different machine — deduplicate
+            hostName = await findAvailableHostName(hostName);
         }
+        // --- Create new host ---
         const created = await hubDb.hosts.create({
             data: {
                 name: hostName,
+                machine_id: newMachineId,
                 host_type: hostType,
                 last_ip: lastIp,
                 last_version: clientVersion,
+                environment: environmentJson,
                 last_active: new Date().toISOString(),
             },
         });
-        hostsById.set(created.id, {
+        updateCache(created.id, {
             hostName,
+            machineId: newMachineId,
             restricted: false,
             hostType,
             lastVersion: clientVersion,
+            environment: environmentJson,
         });
-        return created.id;
+        return { hostId: created.id, machineId: newMachineId, hostName };
     }
     /** Returns all known hosts (from DB + any newly registered) */
     function getAllHosts() {
         return Array.from(hostsById, ([hostId, entry]) => ({
             hostId,
             hostName: entry.hostName,
+            machineId: entry.machineId,
             restricted: entry.restricted,
             hostType: entry.hostType,
             lastVersion: entry.lastVersion,
+            environment: entry.environment,
         }));
     }
     /** Re-read all hosts from DB and replace the in-memory cache */
@@ -81,23 +211,28 @@ export async function createHostRegistrar({ hubDb }) {
             select: {
                 id: true,
                 name: true,
+                machine_id: true,
                 restricted: true,
                 host_type: true,
                 last_version: true,
+                environment: true,
             },
         });
         hostsById.clear();
         for (const row of rows) {
             hostsById.set(row.id, {
                 hostName: row.name,
+                machineId: row.machine_id ?? "",
                 restricted: row.restricted,
                 hostType: row.host_type,
                 lastVersion: row.last_version ?? "",
+                environment: row.environment,
             });
         }
     }
     return {
-        registerHost,
+        registerNaisysClient,
+        registerSupervisor,
         getAllHosts,
         refreshHosts,
     };

package/dist/services/naisysServer.js

@@ -1,3 +1,4 @@
+import { HubEvents } from "@naisys/hub-protocol";
 import { createNaisysConnection } from "./naisysConnection.js";
 /**
  * Creates the NAISYS namespace server that accepts NAISYS instance connections.
@@ -59,7 +60,7 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
     }
     // Authentication middleware
     nsp.use(async (socket, next) => {
-        const { hubAccessKey: clientAccessKey, hostName, hostType: rawHostType, clientVersion, } = socket.handshake.auth;
+        const { hubAccessKey: clientAccessKey, hostName, machineId: rawMachineId, hostType: rawHostType, clientVersion, environment: rawEnvironment, } = 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"));
@@ -71,14 +72,23 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
         try {
             const hostType = (typeof rawHostType === "string" ? rawHostType : "naisys");
             const resolvedVersion = typeof clientVersion === "string" ? clientVersion : "";
-            const hostId = await hostRegistrar.registerHost(hostName, hostType, socket.handshake.address, resolvedVersion);
+            const machineId = typeof rawMachineId === "string" && rawMachineId
+                ? rawMachineId
+                : undefined;
+            const environment = rawEnvironment && typeof rawEnvironment === "object"
+                ? rawEnvironment
+                : undefined;
+            const result = hostType === "supervisor"
+                ? await hostRegistrar.registerSupervisor(hostName, socket.handshake.address, resolvedVersion)
+                : await hostRegistrar.registerNaisysClient(hostName, machineId, socket.handshake.address, resolvedVersion, environment);
             // 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`));
+            if (hostType === "naisys" && naisysConnections.has(result.hostId)) {
+                logService.log(`[Hub] Connection rejected: host '${result.hostName}' is already connected`);
+                return next(new Error(`Host '${result.hostName}' already has an active connection`));
             }
-            socket.data.hostId = hostId;
-            socket.data.hostName = hostName;
+            socket.data.hostId = result.hostId;
+            socket.data.hostName = result.hostName;
+            socket.data.machineId = result.machineId;
             socket.data.hostType = hostType;
             socket.data.clientVersion = resolvedVersion;
             next();
@@ -90,7 +100,10 @@ export function createNaisysServer(nsp, initialHubAccessKey, logService, hostReg
     });
     // Handle new connections
     nsp.on("connection", (socket) => {
-        const { hostId, hostName, hostType, clientVersion } = socket.data;
+        const { hostId, hostName, machineId, hostType, clientVersion } = socket.data;
+        // Send the client its assigned machineId and authoritative hostname
+        const registered = { machineId, hostName };
+        socket.emit(HubEvents.HOST_REGISTERED, registered);
         // Create connection handler for this socket, passing our emit function
         const connection = createNaisysConnection(socket, {
             hostId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naisys/hub",
-  "version": "3.0.0-beta.20",
+  "version": "3.0.0-beta.22",
   "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.20"
+    "@naisys/supervisor": "3.0.0-beta.22"
   },
   "peerDependenciesMeta": {
     "@naisys/supervisor": {
@@ -38,10 +38,10 @@
     }
   },
   "dependencies": {
-    "@naisys/common": "3.0.0-beta.20",
-    "@naisys/common-node": "3.0.0-beta.20",
-    "@naisys/hub-database": "3.0.0-beta.20",
-    "@naisys/hub-protocol": "3.0.0-beta.20",
+    "@naisys/common": "3.0.0-beta.22",
+    "@naisys/common-node": "3.0.0-beta.22",
+    "@naisys/hub-database": "3.0.0-beta.22",
+    "@naisys/hub-protocol": "3.0.0-beta.22",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fastify": "^5.8.2",