@intent-systems/nexus 2026.1.5-3

package/dist/gateway/server-browser.js

@@ -0,0 +1,11 @@
+export async function startBrowserControlServerIfEnabled() {
+    if (process.env.NEXUS_SKIP_BROWSER_CONTROL_SERVER === "1" ||
+        process.env.NEXUS_SKIP_BROWSER_CONTROL_SERVER === "1")
+        return null;
+    // Lazy import: keeps startup fast, but still bundles for the embedded
+    // gateway (bun --compile) via the static specifier path.
+    const override = (process.env.NEXUS_BROWSER_CONTROL_MODULE ?? process.env.NEXUS_BROWSER_CONTROL_MODULE)?.trim();
+    const mod = override ? await import(override) : await import("../browser/server.js");
+    await mod.startBrowserControlServerFromConfig();
+    return { stop: mod.stopBrowserControlServer };
+}

package/dist/gateway/server-channels.js

@@ -0,0 +1,680 @@
+import { monitorDiscordProvider } from "../discord/index.js";
+import { probeDiscord } from "../discord/probe.js";
+import { shouldLogVerbose } from "../globals.js";
+import { monitorIMessageProvider } from "../imessage/index.js";
+import { monitorWebChannel, webAuthExists } from "../channels/web/index.js";
+import { monitorSignalProvider } from "../signal/index.js";
+import { monitorSlackProvider, resolveSlackAppToken, resolveSlackBotToken, } from "../slack/index.js";
+import { monitorTelegramProvider } from "../telegram/monitor.js";
+import { probeTelegram } from "../telegram/probe.js";
+import { resolveTelegramToken } from "../telegram/token.js";
+import { listEnabledWhatsAppAccounts, resolveDefaultWhatsAppAccountId } from "../web/accounts.js";
+import { readWebSelfId } from "../web/session.js";
+import { formatError } from "./server-utils.js";
+export function createChannelManager(opts) {
+    const { loadConfig, logWhatsApp, logTelegram, logDiscord, logSlack, logSignal, logIMessage, whatsappRuntimeEnv, telegramRuntimeEnv, discordRuntimeEnv, slackRuntimeEnv, signalRuntimeEnv, imessageRuntimeEnv, } = opts;
+    const whatsappAborts = new Map();
+    let telegramAbort = null;
+    let discordAbort = null;
+    let slackAbort = null;
+    let signalAbort = null;
+    let imessageAbort = null;
+    const whatsappTasks = new Map();
+    let telegramTask = null;
+    let discordTask = null;
+    let slackTask = null;
+    let signalTask = null;
+    let imessageTask = null;
+    const whatsappRuntimes = new Map();
+    const defaultWhatsAppStatus = () => ({
+        running: false,
+        connected: false,
+        reconnectAttempts: 0,
+        lastConnectedAt: null,
+        lastDisconnect: null,
+        lastMessageAt: null,
+        lastEventAt: null,
+        lastError: null,
+    });
+    let telegramRuntime = {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+        mode: null,
+    };
+    let discordRuntime = {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+    };
+    let slackRuntime = {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+    };
+    let signalRuntime = {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+        baseUrl: null,
+    };
+    let imessageRuntime = {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+        cliPath: null,
+        dbPath: null,
+    };
+    const updateWhatsAppStatus = (accountId, next) => {
+        whatsappRuntimes.set(accountId, next);
+    };
+    const startWhatsAppChannel = async (accountId) => {
+        const cfg = loadConfig();
+        const enabledAccounts = listEnabledWhatsAppAccounts(cfg);
+        const targets = accountId
+            ? enabledAccounts.filter((a) => a.accountId === accountId)
+            : enabledAccounts;
+        if (targets.length === 0)
+            return;
+        if (cfg.web?.enabled === false) {
+            for (const account of targets) {
+                const current = whatsappRuntimes.get(account.accountId) ?? defaultWhatsAppStatus();
+                whatsappRuntimes.set(account.accountId, {
+                    ...current,
+                    running: false,
+                    connected: false,
+                    lastError: "disabled",
+                });
+            }
+            logWhatsApp.info("skipping channel start (web.enabled=false)");
+            return;
+        }
+        await Promise.all(targets.map(async (account) => {
+            if (whatsappTasks.has(account.accountId))
+                return;
+            const current = whatsappRuntimes.get(account.accountId) ?? defaultWhatsAppStatus();
+            if (!(await webAuthExists(account.authDir))) {
+                whatsappRuntimes.set(account.accountId, {
+                    ...current,
+                    running: false,
+                    connected: false,
+                    lastError: "not linked",
+                });
+                logWhatsApp.info(`[${account.accountId}] skipping channel start (no linked session)`);
+                return;
+            }
+            const { e164, jid } = readWebSelfId(account.authDir);
+            const identity = e164 ? e164 : jid ? `jid ${jid}` : "unknown";
+            logWhatsApp.info(`[${account.accountId}] starting channel (${identity})`);
+            const abort = new AbortController();
+            whatsappAborts.set(account.accountId, abort);
+            whatsappRuntimes.set(account.accountId, {
+                ...current,
+                running: true,
+                connected: false,
+                lastError: null,
+            });
+            const task = monitorWebChannel(shouldLogVerbose(), undefined, true, undefined, whatsappRuntimeEnv, abort.signal, {
+                statusSink: (next) => updateWhatsAppStatus(account.accountId, next),
+                accountId: account.accountId,
+            })
+                .catch((err) => {
+                const latest = whatsappRuntimes.get(account.accountId) ?? defaultWhatsAppStatus();
+                whatsappRuntimes.set(account.accountId, {
+                    ...latest,
+                    lastError: formatError(err),
+                });
+                logWhatsApp.error(`[${account.accountId}] channel exited: ${formatError(err)}`);
+            })
+                .finally(() => {
+                whatsappAborts.delete(account.accountId);
+                whatsappTasks.delete(account.accountId);
+                const latest = whatsappRuntimes.get(account.accountId) ?? defaultWhatsAppStatus();
+                whatsappRuntimes.set(account.accountId, {
+                    ...latest,
+                    running: false,
+                    connected: false,
+                });
+            });
+            whatsappTasks.set(account.accountId, task);
+        }));
+    };
+    const stopWhatsAppChannel = async (accountId) => {
+        const ids = accountId
+            ? [accountId]
+            : Array.from(new Set([...whatsappAborts.keys(), ...whatsappTasks.keys()]));
+        await Promise.all(ids.map(async (id) => {
+            const abort = whatsappAborts.get(id);
+            const task = whatsappTasks.get(id);
+            if (!abort && !task)
+                return;
+            abort?.abort();
+            try {
+                await task;
+            }
+            catch {
+                // ignore
+            }
+            whatsappAborts.delete(id);
+            whatsappTasks.delete(id);
+            const latest = whatsappRuntimes.get(id) ?? defaultWhatsAppStatus();
+            whatsappRuntimes.set(id, {
+                ...latest,
+                running: false,
+                connected: false,
+            });
+        }));
+    };
+    const startTelegramChannel = async () => {
+        if (telegramTask)
+            return;
+        const cfg = loadConfig();
+        if (cfg.telegram?.enabled === false) {
+            telegramRuntime = {
+                ...telegramRuntime,
+                running: false,
+                lastError: "disabled",
+            };
+            if (shouldLogVerbose()) {
+                logTelegram.debug("telegram channel disabled (telegram.enabled=false)");
+            }
+            return;
+        }
+        const { token: telegramToken } = resolveTelegramToken(cfg, {
+            logMissingFile: (message) => logTelegram.warn(message),
+        });
+        if (!telegramToken.trim()) {
+            telegramRuntime = {
+                ...telegramRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            // keep quiet by default; this is a normal state
+            if (shouldLogVerbose()) {
+                logTelegram.debug("telegram channel not configured (no TELEGRAM_BOT_TOKEN)");
+            }
+            return;
+        }
+        let telegramBotLabel = "";
+        try {
+            const probe = await probeTelegram(telegramToken.trim(), 2500, cfg.telegram?.proxy);
+            const username = probe.ok ? probe.bot?.username?.trim() : null;
+            if (username)
+                telegramBotLabel = ` (@${username})`;
+        }
+        catch (err) {
+            if (shouldLogVerbose()) {
+                logTelegram.debug(`bot probe failed: ${String(err)}`);
+            }
+        }
+        logTelegram.info(`starting channel${telegramBotLabel}${cfg.telegram ? "" : " (no telegram config; token via env)"}`);
+        telegramAbort = new AbortController();
+        telegramRuntime = {
+            ...telegramRuntime,
+            running: true,
+            lastStartAt: Date.now(),
+            lastError: null,
+            mode: cfg.telegram?.webhookUrl ? "webhook" : "polling",
+        };
+        const task = monitorTelegramProvider({
+            token: telegramToken.trim(),
+            runtime: telegramRuntimeEnv,
+            abortSignal: telegramAbort.signal,
+            useWebhook: Boolean(cfg.telegram?.webhookUrl),
+            webhookUrl: cfg.telegram?.webhookUrl,
+            webhookSecret: cfg.telegram?.webhookSecret,
+            webhookPath: cfg.telegram?.webhookPath,
+        })
+            .catch((err) => {
+            telegramRuntime = {
+                ...telegramRuntime,
+                lastError: formatError(err),
+            };
+            logTelegram.error(`channel exited: ${formatError(err)}`);
+        })
+            .finally(() => {
+            telegramAbort = null;
+            telegramTask = null;
+            telegramRuntime = {
+                ...telegramRuntime,
+                running: false,
+                lastStopAt: Date.now(),
+            };
+        });
+        telegramTask = task;
+    };
+    const stopTelegramChannel = async () => {
+        if (!telegramAbort && !telegramTask)
+            return;
+        telegramAbort?.abort();
+        try {
+            await telegramTask;
+        }
+        catch {
+            // ignore
+        }
+        telegramAbort = null;
+        telegramTask = null;
+        telegramRuntime = {
+            ...telegramRuntime,
+            running: false,
+            lastStopAt: Date.now(),
+        };
+    };
+    const startDiscordChannel = async () => {
+        if (discordTask)
+            return;
+        const cfg = loadConfig();
+        if (cfg.discord?.enabled === false) {
+            discordRuntime = {
+                ...discordRuntime,
+                running: false,
+                lastError: "disabled",
+            };
+            if (shouldLogVerbose()) {
+                logDiscord.debug("discord channel disabled (discord.enabled=false)");
+            }
+            return;
+        }
+        const discordToken = process.env.DISCORD_BOT_TOKEN ?? cfg.discord?.token ?? "";
+        if (!discordToken.trim()) {
+            discordRuntime = {
+                ...discordRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            // keep quiet by default; this is a normal state
+            if (shouldLogVerbose()) {
+                logDiscord.debug("discord channel not configured (no DISCORD_BOT_TOKEN)");
+            }
+            return;
+        }
+        let discordBotLabel = "";
+        try {
+            const probe = await probeDiscord(discordToken.trim(), 2500);
+            const username = probe.ok ? probe.bot?.username?.trim() : null;
+            if (username)
+                discordBotLabel = ` (@${username})`;
+        }
+        catch (err) {
+            if (shouldLogVerbose()) {
+                logDiscord.debug(`bot probe failed: ${String(err)}`);
+            }
+        }
+        logDiscord.info(`starting channel${discordBotLabel}${cfg.discord ? "" : " (no discord config; token via env)"}`);
+        discordAbort = new AbortController();
+        discordRuntime = {
+            ...discordRuntime,
+            running: true,
+            lastStartAt: Date.now(),
+            lastError: null,
+        };
+        const task = monitorDiscordProvider({
+            token: discordToken.trim(),
+            runtime: discordRuntimeEnv,
+            abortSignal: discordAbort.signal,
+            slashCommand: cfg.discord?.slashCommand,
+            mediaMaxMb: cfg.discord?.mediaMaxMb,
+            historyLimit: cfg.discord?.historyLimit,
+        })
+            .catch((err) => {
+            discordRuntime = {
+                ...discordRuntime,
+                lastError: formatError(err),
+            };
+            logDiscord.error(`channel exited: ${formatError(err)}`);
+        })
+            .finally(() => {
+            discordAbort = null;
+            discordTask = null;
+            discordRuntime = {
+                ...discordRuntime,
+                running: false,
+                lastStopAt: Date.now(),
+            };
+        });
+        discordTask = task;
+    };
+    const stopDiscordChannel = async () => {
+        if (!discordAbort && !discordTask)
+            return;
+        discordAbort?.abort();
+        try {
+            await discordTask;
+        }
+        catch {
+            // ignore
+        }
+        discordAbort = null;
+        discordTask = null;
+        discordRuntime = {
+            ...discordRuntime,
+            running: false,
+            lastStopAt: Date.now(),
+        };
+    };
+    const startSlackChannel = async () => {
+        if (slackTask)
+            return;
+        const cfg = loadConfig();
+        if (cfg.slack?.enabled === false) {
+            slackRuntime = {
+                ...slackRuntime,
+                running: false,
+                lastError: "disabled",
+            };
+            if (shouldLogVerbose()) {
+                logSlack.debug("slack channel disabled (slack.enabled=false)");
+            }
+            return;
+        }
+        const botToken = resolveSlackBotToken(process.env.SLACK_BOT_TOKEN ?? cfg.slack?.botToken ?? undefined);
+        const appToken = resolveSlackAppToken(process.env.SLACK_APP_TOKEN ?? cfg.slack?.appToken ?? undefined);
+        if (!botToken || !appToken) {
+            slackRuntime = {
+                ...slackRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            if (shouldLogVerbose()) {
+                logSlack.debug("slack channel not configured (missing SLACK_BOT_TOKEN/SLACK_APP_TOKEN)");
+            }
+            return;
+        }
+        logSlack.info(`starting channel${cfg.slack ? "" : " (no slack config; tokens via env)"}`);
+        slackAbort = new AbortController();
+        slackRuntime = {
+            ...slackRuntime,
+            running: true,
+            lastStartAt: Date.now(),
+            lastError: null,
+        };
+        const task = monitorSlackProvider({
+            botToken,
+            appToken,
+            runtime: slackRuntimeEnv,
+            abortSignal: slackAbort.signal,
+            mediaMaxMb: cfg.slack?.mediaMaxMb,
+            slashCommand: cfg.slack?.slashCommand,
+        })
+            .catch((err) => {
+            slackRuntime = {
+                ...slackRuntime,
+                lastError: formatError(err),
+            };
+            logSlack.error(`channel exited: ${formatError(err)}`);
+        })
+            .finally(() => {
+            slackAbort = null;
+            slackTask = null;
+            slackRuntime = {
+                ...slackRuntime,
+                running: false,
+                lastStopAt: Date.now(),
+            };
+        });
+        slackTask = task;
+    };
+    const stopSlackChannel = async () => {
+        if (!slackAbort && !slackTask)
+            return;
+        slackAbort?.abort();
+        try {
+            await slackTask;
+        }
+        catch {
+            // ignore
+        }
+        slackAbort = null;
+        slackTask = null;
+        slackRuntime = {
+            ...slackRuntime,
+            running: false,
+            lastStopAt: Date.now(),
+        };
+    };
+    const startSignalChannel = async () => {
+        if (signalTask)
+            return;
+        const cfg = loadConfig();
+        if (!cfg.signal) {
+            signalRuntime = {
+                ...signalRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            // keep quiet by default; this is a normal state
+            if (shouldLogVerbose()) {
+                logSignal.debug("signal channel not configured (no signal config)");
+            }
+            return;
+        }
+        if (cfg.signal?.enabled === false) {
+            signalRuntime = {
+                ...signalRuntime,
+                running: false,
+                lastError: "disabled",
+            };
+            if (shouldLogVerbose()) {
+                logSignal.debug("signal channel disabled (signal.enabled=false)");
+            }
+            return;
+        }
+        const signalCfg = cfg.signal;
+        const signalMeaningfullyConfigured = Boolean(signalCfg.account?.trim() ||
+            signalCfg.httpUrl?.trim() ||
+            signalCfg.cliPath?.trim() ||
+            signalCfg.httpHost?.trim() ||
+            typeof signalCfg.httpPort === "number" ||
+            typeof signalCfg.autoStart === "boolean");
+        if (!signalMeaningfullyConfigured) {
+            signalRuntime = {
+                ...signalRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            // keep quiet by default; this is a normal state
+            if (shouldLogVerbose()) {
+                logSignal.debug("signal channel not configured (signal config present but missing required fields)");
+            }
+            return;
+        }
+        const host = cfg.signal?.httpHost?.trim() || "127.0.0.1";
+        const port = cfg.signal?.httpPort ?? 8080;
+        const baseUrl = cfg.signal?.httpUrl?.trim() || `http://${host}:${port}`;
+        logSignal.info(`starting channel (${baseUrl})`);
+        signalAbort = new AbortController();
+        signalRuntime = {
+            ...signalRuntime,
+            running: true,
+            lastStartAt: Date.now(),
+            lastError: null,
+            baseUrl,
+        };
+        const task = monitorSignalProvider({
+            baseUrl,
+            account: cfg.signal?.account,
+            cliPath: cfg.signal?.cliPath,
+            httpHost: cfg.signal?.httpHost,
+            httpPort: cfg.signal?.httpPort,
+            autoStart: typeof cfg.signal?.autoStart === "boolean" ? cfg.signal.autoStart : undefined,
+            runtime: signalRuntimeEnv,
+            abortSignal: signalAbort.signal,
+        })
+            .catch((err) => {
+            signalRuntime = {
+                ...signalRuntime,
+                lastError: formatError(err),
+            };
+            logSignal.error(`channel exited: ${formatError(err)}`);
+        })
+            .finally(() => {
+            signalAbort = null;
+            signalTask = null;
+            signalRuntime = {
+                ...signalRuntime,
+                running: false,
+                lastStopAt: Date.now(),
+            };
+        });
+        signalTask = task;
+    };
+    const stopSignalChannel = async () => {
+        if (!signalAbort && !signalTask)
+            return;
+        signalAbort?.abort();
+        try {
+            await signalTask;
+        }
+        catch {
+            // ignore
+        }
+        signalAbort = null;
+        signalTask = null;
+        signalRuntime = {
+            ...signalRuntime,
+            running: false,
+            lastStopAt: Date.now(),
+        };
+    };
+    const startIMessageChannel = async () => {
+        if (imessageTask)
+            return;
+        const cfg = loadConfig();
+        if (!cfg.imessage) {
+            imessageRuntime = {
+                ...imessageRuntime,
+                running: false,
+                lastError: "not configured",
+            };
+            // keep quiet by default; this is a normal state
+            if (shouldLogVerbose()) {
+                logIMessage.debug("imessage channel not configured (no imessage config)");
+            }
+            return;
+        }
+        if (cfg.imessage?.enabled === false) {
+            imessageRuntime = {
+                ...imessageRuntime,
+                running: false,
+                lastError: "disabled",
+            };
+            if (shouldLogVerbose()) {
+                logIMessage.debug("imessage channel disabled (imessage.enabled=false)");
+            }
+            return;
+        }
+        const cliPath = cfg.imessage?.cliPath?.trim() || "imsg";
+        const dbPath = cfg.imessage?.dbPath?.trim();
+        logIMessage.info(`starting channel (${cliPath}${dbPath ? ` db=${dbPath}` : ""})`);
+        imessageAbort = new AbortController();
+        imessageRuntime = {
+            ...imessageRuntime,
+            running: true,
+            lastStartAt: Date.now(),
+            lastError: null,
+            cliPath,
+            dbPath: dbPath ?? null,
+        };
+        const task = monitorIMessageProvider({
+            cliPath,
+            dbPath,
+            allowFrom: cfg.imessage?.allowFrom,
+            includeAttachments: cfg.imessage?.includeAttachments,
+            mediaMaxMb: cfg.imessage?.mediaMaxMb,
+            runtime: imessageRuntimeEnv,
+            abortSignal: imessageAbort.signal,
+        })
+            .catch((err) => {
+            imessageRuntime = {
+                ...imessageRuntime,
+                lastError: formatError(err),
+            };
+            logIMessage.error(`channel exited: ${formatError(err)}`);
+        })
+            .finally(() => {
+            imessageAbort = null;
+            imessageTask = null;
+            imessageRuntime = {
+                ...imessageRuntime,
+                running: false,
+                lastStopAt: Date.now(),
+            };
+        });
+        imessageTask = task;
+    };
+    const stopIMessageChannel = async () => {
+        if (!imessageAbort && !imessageTask)
+            return;
+        imessageAbort?.abort();
+        try {
+            await imessageTask;
+        }
+        catch {
+            // ignore
+        }
+        imessageAbort = null;
+        imessageTask = null;
+        imessageRuntime = {
+            ...imessageRuntime,
+            running: false,
+            lastStopAt: Date.now(),
+        };
+    };
+    const startChannels = async () => {
+        await startWhatsAppChannel();
+        await startDiscordChannel();
+        await startSlackChannel();
+        await startTelegramChannel();
+        await startSignalChannel();
+        await startIMessageChannel();
+    };
+    const markWhatsAppLoggedOut = (cleared, accountId) => {
+        const cfg = loadConfig();
+        const resolvedId = accountId ?? resolveDefaultWhatsAppAccountId(cfg);
+        const current = whatsappRuntimes.get(resolvedId) ?? defaultWhatsAppStatus();
+        whatsappRuntimes.set(resolvedId, {
+            ...current,
+            running: false,
+            connected: false,
+            lastError: cleared ? "logged out" : current.lastError,
+        });
+    };
+    const getRuntimeSnapshot = () => {
+        const cfg = loadConfig();
+        const defaultId = resolveDefaultWhatsAppAccountId(cfg);
+        const whatsapp = whatsappRuntimes.get(defaultId) ?? defaultWhatsAppStatus();
+        const whatsappAccounts = Object.fromEntries(Array.from(whatsappRuntimes.entries()).map(([id, status]) => [id, { ...status }]));
+        return {
+            whatsapp: { ...whatsapp },
+            whatsappAccounts,
+            telegram: { ...telegramRuntime },
+            discord: { ...discordRuntime },
+            slack: { ...slackRuntime },
+            signal: { ...signalRuntime },
+            imessage: { ...imessageRuntime },
+        };
+    };
+    return {
+        getRuntimeSnapshot,
+        startChannels,
+        startWhatsAppChannel,
+        stopWhatsAppChannel,
+        startTelegramChannel,
+        stopTelegramChannel,
+        startDiscordChannel,
+        stopDiscordChannel,
+        startSlackChannel,
+        stopSlackChannel,
+        startSignalChannel,
+        stopSignalChannel,
+        startIMessageChannel,
+        stopIMessageChannel,
+        markWhatsAppLoggedOut,
+    };
+}