@intent-systems/nexus 2026.1.5-3

package/dist/gateway/server-methods/agent.js

@@ -0,0 +1,254 @@
+import { randomUUID } from "node:crypto";
+import { agentCommand } from "../../commands/agent.js";
+import { loadConfig } from "../../config/config.js";
+import { resolveAgentIdFromSessionKey, resolveAgentMainSessionKey, saveSessionStore, } from "../../config/sessions.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { defaultRuntime } from "../../runtime.js";
+import { resolveSendPolicy } from "../../sessions/send-policy.js";
+import { normalizeE164 } from "../../utils.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateAgentParams, validateAgentWaitParams, } from "../protocol/index.js";
+import { loadSessionEntry } from "../session-utils.js";
+import { formatForLog } from "../ws-log.js";
+import { waitForAgentJob } from "./agent-job.js";
+export const agentHandlers = {
+    agent: async ({ params, respond, context }) => {
+        const p = params;
+        if (!validateAgentParams(p)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: ${formatValidationErrors(validateAgentParams.errors)}`));
+            return;
+        }
+        const request = p;
+        const idem = request.idempotencyKey;
+        const cached = context.dedupe.get(`agent:${idem}`);
+        if (cached) {
+            respond(cached.ok, cached.payload, cached.error, {
+                cached: true,
+            });
+            return;
+        }
+        const message = request.message.trim();
+        const requestedSessionKey = typeof request.sessionKey === "string" && request.sessionKey.trim()
+            ? request.sessionKey.trim()
+            : undefined;
+        let resolvedSessionId = request.sessionId?.trim() || undefined;
+        let sessionEntry;
+        let bestEffortDeliver = false;
+        let cfgForAgent;
+        if (requestedSessionKey) {
+            const { cfg, storePath, store, entry } = loadSessionEntry(requestedSessionKey);
+            cfgForAgent = cfg;
+            const now = Date.now();
+            const sessionId = entry?.sessionId ?? randomUUID();
+            const nextEntry = {
+                sessionId,
+                updatedAt: now,
+                thinkingLevel: entry?.thinkingLevel,
+                verboseLevel: entry?.verboseLevel,
+                systemSent: entry?.systemSent,
+                sendPolicy: entry?.sendPolicy,
+                skillsSnapshot: entry?.skillsSnapshot,
+                lastProvider: entry?.lastProvider,
+                lastTo: entry?.lastTo,
+            };
+            sessionEntry = nextEntry;
+            const sendPolicy = resolveSendPolicy({
+                cfg,
+                entry,
+                sessionKey: requestedSessionKey,
+                provider: entry?.provider,
+                chatType: entry?.chatType,
+            });
+            if (sendPolicy === "deny") {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "send blocked by session policy"));
+                return;
+            }
+            if (store) {
+                store[requestedSessionKey] = nextEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, store);
+                }
+            }
+            resolvedSessionId = sessionId;
+            const agentId = resolveAgentIdFromSessionKey(requestedSessionKey);
+            const mainSessionKey = resolveAgentMainSessionKey({
+                cfg,
+                agentId,
+            });
+            const rawMainKey = (cfg.session?.mainKey ?? "main").trim() || "main";
+            if (requestedSessionKey === mainSessionKey ||
+                requestedSessionKey === rawMainKey) {
+                context.addChatRun(idem, {
+                    sessionKey: requestedSessionKey,
+                    clientRunId: idem,
+                });
+                bestEffortDeliver = true;
+            }
+            registerAgentRunContext(idem, { sessionKey: requestedSessionKey });
+        }
+        const runId = idem;
+        const requestedProviderRaw = typeof request.provider === "string" ? request.provider.trim() : "";
+        const requestedProviderNormalized = requestedProviderRaw
+            ? requestedProviderRaw.toLowerCase()
+            : "last";
+        const requestedProvider = requestedProviderNormalized === "imsg"
+            ? "imessage"
+            : requestedProviderNormalized;
+        const lastProvider = sessionEntry?.lastProvider;
+        const lastTo = typeof sessionEntry?.lastTo === "string"
+            ? sessionEntry.lastTo.trim()
+            : "";
+        const resolvedProvider = (() => {
+            if (requestedProvider === "last") {
+                // WebChat is not a deliverable surface. Treat it as "unset" for routing,
+                // so VoiceWake and CLI callers don't get stuck with deliver=false.
+                return lastProvider && lastProvider !== "webchat"
+                    ? lastProvider
+                    : "whatsapp";
+            }
+            if (requestedProvider === "whatsapp" ||
+                requestedProvider === "telegram" ||
+                requestedProvider === "discord" ||
+                requestedProvider === "signal" ||
+                requestedProvider === "imessage" ||
+                requestedProvider === "webchat") {
+                return requestedProvider;
+            }
+            return lastProvider && lastProvider !== "webchat"
+                ? lastProvider
+                : "whatsapp";
+        })();
+        const resolvedTo = (() => {
+            const explicit = typeof request.to === "string" && request.to.trim()
+                ? request.to.trim()
+                : undefined;
+            if (explicit)
+                return explicit;
+            if (resolvedProvider === "whatsapp" ||
+                resolvedProvider === "telegram" ||
+                resolvedProvider === "discord" ||
+                resolvedProvider === "signal" ||
+                resolvedProvider === "imessage") {
+                return lastTo || undefined;
+            }
+            return undefined;
+        })();
+        const sanitizedTo = (() => {
+            // If we derived a WhatsApp recipient from session "lastTo", ensure it is still valid
+            // for the configured allowlist. Otherwise, fall back to the first allowed number so
+            // voice wake doesn't silently route to stale/test recipients.
+            if (resolvedProvider !== "whatsapp")
+                return resolvedTo;
+            const explicit = typeof request.to === "string" && request.to.trim()
+                ? request.to.trim()
+                : undefined;
+            if (explicit)
+                return resolvedTo;
+            const cfg = cfgForAgent ?? loadConfig();
+            const rawAllow = cfg.whatsapp?.allowFrom ?? [];
+            if (rawAllow.includes("*"))
+                return resolvedTo;
+            const allowFrom = rawAllow
+                .map((val) => normalizeE164(val))
+                .filter((val) => val.length > 1);
+            if (allowFrom.length === 0)
+                return resolvedTo;
+            const normalizedLast = typeof resolvedTo === "string" && resolvedTo.trim()
+                ? normalizeE164(resolvedTo)
+                : undefined;
+            if (normalizedLast && allowFrom.includes(normalizedLast)) {
+                return normalizedLast;
+            }
+            return allowFrom[0];
+        })();
+        const deliver = request.deliver === true && resolvedProvider !== "webchat";
+        const accepted = {
+            runId,
+            status: "accepted",
+            acceptedAt: Date.now(),
+        };
+        // Store an in-flight ack so retries do not spawn a second run.
+        context.dedupe.set(`agent:${idem}`, {
+            ts: Date.now(),
+            ok: true,
+            payload: accepted,
+        });
+        respond(true, accepted, undefined, { runId });
+        void agentCommand({
+            message,
+            to: sanitizedTo,
+            sessionId: resolvedSessionId,
+            thinking: request.thinking,
+            deliver,
+            provider: resolvedProvider,
+            timeout: request.timeout?.toString(),
+            bestEffortDeliver,
+            messageProvider: "voicewake",
+            runId,
+            lane: request.lane,
+            extraSystemPrompt: request.extraSystemPrompt,
+        }, defaultRuntime, context.deps)
+            .then((result) => {
+            const payload = {
+                runId,
+                status: "ok",
+                summary: "completed",
+                result,
+            };
+            context.dedupe.set(`agent:${idem}`, {
+                ts: Date.now(),
+                ok: true,
+                payload,
+            });
+            // Send a second res frame (same id) so TS clients with expectFinal can wait.
+            // Swift clients will typically treat the first res as the result and ignore this.
+            respond(true, payload, undefined, { runId });
+        })
+            .catch((err) => {
+            const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
+            const payload = {
+                runId,
+                status: "error",
+                summary: String(err),
+            };
+            context.dedupe.set(`agent:${idem}`, {
+                ts: Date.now(),
+                ok: false,
+                payload,
+                error,
+            });
+            respond(false, payload, error, {
+                runId,
+                error: formatForLog(err),
+            });
+        });
+    },
+    "agent.wait": async ({ params, respond }) => {
+        if (!validateAgentWaitParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.wait params: ${formatValidationErrors(validateAgentWaitParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const runId = p.runId.trim();
+        const timeoutMs = typeof p.timeoutMs === "number" && Number.isFinite(p.timeoutMs)
+            ? Math.max(0, Math.floor(p.timeoutMs))
+            : 30_000;
+        const snapshot = await waitForAgentJob({
+            runId,
+            timeoutMs,
+        });
+        if (!snapshot) {
+            respond(true, {
+                runId,
+                status: "timeout",
+            });
+            return;
+        }
+        respond(true, {
+            runId,
+            status: snapshot.status,
+            startedAt: snapshot.startedAt,
+            endedAt: snapshot.endedAt,
+            error: snapshot.error,
+        });
+    },
+};

package/dist/gateway/server-methods/channels.js

@@ -0,0 +1,239 @@
+import { loadConfig, readConfigFileSnapshot, writeConfigFile } from "../../config/config.js";
+import { probeDiscord } from "../../discord/probe.js";
+import { probeIMessage } from "../../imessage/probe.js";
+import { probeSignal } from "../../signal/probe.js";
+import { probeSlack } from "../../slack/probe.js";
+import { resolveSlackAppToken, resolveSlackBotToken } from "../../slack/token.js";
+import { probeTelegram } from "../../telegram/probe.js";
+import { resolveTelegramToken } from "../../telegram/token.js";
+import { listEnabledWhatsAppAccounts, resolveDefaultWhatsAppAccountId, } from "../../web/accounts.js";
+import { getWebAuthAgeMs, readWebSelfId, webAuthExists } from "../../web/session.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateChannelsStatusParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const channelsHandlers = {
+    "channels.status": async ({ params, respond, context }) => {
+        if (!validateChannelsStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid channels.status params: ${formatValidationErrors(validateChannelsStatusParams.errors)}`));
+            return;
+        }
+        const probe = params.probe === true;
+        const timeoutMsRaw = params.timeoutMs;
+        const timeoutMs = typeof timeoutMsRaw === "number" ? Math.max(1000, timeoutMsRaw) : 10_000;
+        const cfg = loadConfig();
+        const telegramCfg = cfg.telegram;
+        const telegramEnabled = Boolean(telegramCfg) && telegramCfg?.enabled !== false;
+        const { token: telegramToken, source: tokenSource } = telegramEnabled
+            ? resolveTelegramToken(cfg)
+            : { token: "", source: "none" };
+        let telegramProbe;
+        let lastProbeAt = null;
+        if (probe && telegramToken && telegramEnabled) {
+            telegramProbe = await probeTelegram(telegramToken, timeoutMs, telegramCfg?.proxy);
+            lastProbeAt = Date.now();
+        }
+        const discordCfg = cfg.discord;
+        const discordEnabled = Boolean(discordCfg) && discordCfg?.enabled !== false;
+        const discordEnvToken = discordEnabled ? process.env.DISCORD_BOT_TOKEN?.trim() : "";
+        const discordConfigToken = discordEnabled ? discordCfg?.token?.trim() : "";
+        const discordToken = discordEnvToken || discordConfigToken || "";
+        const discordTokenSource = discordEnvToken ? "env" : discordConfigToken ? "config" : "none";
+        let discordProbe;
+        let discordLastProbeAt = null;
+        if (probe && discordToken && discordEnabled) {
+            discordProbe = await probeDiscord(discordToken, timeoutMs);
+            discordLastProbeAt = Date.now();
+        }
+        const slackCfg = cfg.slack;
+        const slackEnabled = slackCfg?.enabled !== false;
+        const slackBotEnvToken = slackEnabled
+            ? resolveSlackBotToken(process.env.SLACK_BOT_TOKEN)
+            : undefined;
+        const slackBotConfigToken = slackEnabled ? resolveSlackBotToken(slackCfg?.botToken) : undefined;
+        const slackBotToken = slackBotEnvToken ?? slackBotConfigToken ?? "";
+        const slackBotTokenSource = slackBotEnvToken ? "env" : slackBotConfigToken ? "config" : "none";
+        const slackAppEnvToken = slackEnabled
+            ? resolveSlackAppToken(process.env.SLACK_APP_TOKEN)
+            : undefined;
+        const slackAppConfigToken = slackEnabled ? resolveSlackAppToken(slackCfg?.appToken) : undefined;
+        const slackAppToken = slackAppEnvToken ?? slackAppConfigToken ?? "";
+        const slackAppTokenSource = slackAppEnvToken ? "env" : slackAppConfigToken ? "config" : "none";
+        const slackConfigured = slackEnabled && Boolean(slackBotToken) && Boolean(slackAppToken);
+        let slackProbe;
+        let slackLastProbeAt = null;
+        if (probe && slackConfigured) {
+            slackProbe = await probeSlack(slackBotToken, timeoutMs);
+            slackLastProbeAt = Date.now();
+        }
+        const signalCfg = cfg.signal;
+        const signalEnabled = signalCfg?.enabled !== false;
+        const signalHost = signalCfg?.httpHost?.trim() || "127.0.0.1";
+        const signalPort = signalCfg?.httpPort ?? 8080;
+        const signalBaseUrl = signalCfg?.httpUrl?.trim() || `http://${signalHost}:${signalPort}`;
+        const signalConfigured = Boolean(signalCfg) &&
+            signalEnabled &&
+            Boolean(signalCfg?.account?.trim() ||
+                signalCfg?.httpUrl?.trim() ||
+                signalCfg?.cliPath?.trim() ||
+                signalCfg?.httpHost?.trim() ||
+                typeof signalCfg?.httpPort === "number" ||
+                typeof signalCfg?.autoStart === "boolean");
+        let signalProbe;
+        let signalLastProbeAt = null;
+        if (probe && signalConfigured) {
+            signalProbe = await probeSignal(signalBaseUrl, timeoutMs);
+            signalLastProbeAt = Date.now();
+        }
+        const imessageCfg = cfg.imessage;
+        const imessageEnabled = imessageCfg?.enabled !== false;
+        const imessageConfigured = Boolean(imessageCfg) && imessageEnabled;
+        let imessageProbe;
+        let imessageLastProbeAt = null;
+        if (probe && imessageConfigured) {
+            imessageProbe = await probeIMessage(timeoutMs);
+            imessageLastProbeAt = Date.now();
+        }
+        const runtime = context.getRuntimeSnapshot();
+        const defaultWhatsAppAccountId = resolveDefaultWhatsAppAccountId(cfg);
+        const enabledWhatsAppAccounts = listEnabledWhatsAppAccounts(cfg);
+        const defaultWhatsAppAccount = enabledWhatsAppAccounts.find((account) => account.accountId === defaultWhatsAppAccountId) ??
+            enabledWhatsAppAccounts[0];
+        const linked = defaultWhatsAppAccount
+            ? await webAuthExists(defaultWhatsAppAccount.authDir)
+            : false;
+        const authAgeMs = defaultWhatsAppAccount
+            ? getWebAuthAgeMs(defaultWhatsAppAccount.authDir)
+            : null;
+        const self = defaultWhatsAppAccount
+            ? readWebSelfId(defaultWhatsAppAccount.authDir)
+            : { e164: null, jid: null };
+        const defaultWhatsAppStatus = {
+            running: false,
+            connected: false,
+            reconnectAttempts: 0,
+            lastConnectedAt: null,
+            lastDisconnect: null,
+            lastMessageAt: null,
+            lastEventAt: null,
+            lastError: null,
+        };
+        const whatsappAccounts = await Promise.all(enabledWhatsAppAccounts.map(async (account) => {
+            const rt = runtime.whatsappAccounts?.[account.accountId] ?? defaultWhatsAppStatus;
+            return {
+                accountId: account.accountId,
+                enabled: account.enabled,
+                linked: await webAuthExists(account.authDir),
+                authAgeMs: getWebAuthAgeMs(account.authDir),
+                self: readWebSelfId(account.authDir),
+                running: rt.running,
+                connected: rt.connected,
+                lastConnectedAt: rt.lastConnectedAt ?? null,
+                lastDisconnect: rt.lastDisconnect ?? null,
+                reconnectAttempts: rt.reconnectAttempts,
+                lastMessageAt: rt.lastMessageAt ?? null,
+                lastEventAt: rt.lastEventAt ?? null,
+                lastError: rt.lastError ?? null,
+            };
+        }));
+        respond(true, {
+            ts: Date.now(),
+            whatsapp: {
+                configured: linked,
+                linked,
+                authAgeMs,
+                self,
+                running: runtime.whatsapp.running,
+                connected: runtime.whatsapp.connected,
+                lastConnectedAt: runtime.whatsapp.lastConnectedAt ?? null,
+                lastDisconnect: runtime.whatsapp.lastDisconnect ?? null,
+                reconnectAttempts: runtime.whatsapp.reconnectAttempts,
+                lastMessageAt: runtime.whatsapp.lastMessageAt ?? null,
+                lastEventAt: runtime.whatsapp.lastEventAt ?? null,
+                lastError: runtime.whatsapp.lastError ?? null,
+            },
+            whatsappAccounts,
+            whatsappDefaultAccountId: defaultWhatsAppAccountId,
+            telegram: {
+                configured: telegramEnabled && Boolean(telegramToken),
+                tokenSource,
+                running: runtime.telegram.running,
+                mode: runtime.telegram.mode ?? null,
+                lastStartAt: runtime.telegram.lastStartAt ?? null,
+                lastStopAt: runtime.telegram.lastStopAt ?? null,
+                lastError: runtime.telegram.lastError ?? null,
+                probe: telegramProbe,
+                lastProbeAt,
+            },
+            discord: {
+                configured: discordEnabled && Boolean(discordToken),
+                tokenSource: discordTokenSource,
+                running: runtime.discord.running,
+                lastStartAt: runtime.discord.lastStartAt ?? null,
+                lastStopAt: runtime.discord.lastStopAt ?? null,
+                lastError: runtime.discord.lastError ?? null,
+                probe: discordProbe,
+                lastProbeAt: discordLastProbeAt,
+            },
+            slack: {
+                configured: slackConfigured,
+                botTokenSource: slackBotTokenSource,
+                appTokenSource: slackAppTokenSource,
+                running: runtime.slack.running,
+                lastStartAt: runtime.slack.lastStartAt ?? null,
+                lastStopAt: runtime.slack.lastStopAt ?? null,
+                lastError: runtime.slack.lastError ?? null,
+                probe: slackProbe,
+                lastProbeAt: slackLastProbeAt,
+            },
+            signal: {
+                configured: signalConfigured,
+                baseUrl: signalBaseUrl,
+                running: runtime.signal.running,
+                lastStartAt: runtime.signal.lastStartAt ?? null,
+                lastStopAt: runtime.signal.lastStopAt ?? null,
+                lastError: runtime.signal.lastError ?? null,
+                probe: signalProbe,
+                lastProbeAt: signalLastProbeAt,
+            },
+            imessage: {
+                configured: imessageConfigured,
+                running: runtime.imessage.running,
+                lastStartAt: runtime.imessage.lastStartAt ?? null,
+                lastStopAt: runtime.imessage.lastStopAt ?? null,
+                lastError: runtime.imessage.lastError ?? null,
+                cliPath: runtime.imessage.cliPath ?? null,
+                dbPath: runtime.imessage.dbPath ?? null,
+                probe: imessageProbe,
+                lastProbeAt: imessageLastProbeAt,
+            },
+        }, undefined);
+    },
+    "telegram.logout": async ({ respond, context }) => {
+        try {
+            await context.stopTelegramChannel();
+            const snapshot = await readConfigFileSnapshot();
+            if (!snapshot.valid) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "config invalid; fix it before logging out"));
+                return;
+            }
+            const cfg = snapshot.config ?? {};
+            const envToken = process.env.TELEGRAM_BOT_TOKEN?.trim() ?? "";
+            const hadToken = Boolean(cfg.telegram?.botToken);
+            const nextTelegram = cfg.telegram ? { ...cfg.telegram } : undefined;
+            if (nextTelegram) {
+                delete nextTelegram.botToken;
+            }
+            const nextCfg = { ...cfg };
+            if (nextTelegram && Object.keys(nextTelegram).length > 0) {
+                nextCfg.telegram = nextTelegram;
+            }
+            else {
+                delete nextCfg.telegram;
+            }
+            await writeConfigFile(nextCfg);
+            respond(true, { cleared: hadToken, envToken: Boolean(envToken) }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};