@intent-systems/nexus 2026.1.5-3

package/dist/gateway/config-reload.js

@@ -0,0 +1,274 @@
+import chokidar from "chokidar";
+const DEFAULT_RELOAD_SETTINGS = {
+    mode: "hybrid",
+    debounceMs: 300,
+};
+const RELOAD_RULES = [
+    { prefix: "gateway.remote", kind: "none" },
+    { prefix: "gateway.reload", kind: "none" },
+    { prefix: "hooks.gmail", kind: "hot", actions: ["restart-gmail-watcher"] },
+    { prefix: "hooks", kind: "hot", actions: ["reload-hooks"] },
+    { prefix: "agent.heartbeat", kind: "hot", actions: ["restart-heartbeat"] },
+    { prefix: "cron", kind: "hot", actions: ["restart-cron"] },
+    {
+        prefix: "browser",
+        kind: "hot",
+        actions: ["restart-browser-control"],
+    },
+    { prefix: "web", kind: "hot", actions: ["restart-provider:whatsapp"] },
+    { prefix: "telegram", kind: "hot", actions: ["restart-provider:telegram"] },
+    { prefix: "discord", kind: "hot", actions: ["restart-provider:discord"] },
+    { prefix: "slack", kind: "hot", actions: ["restart-provider:slack"] },
+    { prefix: "signal", kind: "hot", actions: ["restart-provider:signal"] },
+    { prefix: "imessage", kind: "hot", actions: ["restart-provider:imessage"] },
+    { prefix: "identity", kind: "none" },
+    { prefix: "wizard", kind: "none" },
+    { prefix: "logging", kind: "none" },
+    { prefix: "models", kind: "none" },
+    { prefix: "agent", kind: "none" },
+    { prefix: "routing", kind: "none" },
+    { prefix: "messages", kind: "none" },
+    { prefix: "session", kind: "none" },
+    { prefix: "whatsapp", kind: "none" },
+    { prefix: "talk", kind: "none" },
+    { prefix: "skills", kind: "none" },
+    { prefix: "ui", kind: "none" },
+    { prefix: "gateway", kind: "restart" },
+    { prefix: "bridge", kind: "restart" },
+    { prefix: "discovery", kind: "restart" },
+    { prefix: "canvasHost", kind: "restart" },
+];
+function matchRule(path) {
+    for (const rule of RELOAD_RULES) {
+        if (path === rule.prefix || path.startsWith(`${rule.prefix}.`))
+            return rule;
+    }
+    return null;
+}
+function isPlainObject(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === "[object Object]");
+}
+export function diffConfigPaths(prev, next, prefix = "") {
+    if (prev === next)
+        return [];
+    if (isPlainObject(prev) && isPlainObject(next)) {
+        const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+        const paths = [];
+        for (const key of keys) {
+            const prevValue = prev[key];
+            const nextValue = next[key];
+            if (prevValue === undefined && nextValue === undefined)
+                continue;
+            const childPrefix = prefix ? `${prefix}.${key}` : key;
+            const childPaths = diffConfigPaths(prevValue, nextValue, childPrefix);
+            if (childPaths.length > 0) {
+                paths.push(...childPaths);
+            }
+        }
+        return paths;
+    }
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length &&
+            prev.every((val, idx) => val === next[idx])) {
+            return [];
+        }
+    }
+    return [prefix || "<root>"];
+}
+export function resolveGatewayReloadSettings(cfg) {
+    const rawMode = cfg.gateway?.reload?.mode;
+    const mode = rawMode === "off" ||
+        rawMode === "restart" ||
+        rawMode === "hot" ||
+        rawMode === "hybrid"
+        ? rawMode
+        : DEFAULT_RELOAD_SETTINGS.mode;
+    const debounceRaw = cfg.gateway?.reload?.debounceMs;
+    const debounceMs = typeof debounceRaw === "number" && Number.isFinite(debounceRaw)
+        ? Math.max(0, Math.floor(debounceRaw))
+        : DEFAULT_RELOAD_SETTINGS.debounceMs;
+    return { mode, debounceMs };
+}
+export function buildGatewayReloadPlan(changedPaths) {
+    const plan = {
+        changedPaths,
+        restartGateway: false,
+        restartReasons: [],
+        hotReasons: [],
+        reloadHooks: false,
+        restartGmailWatcher: false,
+        restartBrowserControl: false,
+        restartCron: false,
+        restartHeartbeat: false,
+        restartProviders: new Set(),
+        noopPaths: [],
+    };
+    const applyAction = (action) => {
+        switch (action) {
+            case "reload-hooks":
+                plan.reloadHooks = true;
+                break;
+            case "restart-gmail-watcher":
+                plan.restartGmailWatcher = true;
+                break;
+            case "restart-browser-control":
+                plan.restartBrowserControl = true;
+                break;
+            case "restart-cron":
+                plan.restartCron = true;
+                break;
+            case "restart-heartbeat":
+                plan.restartHeartbeat = true;
+                break;
+            case "restart-provider:whatsapp":
+                plan.restartProviders.add("whatsapp");
+                break;
+            case "restart-provider:telegram":
+                plan.restartProviders.add("telegram");
+                break;
+            case "restart-provider:discord":
+                plan.restartProviders.add("discord");
+                break;
+            case "restart-provider:slack":
+                plan.restartProviders.add("slack");
+                break;
+            case "restart-provider:signal":
+                plan.restartProviders.add("signal");
+                break;
+            case "restart-provider:imessage":
+                plan.restartProviders.add("imessage");
+                break;
+            default:
+                break;
+        }
+    };
+    for (const path of changedPaths) {
+        const rule = matchRule(path);
+        if (!rule) {
+            plan.restartGateway = true;
+            plan.restartReasons.push(path);
+            continue;
+        }
+        if (rule.kind === "restart") {
+            plan.restartGateway = true;
+            plan.restartReasons.push(path);
+            continue;
+        }
+        if (rule.kind === "none") {
+            plan.noopPaths.push(path);
+            continue;
+        }
+        plan.hotReasons.push(path);
+        for (const action of rule.actions ?? []) {
+            applyAction(action);
+        }
+    }
+    if (plan.restartGmailWatcher) {
+        plan.reloadHooks = true;
+    }
+    return plan;
+}
+export function startGatewayConfigReloader(opts) {
+    let currentConfig = opts.initialConfig;
+    let settings = resolveGatewayReloadSettings(currentConfig);
+    let debounceTimer = null;
+    let pending = false;
+    let running = false;
+    let stopped = false;
+    let restartQueued = false;
+    const schedule = () => {
+        if (stopped)
+            return;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        const wait = settings.debounceMs;
+        debounceTimer = setTimeout(() => {
+            void runReload();
+        }, wait);
+    };
+    const runReload = async () => {
+        if (stopped)
+            return;
+        if (running) {
+            pending = true;
+            return;
+        }
+        running = true;
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        try {
+            const snapshot = await opts.readSnapshot();
+            if (!snapshot.valid) {
+                const issues = snapshot.issues
+                    .map((issue) => `${issue.path}: ${issue.message}`)
+                    .join(", ");
+                opts.log.warn(`config reload skipped (invalid config): ${issues}`);
+                return;
+            }
+            const nextConfig = snapshot.config;
+            const changedPaths = diffConfigPaths(currentConfig, nextConfig);
+            currentConfig = nextConfig;
+            settings = resolveGatewayReloadSettings(nextConfig);
+            if (changedPaths.length === 0)
+                return;
+            const plan = buildGatewayReloadPlan(changedPaths);
+            if (settings.mode === "off") {
+                opts.log.info("config reload disabled (gateway.reload.mode=off)");
+                return;
+            }
+            if (settings.mode === "restart") {
+                if (!restartQueued) {
+                    restartQueued = true;
+                    opts.onRestart(plan, nextConfig);
+                }
+                return;
+            }
+            if (plan.restartGateway) {
+                if (settings.mode === "hot") {
+                    opts.log.warn(`config reload requires gateway restart; hot mode ignoring (${plan.restartReasons.join(", ")})`);
+                    return;
+                }
+                if (!restartQueued) {
+                    restartQueued = true;
+                    opts.onRestart(plan, nextConfig);
+                }
+                return;
+            }
+            await opts.onHotReload(plan, nextConfig);
+        }
+        catch (err) {
+            opts.log.error(`config reload failed: ${String(err)}`);
+        }
+        finally {
+            running = false;
+            if (pending) {
+                pending = false;
+                schedule();
+            }
+        }
+    };
+    const watcher = chokidar.watch(opts.watchPath, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+    });
+    watcher.on("add", schedule);
+    watcher.on("change", schedule);
+    watcher.on("unlink", schedule);
+    watcher.on("error", (err) => {
+        opts.log.warn(`config watcher error: ${String(err)}`);
+    });
+    return {
+        stop: async () => {
+            stopped = true;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = null;
+            await watcher.close().catch(() => { });
+        },
+    };
+}

package/dist/gateway/control-ui.js

@@ -0,0 +1,184 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const ROOT_PREFIX = "/";
+export function normalizeControlUiBasePath(basePath) {
+    if (!basePath)
+        return "";
+    let normalized = basePath.trim();
+    if (!normalized)
+        return "";
+    if (!normalized.startsWith("/"))
+        normalized = `/${normalized}`;
+    if (normalized === "/")
+        return "";
+    if (normalized.endsWith("/"))
+        normalized = normalized.slice(0, -1);
+    return normalized;
+}
+function resolveControlUiRoot() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const execDir = (() => {
+        try {
+            return path.dirname(fs.realpathSync(process.execPath));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const candidates = [
+        // Packaged relay: Resources/Relay/control-ui
+        execDir ? path.resolve(execDir, "control-ui") : null,
+        // Running from dist: dist/gateway/control-ui.js -> dist/control-ui
+        path.resolve(here, "../control-ui"),
+        // Running from source: src/gateway/control-ui.ts -> dist/control-ui
+        path.resolve(here, "../../dist/control-ui"),
+        // Fallback to cwd (dev)
+        path.resolve(process.cwd(), "dist", "control-ui"),
+    ].filter((dir) => Boolean(dir));
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(dir, "index.html")))
+            return dir;
+    }
+    return null;
+}
+function contentTypeForExt(ext) {
+    switch (ext) {
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".js":
+            return "application/javascript; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".json":
+        case ".map":
+            return "application/json; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".ico":
+            return "image/x-icon";
+        case ".txt":
+            return "text/plain; charset=utf-8";
+        default:
+            return "application/octet-stream";
+    }
+}
+function respondNotFound(res) {
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Not Found");
+}
+function serveFile(res, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    res.setHeader("Content-Type", contentTypeForExt(ext));
+    // Static UI should never be cached aggressively while iterating; allow the
+    // browser to revalidate.
+    res.setHeader("Cache-Control", "no-cache");
+    res.end(fs.readFileSync(filePath));
+}
+function injectControlUiBasePath(html, basePath) {
+    const script = `<script>window.__NEXUS_CONTROL_UI_BASE_PATH__=${JSON.stringify(basePath)};</script>`;
+    if (html.includes("__NEXUS_CONTROL_UI_BASE_PATH__"))
+        return html;
+    const headClose = html.indexOf("</head>");
+    if (headClose !== -1) {
+        return `${html.slice(0, headClose)}${script}${html.slice(headClose)}`;
+    }
+    return `${script}${html}`;
+}
+function serveIndexHtml(res, indexPath, basePath) {
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache");
+    const raw = fs.readFileSync(indexPath, "utf8");
+    res.end(injectControlUiBasePath(raw, basePath));
+}
+function isSafeRelativePath(relPath) {
+    if (!relPath)
+        return false;
+    const normalized = path.posix.normalize(relPath);
+    if (normalized.startsWith("../") || normalized === "..")
+        return false;
+    if (normalized.includes("\0"))
+        return false;
+    return true;
+}
+export function handleControlUiHttpRequest(req, res, opts) {
+    const urlRaw = req.url;
+    if (!urlRaw)
+        return false;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("Method Not Allowed");
+        return true;
+    }
+    const url = new URL(urlRaw, "http://localhost");
+    const basePath = normalizeControlUiBasePath(opts?.basePath);
+    const pathname = url.pathname;
+    if (!basePath) {
+        if (pathname === "/ui" || pathname.startsWith("/ui/")) {
+            respondNotFound(res);
+            return true;
+        }
+    }
+    if (basePath) {
+        if (pathname === basePath) {
+            res.statusCode = 302;
+            res.setHeader("Location", `${basePath}/${url.search}`);
+            res.end();
+            return true;
+        }
+        if (!pathname.startsWith(`${basePath}/`))
+            return false;
+    }
+    const root = resolveControlUiRoot();
+    if (!root) {
+        res.statusCode = 503;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("Control UI assets not found. Build them with `bun run ui:build` (or run `bun run ui:dev` during development).");
+        return true;
+    }
+    const uiPath = basePath && pathname.startsWith(`${basePath}/`)
+        ? pathname.slice(basePath.length)
+        : pathname;
+    const rel = (() => {
+        if (uiPath === ROOT_PREFIX)
+            return "";
+        const assetsIndex = uiPath.indexOf("/assets/");
+        if (assetsIndex >= 0)
+            return uiPath.slice(assetsIndex + 1);
+        return uiPath.slice(1);
+    })();
+    const requested = rel && !rel.endsWith("/") ? rel : `${rel}index.html`;
+    const fileRel = requested || "index.html";
+    if (!isSafeRelativePath(fileRel)) {
+        respondNotFound(res);
+        return true;
+    }
+    const filePath = path.join(root, fileRel);
+    if (!filePath.startsWith(root)) {
+        respondNotFound(res);
+        return true;
+    }
+    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        if (path.basename(filePath) === "index.html") {
+            serveIndexHtml(res, filePath, basePath);
+            return true;
+        }
+        serveFile(res, filePath);
+        return true;
+    }
+    // SPA fallback (client-side router): serve index.html for unknown paths.
+    const indexPath = path.join(root, "index.html");
+    if (fs.existsSync(indexPath)) {
+        serveIndexHtml(res, indexPath, basePath);
+        return true;
+    }
+    respondNotFound(res);
+    return true;
+}