@nordbyte/nordrelay 0.7.0 → 0.8.1

package/dist/discord-bot.js

@@ -12,8 +12,10 @@ import { AuditLogStore } from "./audit-log.js";
 import { BotPreferencesStore } from "./bot-preferences.js";
 import { capabilitiesOf, filterActivityEvents, formatLocalDateTime, parseActivityOptions, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, trimLine } from "./bot-rendering.js";
 import { renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderQueueListAction } from "./channel-actions.js";
+import { createSharedChannelCommandDispatcher } from "./channel-command-core.js";
 import { ChannelCommandService } from "./channel-command-service.js";
 import { discordHelpCommandList } from "./channel-command-catalog.js";
+import { createChannelPromptEngine } from "./channel-prompt-engine.js";
 import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
 import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
@@ -595,157 +597,41 @@ export function createDiscordBridge(config, registry) {
         }
         const busyState = getBusyState(request.contextKey);
         busyState.processing = true;
-        const typing = setInterval(() => {
-            void runtime.sendTyping(request.context).catch(() => { });
-        }, TYPING_INTERVAL_MS);
-        void runtime.sendTyping(request.context).catch(() => { });
-        let accumulatedText = "";
-        let responseMessageId;
-        let planMessageId;
-        let flushTimer;
-        let lastEditAt = 0;
-        let running = true;
-        let finalized = false;
-        const toolCounts = new Map();
-        const toolVerbosity = config.toolVerbosity;
-        const startedAt = Date.now();
-        const turnId = randomUUID().slice(0, 12);
-        const progress = {
-            status: "running",
+        const engine = createChannelPromptEngine({
+            runtime,
+            context: request.context,
+            contextKey: request.contextKey,
             promptDescription: envelope.description,
-            startedAt,
-            updatedAt: startedAt,
-            toolCounts,
-            textCharacters: 0,
-        };
+            abortAction: `discord_abort:${request.contextKey}`,
+            trimMessage: trimDiscordMessage,
+            splitMessage: splitDiscordMessage,
+            editDebounceMs: EDIT_DEBOUNCE_MS,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            toolVerbosity: config.toolVerbosity,
+            logPrefix: "Discord",
+            onResponseMessage: (messageId) => responseOwners.set(messageId, request.contextKey),
+            onToolStart: (toolName) => appendActivity(request, {
+                status: "running",
+                type: "tool_started",
+                prompt: envelope.description,
+                detail: toolName,
+                threadId: session.getInfo().threadId,
+                workspace: session.getInfo().workspace,
+                agentId: session.getInfo().agentId,
+            }),
+            onToolEnd: (isError) => appendActivity(request, {
+                status: isError ? "failed" : "completed",
+                type: isError ? "tool_failed" : "tool_completed",
+                prompt: envelope.description,
+                detail: "tool",
+                threadId: session.getInfo().threadId,
+                workspace: session.getInfo().workspace,
+                agentId: session.getInfo().agentId,
+            }),
+        });
+        const progress = engine.progress;
         turnProgress.set(request.contextKey, progress);
-        const scheduleFlush = () => {
-            if (flushTimer || !running) {
-                return;
-            }
-            const delay = Math.max(0, EDIT_DEBOUNCE_MS - (Date.now() - lastEditAt));
-            flushTimer = setTimeout(() => {
-                flushTimer = undefined;
-                void flushResponse().catch((error) => console.error("Failed to edit Discord response:", error));
-            }, delay);
-        };
-        const ensureResponse = async () => {
-            if (responseMessageId)
-                return;
-            const preview = trimDiscordMessage(accumulatedText || "Working...");
-            const sent = await runtime.sendMessage(request.context, {
-                text: preview,
-                fallbackText: preview,
-                buttons: [[{ label: "Abort", action: `discord_abort:${request.contextKey}` }]],
-            });
-            responseMessageId = sent.messageId;
-            responseOwners.set(responseMessageId, request.contextKey);
-            lastEditAt = Date.now();
-        };
-        const flushResponse = async (force = false) => {
-            if (!accumulatedText.trim())
-                return;
-            await ensureResponse();
-            if (!responseMessageId)
-                return;
-            const now = Date.now();
-            if (!force && now - lastEditAt < EDIT_DEBOUNCE_MS)
-                return;
-            await runtime.editMessage(request.context, responseMessageId, {
-                text: trimDiscordMessage(accumulatedText),
-                fallbackText: trimDiscordMessage(accumulatedText),
-                buttons: [[{ label: "Abort", action: `discord_abort:${request.contextKey}` }]],
-            });
-            lastEditAt = Date.now();
-        };
-        const finalize = async () => {
-            if (finalized) {
-                return;
-            }
-            finalized = true;
-            running = false;
-            clearInterval(typing);
-            if (flushTimer) {
-                clearTimeout(flushTimer);
-                flushTimer = undefined;
-            }
-            const finalText = accumulatedText.trim() || "Done.";
-            const chunks = splitDiscordMessage(finalText);
-            if (responseMessageId) {
-                const [first, ...rest] = chunks;
-                await runtime.editMessage(request.context, responseMessageId, { text: first ?? "Done.", fallbackText: first ?? "Done." });
-                for (const chunk of rest) {
-                    await runtime.sendMessage(request.context, { text: chunk, fallbackText: chunk });
-                }
-            }
-            else {
-                for (const chunk of chunks) {
-                    await runtime.sendMessage(request.context, { text: chunk, fallbackText: chunk });
-                }
-            }
-        };
-        const callbacks = {
-            onTextDelta: (delta) => {
-                accumulatedText += delta;
-                progress.textCharacters = accumulatedText.length;
-                progress.updatedAt = Date.now();
-                void ensureResponse().then(() => scheduleFlush()).catch((error) => console.error("Failed to send Discord response:", error));
-            },
-            onToolStart: (toolName) => {
-                toolCounts.set(toolName, (toolCounts.get(toolName) ?? 0) + 1);
-                progress.currentTool = toolName;
-                progress.lastTool = toolName;
-                progress.updatedAt = Date.now();
-                appendActivity(request, {
-                    status: "running",
-                    type: "tool_started",
-                    prompt: envelope.description,
-                    detail: toolName,
-                    threadId: session.getInfo().threadId,
-                    workspace: session.getInfo().workspace,
-                    agentId: session.getInfo().agentId,
-                });
-                if (toolVerbosity === "all") {
-                    void runtime.sendMessage(request.context, { text: `Tool started: ${toolName}`, fallbackText: `Tool started: ${toolName}` }).catch(() => { });
-                }
-            },
-            onToolUpdate: () => { },
-            onToolEnd: (_toolCallId, isError) => {
-                progress.currentTool = undefined;
-                progress.updatedAt = Date.now();
-                appendActivity(request, {
-                    status: isError ? "failed" : "completed",
-                    type: isError ? "tool_failed" : "tool_completed",
-                    prompt: envelope.description,
-                    detail: "tool",
-                    threadId: session.getInfo().threadId,
-                    workspace: session.getInfo().workspace,
-                    agentId: session.getInfo().agentId,
-                });
-            },
-            onTodoUpdate: (items) => {
-                progress.updatedAt = Date.now();
-                const text = [
-                    "Plan:",
-                    ...items.map((item) => `${item.completed ? "[x]" : "[ ]"} ${item.text}`),
-                ].join("\n");
-                if (!planMessageId) {
-                    void runtime.sendMessage(request.context, { text, fallbackText: text }).then((result) => {
-                        planMessageId = result.messageId;
-                    }).catch(() => { });
-                }
-                else {
-                    void runtime.editMessage(request.context, planMessageId, { text, fallbackText: text }).catch(() => { });
-                }
-            },
-            onTurnComplete: () => { },
-            onAgentEnd: () => {
-                progress.status = "completed";
-                progress.completedAt = Date.now();
-                progress.updatedAt = progress.completedAt;
-                void finalize().catch((error) => console.error("Failed to finalize Discord response:", error));
-            },
-        };
+        engine.start();
         try {
             const info = session.getInfo();
             if ((info.capabilities ?? capabilitiesOf(info)).auth) {
@@ -777,15 +663,15 @@ export function createDiscordBridge(config, registry) {
                 workspace: currentInfo.workspace,
                 description: envelope.description,
             });
-            await session.prompt(envelope.input, callbacks);
+            await session.prompt(envelope.input, engine.callbacks);
             updateSession(request, session);
             progress.status = "completed";
             progress.completedAt = Date.now();
             progress.updatedAt = progress.completedAt;
-            await finalize();
-            await artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, new Date(startedAt));
+            await engine.finalize();
+            await artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, engine.turnId, new Date(engine.startedAt));
             if (config.discordAutoSendArtifacts) {
-                await sendRecentDiscordArtifacts(artifactDeps, request, session, new Date(startedAt), turnId);
+                await sendRecentDiscordArtifacts(artifactDeps, request, session, new Date(engine.startedAt), engine.turnId);
             }
             appendActivity(request, {
                 status: "completed",
@@ -794,7 +680,7 @@ export function createDiscordBridge(config, registry) {
                 threadId: session.getInfo().threadId,
                 workspace: session.getInfo().workspace,
                 agentId: session.getInfo().agentId,
-                durationMs: Date.now() - startedAt,
+                durationMs: Date.now() - engine.startedAt,
             });
             audit(request, {
                 action: "prompt_completed",
@@ -810,13 +696,8 @@ export function createDiscordBridge(config, registry) {
             progress.completedAt = Date.now();
             progress.updatedAt = progress.completedAt;
             progress.error = friendlyErrorText(error);
-            const errorText = renderPromptFailure(accumulatedText, error);
-            if (responseMessageId) {
-                await runtime.editMessage(request.context, responseMessageId, { text: trimDiscordMessage(errorText), fallbackText: trimDiscordMessage(errorText) }).catch(() => { });
-            }
-            else {
-                await reply(request, errorText).catch(() => { });
-            }
+            const errorText = renderPromptFailure(engine.accumulatedText(), error);
+            await engine.fail(errorText);
             appendActivity(request, {
                 status: "failed",
                 type: "prompt_failed",
@@ -825,7 +706,7 @@ export function createDiscordBridge(config, registry) {
                 threadId: session.getInfo().threadId,
                 workspace: session.getInfo().workspace,
                 agentId: session.getInfo().agentId,
-                durationMs: Date.now() - startedAt,
+                durationMs: Date.now() - engine.startedAt,
             });
             audit(request, {
                 action: "prompt_failed",
@@ -838,8 +719,7 @@ export function createDiscordBridge(config, registry) {
             });
         }
         finally {
-            running = false;
-            clearInterval(typing);
+            engine.stop();
             busyState.processing = false;
             await drainQueue(request).catch((error) => console.error("Failed to drain Discord queue:", error));
         }
@@ -916,6 +796,58 @@ export function createDiscordBridge(config, registry) {
         if (state)
             state.artifactsDeliveredForTurnId = turnId;
     };
+    const commandDispatcher = createSharedChannelCommandDispatcher({
+        transport: "discord",
+        bindings: [
+            { names: ["start", "help"], handler: (request) => commandHelp(request) },
+            { names: ["channels"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderChannels()).then(() => { }) },
+            { names: ["peers"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderPeers()).then(() => { }) },
+            { names: ["target"], handler: (request, argument) => deliverChannelAction(runtime, request.context, commandService.renderTargetPreference({ source: "discord", contextKey: request.contextKey, argument, preferencesStore })).then(() => { }) },
+            { names: ["agents"], handler: (request) => deliverChannelAction(runtime, request.context, commandService.renderAgents()).then(() => { }) },
+            { names: ["agent"], handler: (request, argument) => commandAgent(request, argument) },
+            { names: ["auth"], handler: (request) => commandAuth(request) },
+            { names: ["login"], handler: (request) => commandLogin(request) },
+            { names: ["logout"], handler: (request) => commandLogout(request) },
+            { names: ["session"], handler: (request) => commandSession(request) },
+            { names: ["sessions"], handler: (request, argument) => commandSessions(request, argument) },
+            { names: ["new"], handler: (request, argument) => commandNew(request, argument) },
+            { names: ["switch", "attach"], handler: (request, argument) => commandSwitch(request, argument) },
+            { names: ["model"], handler: (request, argument) => commandModel(request, argument) },
+            { names: ["reasoning", "effort"], handler: (request, argument) => commandReasoning(request, argument) },
+            { names: ["fast"], handler: (request, argument) => commandFast(request, argument) },
+            { names: ["launch", "launch_profiles", "launch-profiles"], handler: (request, argument) => commandLaunch(request, argument) },
+            { names: ["queue"], handler: (request, argument) => commandQueue(request, argument) },
+            { names: ["clearqueue"], handler: (request) => { promptStore.clear(request.contextKey); return reply(request, "Queue cleared."); } },
+            { names: ["cancel"], handler: (request, argument) => commandQueue(request, `cancel ${argument}`) },
+            { names: ["abort", "stop"], handler: (request) => commandAbort(request) },
+            { names: ["retry"], handler: (request) => commandRetry(request) },
+            { names: ["sync"], handler: (request) => commandSync(request) },
+            { names: ["tasks", "progress"], handler: (request) => commandProgress(request) },
+            { names: ["activity"], handler: (request, argument) => commandActivity(request, argument) },
+            { names: ["audit"], handler: (request, argument) => commandAudit(request, argument) },
+            { names: ["artifacts"], handler: (request, argument) => commandArtifacts(request, argument) },
+            { names: ["logs"], handler: (request, argument) => commandLogs(request, argument) },
+            { names: ["version", "health", "status"], handler: (request) => commandVersion(request) },
+            { names: ["diagnostics", "support"], handler: (request) => commandDiagnostics(request) },
+            { names: ["restart"], handler: (request) => commandRestart(request) },
+            { names: ["update"], handler: (request, argument) => commandUpdate(request, argument) },
+            { names: ["lock"], handler: (request) => commandLock(request) },
+            { names: ["unlock"], handler: (request) => { lockStore.clear(request.contextKey); return reply(request, "Session unlocked."); } },
+            { names: ["locks"], handler: (request) => reply(request, lockStore.list().map((lock) => `${lock.contextKey}: ${lock.ownerLabel || lock.ownerUserId}`).join("\n") || "No active locks.") },
+            { names: ["mirror"], handler: (request, argument) => commandMirror(request, argument) },
+            { names: ["notify"], handler: (request, argument) => commandNotify(request, argument) },
+            { names: ["voice"], handler: (request, argument) => commandVoice(request, argument) },
+            { names: ["workspaces"], handler: (request) => commandWorkspaces(request) },
+            { names: ["pin"], handler: (request, argument) => commandPin(request, argument) },
+            { names: ["unpin"], handler: (request, argument) => commandUnpin(request, argument) },
+            { names: ["pinned"], handler: (request) => commandPinned(request) },
+            { names: ["handback"], handler: (request) => commandHandback(request) },
+            { names: ["register_channel"], handler: (request) => commandRegisterChannel(request) },
+            { names: ["link"], handler: (request, argument) => commandLink(request, argument) },
+            { names: ["whoami"], handler: (request) => reply(request, request.authUser ? `${request.authUser.user.displayName} <${request.authUser.user.email}>\nGroups: ${request.authUser.groups.map((group) => group.name).join(", ")}` : "Not linked.") },
+            { names: ["prompt"], handler: (request, argument) => handlePrompt(request, argument) },
+        ],
+    });
     const handleCommand = async (request, command, argument) => {
         const normalized = command.toLowerCase();
         const permission = requiredPermissionForDiscordCommand(normalized, argument);
@@ -923,169 +855,9 @@ export function createDiscordBridge(config, registry) {
             return;
         }
         audit(request, { action: "command", status: "ok", description: `/${normalized} ${argument}`.trim() });
-        switch (normalized) {
-            case "start":
-            case "help":
-                await commandHelp(request);
-                return;
-            case "channels":
-                await deliverChannelAction(runtime, request.context, commandService.renderChannels());
-                return;
-            case "peers":
-                await deliverChannelAction(runtime, request.context, commandService.renderPeers());
-                return;
-            case "target":
-                await deliverChannelAction(runtime, request.context, commandService.renderTargetPreference({
-                    source: "discord",
-                    contextKey: request.contextKey,
-                    argument,
-                    preferencesStore,
-                }));
-                return;
-            case "agents":
-                await deliverChannelAction(runtime, request.context, commandService.renderAgents());
-                return;
-            case "agent":
-                await commandAgent(request, argument);
-                return;
-            case "auth":
-                await commandAuth(request);
-                return;
-            case "login":
-                await commandLogin(request);
-                return;
-            case "logout":
-                await commandLogout(request);
-                return;
-            case "session":
-                await commandSession(request);
-                return;
-            case "sessions":
-                await commandSessions(request, argument);
-                return;
-            case "new":
-                await commandNew(request, argument);
-                return;
-            case "switch":
-            case "attach":
-                await commandSwitch(request, argument);
-                return;
-            case "model":
-                await commandModel(request, argument);
-                return;
-            case "reasoning":
-            case "effort":
-                await commandReasoning(request, argument);
-                return;
-            case "fast":
-                await commandFast(request, argument);
-                return;
-            case "launch":
-            case "launch_profiles":
-            case "launch-profiles":
-                await commandLaunch(request, argument);
-                return;
-            case "queue":
-                await commandQueue(request, argument);
-                return;
-            case "clearqueue":
-                promptStore.clear(request.contextKey);
-                await reply(request, "Queue cleared.");
-                return;
-            case "cancel":
-                await commandQueue(request, `cancel ${argument}`);
-                return;
-            case "abort":
-            case "stop":
-                await commandAbort(request);
-                return;
-            case "retry":
-                await commandRetry(request);
-                return;
-            case "sync":
-                await commandSync(request);
-                return;
-            case "tasks":
-            case "progress":
-                await commandProgress(request);
-                return;
-            case "activity":
-                await commandActivity(request, argument);
-                return;
-            case "audit":
-                await commandAudit(request, argument);
-                return;
-            case "artifacts":
-                await commandArtifacts(request, argument);
-                return;
-            case "logs":
-                await commandLogs(request, argument);
-                return;
-            case "version":
-            case "health":
-            case "status":
-                await commandVersion(request);
-                return;
-            case "diagnostics":
-                await commandDiagnostics(request);
-                return;
-            case "support":
-                await commandDiagnostics(request);
-                return;
-            case "restart":
-                await commandRestart(request);
-                return;
-            case "update":
-                await commandUpdate(request, argument);
-                return;
-            case "lock":
-                await commandLock(request);
-                return;
-            case "unlock":
-                lockStore.clear(request.contextKey);
-                await reply(request, "Session unlocked.");
-                return;
-            case "locks":
-                await reply(request, lockStore.list().map((lock) => `${lock.contextKey}: ${lock.ownerLabel || lock.ownerUserId}`).join("\n") || "No active locks.");
-                return;
-            case "mirror":
-                await commandMirror(request, argument);
-                return;
-            case "notify":
-                await commandNotify(request, argument);
-                return;
-            case "voice":
-                await commandVoice(request, argument);
-                return;
-            case "workspaces":
-                await commandWorkspaces(request);
-                return;
-            case "pin":
-                await commandPin(request, argument);
-                return;
-            case "unpin":
-                await commandUnpin(request, argument);
-                return;
-            case "pinned":
-                await commandPinned(request);
-                return;
-            case "handback":
-                await commandHandback(request);
-                return;
-            case "register_channel":
-                await commandRegisterChannel(request);
-                return;
-            case "link":
-                await commandLink(request, argument);
-                return;
-            case "whoami":
-                await reply(request, request.authUser ? `${request.authUser.user.displayName} <${request.authUser.user.email}>\nGroups: ${request.authUser.groups.map((group) => group.name).join(", ")}` : "Not linked.");
-                return;
-            case "prompt":
-                await handlePrompt(request, argument);
-                return;
-            default:
-                await reply(request, `Unknown command: /${normalized}`);
+        const result = await commandDispatcher.dispatch(request, normalized, argument);
+        if (!result.matched) {
+            await reply(request, `Unknown command: /${normalized}`);
         }
     };
     const commandHelp = async (request) => {

package/dist/index.js

@@ -5,6 +5,7 @@ import { webhookCallback } from "grammy";
 import { agentLabel } from "./agent.js";
 import { createBot, registerCommands } from "./bot.js";
 import { createDiscordBridge } from "./discord-bot.js";
+import { createSlackBridge } from "./slack-bot.js";
 import { checkAuthStatus } from "./codex-auth.js";
 import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
 import { checkClaudeCodeAuthStatus } from "./claude-code-auth.js";
@@ -27,6 +28,7 @@ import { UserStore } from "./user-management.js";
 let registry;
 let bot;
 let discordBridge;
+let slackBridge;
 let webhookServer;
 let peerServer;
 let peerRuntime;
@@ -43,6 +45,8 @@ try {
     }
     discordBridge = createDiscordBridge(config, registry);
     await discordBridge?.start();
+    slackBridge = createSlackBridge(config, registry);
+    await slackBridge?.start();
     if (config.peerEnabled) {
         peerRuntime = new RelayRuntime(config);
         peerServer = await startPeerServer({ config, runtime: peerRuntime });
@@ -94,6 +98,7 @@ try {
     console.log("Session mode: per chat context");
     console.log(`Telegram: ${config.telegramEnabled ? config.telegramTransport : "disabled"}`);
     console.log(`Discord: ${config.discordEnabled ? "enabled" : "disabled"}`);
+    console.log(`Slack: ${config.slackEnabled ? (config.slackSocketMode ? "socket-mode" : `http:${config.slackPort}`) : "disabled"}`);
     console.log(`Peers: ${peerServer ? peerServer.url : "disabled"}`);
     await writeConnectorState({
         status: "ready",
@@ -111,6 +116,7 @@ try {
         openClawGateway: config.openClawGatewayUrl,
         telegramTransport: config.telegramTransport,
         discordEnabled: config.discordEnabled,
+        slackEnabled: config.slackEnabled,
         peerEnabled: config.peerEnabled,
         peerUrl: peerServer?.url,
         peerTlsFingerprint: peerServer?.tlsFingerprint,
@@ -164,6 +170,9 @@ const shutdown = (signal) => {
     void discordBridge?.stop().catch((error) => {
         console.warn("Failed to stop Discord bridge:", error instanceof Error ? error.message : String(error));
     });
+    void slackBridge?.stop().catch((error) => {
+        console.warn("Failed to stop Slack bridge:", error instanceof Error ? error.message : String(error));
+    });
     webhookServer?.close();
     void peerServer?.close().catch((error) => {
         console.warn("Failed to stop peer server:", error instanceof Error ? error.message : String(error));

package/dist/metrics.js

@@ -1,5 +1,6 @@
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { getDiscordRateLimitMetrics } from "./discord-rate-limit.js";
+import { getSlackRateLimitMetrics } from "./slack-rate-limit.js";
 import { getTelegramRateLimitMetrics } from "./telegram-rate-limit.js";
 const startedAt = Date.now();
 const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
@@ -35,6 +36,7 @@ export function buildRuntimeMetrics(input) {
         adapters: {
             telegram: getTelegramRateLimitMetrics(),
             discord: getDiscordRateLimitMetrics(),
+            slack: getSlackRateLimitMetrics(),
         },
     };
 }