@camstack/server 1.1.76 → 1.2.1

package/dist/agent/agent-http.js

@@ -0,0 +1,444 @@
+"use strict";
+/**
+ * Agent HTTP server -- lightweight Fastify instance for agent status,
+ * process management, config editing, and static UI serving.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickIpv4 = void 0;
+exports.compareVersions = compareVersions;
+exports.readUiDistCandidate = readUiDistCandidate;
+exports.pickUiDist = pickUiDist;
+exports.resolveUiDistDir = resolveUiDistDir;
+exports.getRegistryNodes = getRegistryNodes;
+exports.resolveHubEndpoint = resolveHubEndpoint;
+exports.mapDiscoveredNodes = mapDiscoveredNodes;
+exports.createAgentHttpServer = createAgentHttpServer;
+exports.startAgentHttpServer = startAgentHttpServer;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fastify_1 = __importDefault(require("fastify"));
+const derive_hub_url_js_1 = require("./derive-hub-url.js");
+Object.defineProperty(exports, "pickIpv4", { enumerable: true, get: function () { return derive_hub_url_js_1.pickIpv4; } });
+const agent_http_auth_js_1 = require("./agent-http-auth.js");
+/** Dotted-numeric version compare; `null` sorts lowest. */
+function compareVersions(a, b) {
+    if (a === null && b === null)
+        return 0;
+    if (a === null)
+        return -1;
+    if (b === null)
+        return 1;
+    const pa = a.split('.').map((s) => Number.parseInt(s, 10) || 0);
+    const pb = b.split('.').map((s) => Number.parseInt(s, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/**
+ * Read an agent-ui package dir (`<base>/package.json` + `<base>/dist/index.html`)
+ * into a candidate. Returns `null` when the dist is absent/unusable.
+ */
+function readUiDistCandidate(baseDir) {
+    const dir = path.join(baseDir, 'dist');
+    if (!fs.existsSync(path.join(dir, 'index.html')))
+        return null;
+    let version = null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(baseDir, 'package.json'), 'utf-8'));
+        version = typeof parsed.version === 'string' ? parsed.version : null;
+    }
+    catch {
+        version = null;
+    }
+    return { dir, version };
+}
+/**
+ * Pick between the dataDir-installed copy and the app-bundled copy: the
+ * NEWER version wins; on a tie the installed copy wins (it is the one
+ * `camstack deploy` updates).
+ *
+ * Rationale: bootstrap addon install is seed-only (first boot), so a
+ * packaged desktop app that ships a newer agent-ui in its resources would
+ * otherwise keep serving the UI frozen at whatever version was first
+ * installed (observed live: an app at v1.1.27 serving the v1.1.1 UI).
+ */
+function pickUiDist(installed, bundled) {
+    if (installed && bundled) {
+        return compareVersions(bundled.version, installed.version) > 0 ? bundled.dir : installed.dir;
+    }
+    return installed?.dir ?? bundled?.dir ?? null;
+}
+function resolveUiDistDir(dataDir, bundledAddonsDir, 
+// Workspace / npm-package sibling — dev checkouts and Docker images where
+// @camstack/addon-agent-ui sits next to @camstack/agent in node_modules.
+// Always version-matched to the agent, so it keeps top priority.
+// Injectable so tests are independent of the workspace checkout.
+siblingDistDir = path.resolve(__dirname, '../../addon-agent-ui/dist')) {
+    if (fs.existsSync(path.join(siblingDistDir, 'index.html')))
+        return siblingDistDir;
+    const installed = readUiDistCandidate(path.join(dataDir, 'addons', '@camstack', 'addon-agent-ui'));
+    const bundled = bundledAddonsDir
+        ? readUiDistCandidate(path.join(bundledAddonsDir, 'addon-agent-ui'))
+        : null;
+    const picked = pickUiDist(installed, bundled);
+    if (picked)
+        return picked;
+    const legacy = path.join(dataDir, 'agent-ui');
+    if (fs.existsSync(path.join(legacy, 'index.html')))
+        return legacy;
+    return null;
+}
+function readConfigFile(configPath) {
+    if (!fs.existsSync(configPath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfigFile(configPath, data) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(data, null, 2), 'utf-8');
+}
+/** Live Moleculer registry snapshot — reused by agent-bootstrap's Option A. */
+function getRegistryNodes(broker) {
+    try {
+        const registry = broker.registry;
+        return registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * A human-readable, reachable address for the hub node as the agent actually
+ * sees it in the Moleculer registry. Used to fill in the effective address
+ * even in UDP-discovery mode where no address was manually configured.
+ */
+function resolveHubEndpoint(nodes) {
+    const hub = nodes.find((n) => n.id === 'hub');
+    if (!hub)
+        return null;
+    return (0, derive_hub_url_js_1.pickIpv4)(hub.ipList) ?? hub.hostname ?? null;
+}
+/**
+ * Map raw registry nodes (minus self) to the UI-facing shape: the hub carries
+ * its real hostname so the UI can render "hostname (hub)" instead of the bare
+ * `hub` node id.
+ */
+function mapDiscoveredNodes(nodes, selfId) {
+    return nodes
+        .filter((n) => n.id !== selfId)
+        .map((n) => ({ id: n.id, hostname: n.hostname ?? n.id, isHub: n.id === 'hub' }));
+}
+/**
+ * Derive the hub connection state from broker registry + config when no
+ * external getter is wired. Does NOT detect `secret-mismatch` — that
+ * requires the bootstrap to inject `getHubConnectionState`.
+ */
+function deriveHubConnectionState(nodes, discoveryMode) {
+    const hubInRegistry = nodes.some((n) => n.id === 'hub');
+    if (hubInRegistry)
+        return 'connected';
+    if (discoveryMode)
+        return 'searching';
+    return 'disconnected';
+}
+/**
+ * Read the current effective config from the persisted file.
+ * This is the single source of truth -- always reflects what the UI wrote.
+ */
+function getEffectiveConfig(configPath, nodeId) {
+    const raw = readConfigFile(configPath);
+    return {
+        name: typeof raw.name === 'string' ? raw.name : nodeId,
+        hubAddress: typeof raw.hubAddress === 'string' ? raw.hubAddress : null,
+        hasSecret: typeof raw.secret === 'string' && raw.secret.length > 0,
+    };
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+async function createAgentHttpServer(getBroker, config) {
+    const app = (0, fastify_1.default)({ logger: false });
+    const cors = await Promise.resolve().then(() => __importStar(require('@fastify/cors')));
+    await app.register(cors.default);
+    // -- Auth gate (port-4444 hardening, mirrors the hub's /health work) --
+    // Loopback (Electron renderer, in-container probes) always passes;
+    // remote callers need `Authorization: Bearer <cluster secret>`. While
+    // the agent is UNPAIRED (no secret configured) only the pairing surface
+    // is reachable remotely. Registered as an onRequest hook over the /api
+    // + /health/details prefixes so any FUTURE route is gated fail-closed.
+    const currentSecret = () => {
+        const raw = readConfigFile(config.configPath);
+        return typeof raw.secret === 'string' && raw.secret.length > 0 ? raw.secret : null;
+    };
+    app.addHook('onRequest', async (req, reply) => {
+        const pathOnly = req.url.split('?')[0] ?? req.url;
+        const isProtected = pathOnly.startsWith('/api/') || pathOnly.startsWith('/health/');
+        if (!isProtected)
+            return;
+        const secret = currentSecret();
+        const authInput = {
+            remoteAddress: req.socket.remoteAddress ?? undefined,
+            ...(typeof req.headers.authorization === 'string'
+                ? { authorization: req.headers.authorization }
+                : {}),
+        };
+        if ((0, agent_http_auth_js_1.isAuthorizedAgentRequest)(authInput, secret))
+            return;
+        if (secret === null && (0, agent_http_auth_js_1.isPairingRequest)(req.method, pathOnly))
+            return;
+        return reply.status(401).send({ ok: false, error: 'unauthorized' });
+    });
+    // -- Health ---------------------------------------------------------
+    // PUBLIC probe: liveness only — `{ok}`, no nodeId/version/topology (a
+    // public endpoint must not enumerate the deployment; same policy as the
+    // hub's /health). The detailed shape lives on `$agent.health` (Moleculer
+    // action) for the hub, and on the AUTHENTICATED /health/details below
+    // for external monitors.
+    app.get('/health', async (_req, reply) => {
+        try {
+            await getBroker().call('$agent.health');
+            return { ok: true };
+        }
+        catch {
+            return reply.status(503).send({ ok: false });
+        }
+    });
+    // AUTHENTICATED detailed health — the payload /health used to return.
+    app.get('/health/details', async (_req, reply) => {
+        try {
+            const result = await getBroker().call('$agent.health');
+            return result;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return reply.status(503).send({
+                ok: false,
+                nodeId: config.nodeId,
+                error: message,
+            });
+        }
+    });
+    // -- Agent status (enriched with connection state) ------------------
+    app.get('/api/agent/status', async () => {
+        const broker = getBroker();
+        const eff = getEffectiveConfig(config.configPath, config.nodeId);
+        const nodes = getRegistryNodes(broker);
+        const hubConnected = nodes.some((n) => n.id === 'hub');
+        const discoveryMode = !eff.hubAddress;
+        const hubConnectionState = config.getHubConnectionState
+            ? config.getHubConnectionState()
+            : deriveHubConnectionState(nodes, discoveryMode);
+        // The address the agent actually reaches the hub at (from the Moleculer
+        // registry) — lets the UI show the real endpoint even under UDP discovery
+        // where `eff.hubAddress` is null.
+        const resolvedHubAddress = resolveHubEndpoint(nodes);
+        // Version of the Electron wrapper (injected by the desktop app); absent
+        // when the agent runs headless / in Docker.
+        const appVersion = process.env['CAMSTACK_AGENT_APP_VERSION'] ?? null;
+        const discoveredNodes = mapDiscoveredNodes(nodes, broker.nodeID);
+        try {
+            const status = (await broker.call('$agent.status'));
+            return {
+                ...status,
+                name: eff.name,
+                hubAddress: eff.hubAddress,
+                resolvedHubAddress,
+                appVersion,
+                hubConnected,
+                hubConnectionState,
+                discoveryMode,
+                hasSecret: eff.hasSecret,
+                discoveredNodes,
+            };
+        }
+        catch {
+            return {
+                nodeId: config.nodeId,
+                name: eff.name,
+                hubAddress: eff.hubAddress,
+                resolvedHubAddress,
+                appVersion,
+                hubConnected,
+                hubConnectionState,
+                discoveryMode,
+                hasSecret: eff.hasSecret,
+                discoveredNodes,
+                addons: [],
+                localIps: [],
+            };
+        }
+    });
+    // -- Processes ------------------------------------------------------
+    app.get('/api/agent/processes', async () => {
+        try {
+            return await getBroker().call('$process.list');
+        }
+        catch {
+            return [];
+        }
+    });
+    // -- Addon restart --------------------------------------------------
+    app.post('/api/agent/addon/restart', async (req, reply) => {
+        const addonId = req.body?.addonId;
+        if (!addonId)
+            return reply.status(400).send({ error: 'addonId required' });
+        return getBroker().call('$agent.restart', { addonId });
+    });
+    // -- Process restart ------------------------------------------------
+    app.post('/api/agent/process/restart', async (req, reply) => {
+        const name = req.body?.name;
+        if (!name)
+            return reply.status(400).send({ error: 'name required' });
+        return getBroker().call('$process.restart', { name });
+    });
+    // -- Config read (always from file -- single source of truth) -------
+    app.get('/api/agent/config', async () => {
+        const persisted = readConfigFile(config.configPath);
+        const eff = getEffectiveConfig(config.configPath, config.nodeId);
+        return {
+            nodeId: config.nodeId,
+            name: eff.name,
+            hubAddress: eff.hubAddress,
+            hasSecret: eff.hasSecret,
+            configPath: config.configPath,
+            dataDir: config.dataDir,
+            // Include all persisted fields except raw secret
+            ...Object.fromEntries(Object.entries(persisted).filter(([k]) => k !== 'secret')),
+        };
+    });
+    // -- Config write (merge-patch + persist) ---------------------------
+    // Fastify (not Express) natively awaits async route handlers and serializes
+    // the returned value / catches rejections, so an async handler is correct here.
+    // eslint-disable-next-line oxc/no-async-endpoint-handlers
+    app.post('/api/agent/config', async (req) => {
+        const patch = req.body ?? {};
+        const existing = readConfigFile(config.configPath);
+        const merged = { ...existing, ...patch };
+        writeConfigFile(config.configPath, merged);
+        // Apply name change immediately (no reconnect needed)
+        if (typeof patch.name === 'string' && patch.name.trim()) {
+            try {
+                await getBroker().call('$agent.rename', { name: patch.name.trim() });
+                console.log(`[Agent] Name changed to "${patch.name.trim()}"`);
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        // Only flag reconnect when a connection-affecting field actually
+        // CHANGED. The form posts every visible field on every Save, so
+        // `patch.hubAddress !== undefined` was always true and produced
+        // false-positive "Restart required" prompts on no-op saves.
+        const reconnectRelevant = ['hubAddress', 'secret'];
+        const needsReconnect = reconnectRelevant.some((k) => Object.prototype.hasOwnProperty.call(patch, k) && patch[k] !== existing[k]);
+        return {
+            success: true,
+            restartRequired: needsReconnect,
+        };
+    });
+    // -- Agent reconnect (applies new hub/secret config) ----------------
+    app.post('/api/agent/restart', async () => {
+        if (!config.onReconnect) {
+            return { success: false, message: 'Reconnect not available' };
+        }
+        console.log('[Agent] Reconnect requested from UI');
+        void config.onReconnect().catch((err) => {
+            console.error('[Agent] Reconnect failed:', err);
+        });
+        return { success: true, message: 'Agent reconnecting...' };
+    });
+    // -- Discovered nodes -----------------------------------------------
+    app.get('/api/agent/discovered-nodes', async () => {
+        const b = getBroker();
+        const nodes = getRegistryNodes(b);
+        return mapDiscoveredNodes(nodes, b.nodeID);
+    });
+    // -- Static file serving (agent-ui) ---------------------------------
+    const uiDir = resolveUiDistDir(config.dataDir, process.env['CAMSTACK_BUNDLED_ADDONS_DIR']);
+    if (uiDir) {
+        const fastifyStatic = await Promise.resolve().then(() => __importStar(require('@fastify/static')));
+        await app.register(fastifyStatic.default, {
+            root: uiDir,
+            prefix: '/',
+            wildcard: false,
+            // MUST stay true: the SPA-fallback below uses `reply.sendFile`, which
+            // only exists when the plugin decorates Reply. With `false` every
+            // fallback request 500'd with "reply.sendFile is not a function".
+            decorateReply: true,
+        });
+        app.setNotFoundHandler(async (req, reply) => {
+            if (req.url.startsWith('/api/') || req.url.startsWith('/health')) {
+                return reply.status(404).send({ error: 'Not found' });
+            }
+            // Never serve index.html to an asset request: a stale index.html
+            // referencing missing hashed assets must fail VISIBLY (404 in the
+            // renderer console) instead of feeding HTML to a module script,
+            // which renders as a silent blank page.
+            if (req.url.startsWith('/assets/')) {
+                console.warn(`[Agent] UI asset not found (stale index.html?): ${req.url}`);
+                return reply.status(404).send({ error: 'Asset not found' });
+            }
+            return reply.type('text/html').sendFile('index.html');
+        });
+        console.log(`[Agent] UI served from: ${uiDir}`);
+    }
+    return app;
+}
+// ---------------------------------------------------------------------------
+// Start helper
+// ---------------------------------------------------------------------------
+async function startAgentHttpServer(getBroker, config) {
+    try {
+        const app = await createAgentHttpServer(getBroker, config);
+        await app.listen({ port: config.port, host: '0.0.0.0' });
+        console.log(`[Agent] HTTP server: http://localhost:${config.port}`);
+    }
+    catch (err) {
+        console.warn(`[Agent] HTTP server failed to start on port ${config.port}:`, err);
+    }
+}