@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,83 @@
+import { installSkill } from "../../agents/skills-install.js";
+import { buildWorkspaceSkillStatus } from "../../agents/skills-status.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "../../agents/workspace.js";
+import { loadConfig, writeConfigFile } from "../../config/config.js";
+import { resolveUserPath } from "../../utils.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsInstallParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
+export const skillsHandlers = {
+    "skills.status": ({ params, respond }) => {
+        if (!validateSkillsStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.status params: ${formatValidationErrors(validateSkillsStatusParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const workspaceDirRaw = cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+        const workspaceDir = resolveUserPath(workspaceDirRaw);
+        const report = buildWorkspaceSkillStatus(workspaceDir, {
+            config: cfg,
+        });
+        respond(true, report, undefined);
+    },
+    "skills.install": async ({ params, respond }) => {
+        if (!validateSkillsInstallParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.install params: ${formatValidationErrors(validateSkillsInstallParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const workspaceDirRaw = cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+        const result = await installSkill({
+            workspaceDir: workspaceDirRaw,
+            skillName: p.name,
+            installId: p.installId,
+            timeoutMs: p.timeoutMs,
+            config: cfg,
+        });
+        respond(result.ok, result, result.ok
+            ? undefined
+            : errorShape(ErrorCodes.UNAVAILABLE, result.message));
+    },
+    "skills.update": async ({ params, respond }) => {
+        if (!validateSkillsUpdateParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.update params: ${formatValidationErrors(validateSkillsUpdateParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const skills = cfg.skills ? { ...cfg.skills } : {};
+        const entries = skills.entries ? { ...skills.entries } : {};
+        const current = entries[p.skillKey] ? { ...entries[p.skillKey] } : {};
+        if (typeof p.enabled === "boolean") {
+            current.enabled = p.enabled;
+        }
+        if (typeof p.apiKey === "string") {
+            const trimmed = p.apiKey.trim();
+            if (trimmed)
+                current.apiKey = trimmed;
+            else
+                delete current.apiKey;
+        }
+        if (p.env && typeof p.env === "object") {
+            const nextEnv = current.env ? { ...current.env } : {};
+            for (const [key, value] of Object.entries(p.env)) {
+                const trimmedKey = key.trim();
+                if (!trimmedKey)
+                    continue;
+                const trimmedVal = value.trim();
+                if (!trimmedVal)
+                    delete nextEnv[trimmedKey];
+                else
+                    nextEnv[trimmedKey] = trimmedVal;
+            }
+            current.env = nextEnv;
+        }
+        entries[p.skillKey] = current;
+        skills.entries = entries;
+        const nextConfig = {
+            ...cfg,
+            skills,
+        };
+        await writeConfigFile(nextConfig);
+        respond(true, { ok: true, skillKey: p.skillKey, config: current }, undefined);
+    },
+};

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

@@ -0,0 +1,118 @@
+import { getLastHeartbeatEvent } from "../../infra/heartbeat-events.js";
+import { setHeartbeatsEnabled } from "../../infra/heartbeat-runner.js";
+import { enqueueSystemEvent, isSystemEventContextChanged, } from "../../infra/system-events.js";
+import { listSystemPresence, updateSystemPresence, } from "../../infra/system-presence.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+export const systemHandlers = {
+    "last-heartbeat": ({ respond }) => {
+        respond(true, getLastHeartbeatEvent(), undefined);
+    },
+    "set-heartbeats": ({ params, respond }) => {
+        const enabled = params.enabled;
+        if (typeof enabled !== "boolean") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid set-heartbeats params: enabled (boolean) required"));
+            return;
+        }
+        setHeartbeatsEnabled(enabled);
+        respond(true, { ok: true, enabled }, undefined);
+    },
+    "system-presence": ({ respond }) => {
+        const presence = listSystemPresence();
+        respond(true, presence, undefined);
+    },
+    "system-event": ({ params, respond, context }) => {
+        const text = typeof params.text === "string" ? params.text.trim() : "";
+        if (!text) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "text required"));
+            return;
+        }
+        const instanceId = typeof params.instanceId === "string" ? params.instanceId : undefined;
+        const host = typeof params.host === "string" ? params.host : undefined;
+        const ip = typeof params.ip === "string" ? params.ip : undefined;
+        const mode = typeof params.mode === "string" ? params.mode : undefined;
+        const version = typeof params.version === "string" ? params.version : undefined;
+        const platform = typeof params.platform === "string" ? params.platform : undefined;
+        const deviceFamily = typeof params.deviceFamily === "string" ? params.deviceFamily : undefined;
+        const modelIdentifier = typeof params.modelIdentifier === "string"
+            ? params.modelIdentifier
+            : undefined;
+        const lastInputSeconds = typeof params.lastInputSeconds === "number" &&
+            Number.isFinite(params.lastInputSeconds)
+            ? params.lastInputSeconds
+            : undefined;
+        const reason = typeof params.reason === "string" ? params.reason : undefined;
+        const tags = Array.isArray(params.tags) &&
+            params.tags.every((t) => typeof t === "string")
+            ? params.tags
+            : undefined;
+        const presenceUpdate = updateSystemPresence({
+            text,
+            instanceId,
+            host,
+            ip,
+            mode,
+            version,
+            platform,
+            deviceFamily,
+            modelIdentifier,
+            lastInputSeconds,
+            reason,
+            tags,
+        });
+        const isNodePresenceLine = text.startsWith("Node:");
+        if (isNodePresenceLine) {
+            const next = presenceUpdate.next;
+            const changed = new Set(presenceUpdate.changedKeys);
+            const reasonValue = next.reason ?? reason;
+            const normalizedReason = (reasonValue ?? "").toLowerCase();
+            const ignoreReason = normalizedReason.startsWith("periodic") ||
+                normalizedReason === "heartbeat";
+            const hostChanged = changed.has("host");
+            const ipChanged = changed.has("ip");
+            const versionChanged = changed.has("version");
+            const modeChanged = changed.has("mode");
+            const reasonChanged = changed.has("reason") && !ignoreReason;
+            const hasChanges = hostChanged ||
+                ipChanged ||
+                versionChanged ||
+                modeChanged ||
+                reasonChanged;
+            if (hasChanges) {
+                const contextChanged = isSystemEventContextChanged(presenceUpdate.key);
+                const parts = [];
+                if (contextChanged || hostChanged || ipChanged) {
+                    const hostLabel = next.host?.trim() || "Unknown";
+                    const ipLabel = next.ip?.trim();
+                    parts.push(`Node: ${hostLabel}${ipLabel ? ` (${ipLabel})` : ""}`);
+                }
+                if (versionChanged) {
+                    parts.push(`app ${next.version?.trim() || "unknown"}`);
+                }
+                if (modeChanged) {
+                    parts.push(`mode ${next.mode?.trim() || "unknown"}`);
+                }
+                if (reasonChanged) {
+                    parts.push(`reason ${reasonValue?.trim() || "event"}`);
+                }
+                const deltaText = parts.join(" · ");
+                if (deltaText) {
+                    enqueueSystemEvent(deltaText, {
+                        contextKey: presenceUpdate.key,
+                    });
+                }
+            }
+        }
+        else {
+            enqueueSystemEvent(text);
+        }
+        const nextPresenceVersion = context.incrementPresenceVersion();
+        context.broadcast("presence", { presence: listSystemPresence() }, {
+            dropIfSlow: true,
+            stateVersion: {
+                presence: nextPresenceVersion,
+                health: context.getHealthVersion(),
+            },
+        });
+        respond(true, { ok: true }, undefined);
+    },
+};

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

@@ -0,0 +1,22 @@
+import { ErrorCodes, errorShape, formatValidationErrors, validateTalkModeParams, } from "../protocol/index.js";
+export const talkHandlers = {
+    "talk.mode": ({ params, respond, context, client, isWebchatConnect }) => {
+        if (client &&
+            isWebchatConnect(client.connect) &&
+            !context.hasConnectedMobileNode()) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "talk disabled: no connected iOS/Android nodes"));
+            return;
+        }
+        if (!validateTalkModeParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.mode params: ${formatValidationErrors(validateTalkModeParams.errors)}`));
+            return;
+        }
+        const payload = {
+            enabled: params.enabled,
+            phase: params.phase ?? null,
+            ts: Date.now(),
+        };
+        context.broadcast("talk.mode", payload, { dropIfSlow: true });
+        respond(true, payload, undefined);
+    },
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,30 @@
+import { loadVoiceWakeConfig, setVoiceWakeTriggers, } from "../../infra/voicewake.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+import { normalizeVoiceWakeTriggers } from "../server-utils.js";
+import { formatForLog } from "../ws-log.js";
+export const voicewakeHandlers = {
+    "voicewake.get": async ({ respond }) => {
+        try {
+            const cfg = await loadVoiceWakeConfig();
+            respond(true, { triggers: cfg.triggers });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "voicewake.set": async ({ params, respond, context }) => {
+        if (!Array.isArray(params.triggers)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "voicewake.set requires triggers: string[]"));
+            return;
+        }
+        try {
+            const triggers = normalizeVoiceWakeTriggers(params.triggers);
+            const cfg = await setVoiceWakeTriggers(triggers);
+            context.broadcastVoiceWakeChanged(cfg.triggers);
+            respond(true, { triggers: cfg.triggers });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};

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

@@ -0,0 +1,81 @@
+import { loadConfig } from "../../config/config.js";
+import { defaultRuntime } from "../../runtime.js";
+import { resolveWhatsAppAccount } from "../../web/accounts.js";
+import { startWebLoginWithQr, waitForWebLogin } from "../../web/login-qr.js";
+import { logoutWeb } from "../../web/session.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateWebLoginStartParams, validateWebLoginWaitParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const webHandlers = {
+    "web.login.start": async ({ params, respond, context }) => {
+        if (!validateWebLoginStartParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid web.login.start params: ${formatValidationErrors(validateWebLoginStartParams.errors)}`));
+            return;
+        }
+        try {
+            const accountId = typeof params.accountId === "string"
+                ? params.accountId
+                : undefined;
+            await context.stopWhatsAppProvider(accountId);
+            const result = await startWebLoginWithQr({
+                force: Boolean(params.force),
+                timeoutMs: typeof params.timeoutMs === "number"
+                    ? params.timeoutMs
+                    : undefined,
+                verbose: Boolean(params.verbose),
+                accountId,
+            });
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "web.login.wait": async ({ params, respond, context }) => {
+        if (!validateWebLoginWaitParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid web.login.wait params: ${formatValidationErrors(validateWebLoginWaitParams.errors)}`));
+            return;
+        }
+        try {
+            const accountId = typeof params.accountId === "string"
+                ? params.accountId
+                : undefined;
+            const result = await waitForWebLogin({
+                timeoutMs: typeof params.timeoutMs === "number"
+                    ? params.timeoutMs
+                    : undefined,
+                accountId,
+            });
+            if (result.connected) {
+                await context.startWhatsAppProvider(accountId);
+            }
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "web.logout": async ({ params, respond, context }) => {
+        try {
+            const rawAccountId = params && typeof params === "object" && "accountId" in params
+                ? params.accountId
+                : undefined;
+            const accountId = typeof rawAccountId === "string" ? rawAccountId.trim() : "";
+            const cfg = loadConfig();
+            const account = resolveWhatsAppAccount({
+                cfg,
+                accountId: accountId || undefined,
+            });
+            await context.stopWhatsAppProvider(account.accountId);
+            const cleared = await logoutWeb({
+                authDir: account.authDir,
+                isLegacyAuthDir: account.isLegacyAuthDir,
+                runtime: defaultRuntime,
+            });
+            context.markWhatsAppLoggedOut(cleared, account.accountId);
+            respond(true, { cleared }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};

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

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { defaultRuntime } from "../../runtime.js";
+import { WizardSession } from "../../wizard/session.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateWizardCancelParams, validateWizardNextParams, validateWizardStartParams, validateWizardStatusParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const wizardHandlers = {
+    "wizard.start": async ({ params, respond, context }) => {
+        if (!validateWizardStartParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid wizard.start params: ${formatValidationErrors(validateWizardStartParams.errors)}`));
+            return;
+        }
+        const running = context.findRunningWizard();
+        if (running) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "wizard already running"));
+            return;
+        }
+        const sessionId = randomUUID();
+        const opts = {
+            mode: params.mode,
+            workspace: typeof params.workspace === "string" ? params.workspace : undefined,
+        };
+        const session = new WizardSession((prompter) => context.wizardRunner(opts, defaultRuntime, prompter));
+        context.wizardSessions.set(sessionId, session);
+        const result = await session.next();
+        if (result.done) {
+            context.purgeWizardSession(sessionId);
+        }
+        respond(true, { sessionId, ...result }, undefined);
+    },
+    "wizard.next": async ({ params, respond, context }) => {
+        if (!validateWizardNextParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid wizard.next params: ${formatValidationErrors(validateWizardNextParams.errors)}`));
+            return;
+        }
+        const sessionId = params.sessionId;
+        const session = context.wizardSessions.get(sessionId);
+        if (!session) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "wizard not found"));
+            return;
+        }
+        const answer = params.answer;
+        if (answer) {
+            if (session.getStatus() !== "running") {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "wizard not running"));
+                return;
+            }
+            try {
+                await session.answer(String(answer.stepId ?? ""), answer.value);
+            }
+            catch (err) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, formatForLog(err)));
+                return;
+            }
+        }
+        const result = await session.next();
+        if (result.done) {
+            context.purgeWizardSession(sessionId);
+        }
+        respond(true, result, undefined);
+    },
+    "wizard.cancel": ({ params, respond, context }) => {
+        if (!validateWizardCancelParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid wizard.cancel params: ${formatValidationErrors(validateWizardCancelParams.errors)}`));
+            return;
+        }
+        const sessionId = params.sessionId;
+        const session = context.wizardSessions.get(sessionId);
+        if (!session) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "wizard not found"));
+            return;
+        }
+        session.cancel();
+        const status = {
+            status: session.getStatus(),
+            error: session.getError(),
+        };
+        context.wizardSessions.delete(sessionId);
+        respond(true, status, undefined);
+    },
+    "wizard.status": ({ params, respond, context }) => {
+        if (!validateWizardStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid wizard.status params: ${formatValidationErrors(validateWizardStatusParams.errors)}`));
+            return;
+        }
+        const sessionId = params.sessionId;
+        const session = context.wizardSessions.get(sessionId);
+        if (!session) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "wizard not found"));
+            return;
+        }
+        const status = {
+            status: session.getStatus(),
+            error: session.getError(),
+        };
+        if (status.status !== "running") {
+            context.wizardSessions.delete(sessionId);
+        }
+        respond(true, status, undefined);
+    },
+};

package/dist/gateway/server-methods.js

@@ -0,0 +1,53 @@
+import { ErrorCodes, errorShape } from "./protocol/index.js";
+import { agentHandlers } from "./server-methods/agent.js";
+import { chatHandlers } from "./server-methods/chat.js";
+import { configHandlers } from "./server-methods/config.js";
+import { connectHandlers } from "./server-methods/connect.js";
+import { cronHandlers } from "./server-methods/cron.js";
+import { healthHandlers } from "./server-methods/health.js";
+import { modelsHandlers } from "./server-methods/models.js";
+import { nodeHandlers } from "./server-methods/nodes.js";
+import { providersHandlers } from "./server-methods/providers.js";
+import { sendHandlers } from "./server-methods/send.js";
+import { sessionsHandlers } from "./server-methods/sessions.js";
+import { skillsHandlers } from "./server-methods/skills.js";
+import { systemHandlers } from "./server-methods/system.js";
+import { talkHandlers } from "./server-methods/talk.js";
+import { voicewakeHandlers } from "./server-methods/voicewake.js";
+import { webHandlers } from "./server-methods/web.js";
+import { wizardHandlers } from "./server-methods/wizard.js";
+const handlers = {
+    ...connectHandlers,
+    ...voicewakeHandlers,
+    ...healthHandlers,
+    ...providersHandlers,
+    ...chatHandlers,
+    ...cronHandlers,
+    ...webHandlers,
+    ...modelsHandlers,
+    ...configHandlers,
+    ...wizardHandlers,
+    ...talkHandlers,
+    ...skillsHandlers,
+    ...sessionsHandlers,
+    ...systemHandlers,
+    ...nodeHandlers,
+    ...sendHandlers,
+    ...agentHandlers,
+};
+export async function handleGatewayRequest(opts) {
+    const { req, respond, client, isWebchatConnect, context } = opts;
+    const handler = handlers[req.method];
+    if (!handler) {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `unknown method: ${req.method}`));
+        return;
+    }
+    await handler({
+        req,
+        params: (req.params ?? {}),
+        client,
+        isWebchatConnect,
+        respond,
+        context,
+    });
+}