@nordbyte/nordrelay 0.7.0 → 0.8.0

package/dist/bot.js

@@ -14,6 +14,7 @@ import { renderAgentUpdateJobAction } from "./channel-actions.js";
 import { ChannelCommandService } from "./channel-command-service.js";
 import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
+import { createChannelTurnLifecycle, createChannelTypingLoop } from "./channel-turn-lifecycle.js";
 import { agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
 import { getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
 import { checkAuthStatus, clearAuthCache, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
@@ -1118,14 +1119,8 @@ export function createBot(config, registry) {
         }
         const busyState = getBusyState(contextKey);
         busyState.processing = true;
-        const progress = {
-            status: "running",
-            promptDescription: envelope.description,
-            startedAt: Date.now(),
-            updatedAt: Date.now(),
-            toolCounts: new Map(),
-            textCharacters: 0,
-        };
+        const turnLifecycle = createChannelTurnLifecycle(envelope.description);
+        const progress = turnLifecycle.progress;
         turnProgress.set(contextKey, progress);
         const abortKeyboard = new InlineKeyboard().text("⏹ Abort", `agent_abort:${contextKey}`);
         const toolVerbosity = config.toolVerbosity;
@@ -1147,12 +1142,13 @@ export function createBot(config, registry) {
         let promptStartedAt;
         const toolActivityNames = new Map();
         const toolActivityStartedAt = new Map();
-        const typingInterval = setInterval(() => {
-            void sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
-        }, TYPING_INTERVAL_MS);
-        void sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
+        const typingLoop = createChannelTypingLoop({
+            intervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => sendChatActionSafe(bot.api, chatId, "typing", messageThreadId),
+        });
+        typingLoop.start();
         const stopTyping = () => {
-            clearInterval(typingInterval);
+            typingLoop.stop();
         };
         const clearFlushTimer = () => {
             if (flushTimer) {
@@ -1303,6 +1299,7 @@ export function createBot(config, registry) {
                 return;
             }
             finalized = true;
+            turnLifecycle.recordCompleted();
             stopTyping();
             clearFlushTimer();
             if (responseMessagePromise) {
@@ -1331,8 +1328,7 @@ export function createBot(config, registry) {
         const callbacks = {
             onTextDelta: (delta) => {
                 accumulatedText += delta;
-                progress.textCharacters += delta.length;
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordTextDelta(delta.length);
                 if (!responseMessageId) {
                     void ensureResponseMessage()
                         .then(() => {
@@ -1346,10 +1342,7 @@ export function createBot(config, registry) {
                 scheduleFlush();
             },
             onToolStart: (toolName, toolCallId) => {
-                progress.currentTool = toolName;
-                progress.lastTool = toolName;
-                progress.updatedAt = Date.now();
-                progress.toolCounts.set(toolName, (progress.toolCounts.get(toolName) ?? 0) + 1);
+                turnLifecycle.recordToolStart(toolName);
                 toolActivityNames.set(toolCallId, toolName);
                 toolActivityStartedAt.set(toolCallId, Date.now());
                 appendTelegramActivity(ctx, contextKey, session, {
@@ -1393,7 +1386,7 @@ export function createBot(config, registry) {
                 });
             },
             onToolUpdate: (toolCallId, partialResult) => {
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordToolUpdate();
                 if (toolVerbosity === "none" || toolVerbosity === "summary") {
                     return;
                 }
@@ -1404,8 +1397,7 @@ export function createBot(config, registry) {
                 state.partialResult = appendWithCap(state.partialResult, partialResult, TOOL_OUTPUT_PREVIEW_LIMIT);
             },
             onToolEnd: (toolCallId, isError) => {
-                progress.currentTool = undefined;
-                progress.updatedAt = Date.now();
+                turnLifecycle.recordToolEnd();
                 const activityToolName = toolActivityNames.get(toolCallId) ?? "tool";
                 const activityStartedAt = toolActivityStartedAt.get(toolCallId);
                 appendTelegramActivity(ctx, contextKey, session, {
@@ -1450,7 +1442,7 @@ export function createBot(config, registry) {
                 });
             },
             onTodoUpdate: (items) => {
-                progress.updatedAt = Date.now();
+                turnLifecycle.touch();
                 if (toolVerbosity === "none") {
                     return;
                 }
@@ -1482,7 +1474,7 @@ export function createBot(config, registry) {
             },
             onTurnComplete: (usage) => {
                 lastTurnUsage = usage;
-                progress.updatedAt = Date.now();
+                turnLifecycle.touch();
             },
             onAgentEnd: () => {
                 void finalizeResponse().catch((error) => {
@@ -1597,9 +1589,7 @@ export function createBot(config, registry) {
                     await pruneArtifacts(session.getInfo().workspace);
                 }
             }
-            progress.status = "completed";
-            progress.completedAt = Date.now();
-            progress.updatedAt = progress.completedAt;
+            turnLifecycle.recordCompleted();
             auditContext(ctx, contextKey, session, {
                 action: "prompt_completed",
                 status: "ok",
@@ -1614,8 +1604,7 @@ export function createBot(config, registry) {
             });
         }
         catch (error) {
-            progress.status = "failed";
-            progress.error = friendlyErrorText(error);
+            turnLifecycle.recordFailed(friendlyErrorText(error));
             auditContext(ctx, contextKey, session, {
                 action: "prompt_failed",
                 status: "failed",
@@ -1632,8 +1621,6 @@ export function createBot(config, registry) {
                     durationMs: Date.now() - promptStartedAt,
                 });
             }
-            progress.completedAt = Date.now();
-            progress.updatedAt = progress.completedAt;
             stopTyping();
             clearFlushTimer();
             if (responseMessagePromise) {

package/dist/channel-adapter.js

@@ -19,6 +19,17 @@ const DISCORD_CAPABILITIES = [
     "voice",
     "topics",
 ];
+const SLACK_CAPABILITIES = [
+    "text",
+    "streaming-edits",
+    "typing",
+    "inline-buttons",
+    "files",
+    "photos",
+    "voice",
+    "topics",
+    "webhooks",
+];
 const PLANNED_CHANNELS = [
     {
         id: "whatsapp",
@@ -27,12 +38,6 @@ const PLANNED_CHANNELS = [
         status: "planned",
         notes: "Requires a WhatsApp Business provider integration.",
     },
-    {
-        id: "slack",
-        label: "Slack",
-        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files"],
-        status: "planned",
-    },
     {
         id: "matrix",
         label: "Matrix",
@@ -82,10 +87,32 @@ export class DiscordChannelAdapter {
         };
     }
 }
+export class SlackChannelAdapter {
+    id = "slack";
+    label = "Slack";
+    capabilities = new Set(SLACK_CAPABILITIES);
+    describe() {
+        const requested = process.env.SLACK_ENABLED === "true";
+        const enabled = requested && Boolean(process.env.SLACK_BOT_TOKEN) && Boolean(process.env.SLACK_APP_TOKEN);
+        return {
+            id: this.id,
+            label: this.label,
+            capabilities: [...this.capabilities],
+            status: "available",
+            enabled,
+            notes: enabled
+                ? "Slack bot runtime is enabled."
+                : requested
+                    ? "Slack bot runtime is disabled because SLACK_BOT_TOKEN or SLACK_APP_TOKEN is missing."
+                    : "Enable with SLACK_ENABLED=true, SLACK_BOT_TOKEN, and SLACK_APP_TOKEN.",
+        };
+    }
+}
 export function listChannelDescriptors() {
     return [
         new TelegramChannelAdapter().describe(),
         new DiscordChannelAdapter().describe(),
+        new SlackChannelAdapter().describe(),
         ...PLANNED_CHANNELS,
     ];
 }

package/dist/channel-command-catalog.js

@@ -86,3 +86,9 @@ export function discordHelpCommandList() {
         .map((entry) => `/${entry.name}`)
         .join(", ");
 }
+export function slackHelpCommandList() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.slack !== false && !["start", "help", "prompt"].includes(entry.name))
+        .map((entry) => `/${entry.name}`)
+        .join(", ");
+}

package/dist/channel-command-core.js

@@ -0,0 +1,60 @@
+import { CHANNEL_COMMANDS } from "./channel-command-catalog.js";
+import { normalizeChannelCommandName } from "./channel-runtime.js";
+export function createSharedChannelCommandDispatcher(input) {
+    const handlers = new Map();
+    for (const binding of input.bindings) {
+        for (const name of binding.names) {
+            const normalized = normalizeChannelCommandName(name);
+            if (!normalized) {
+                throw new Error("Channel command name is required.");
+            }
+            if (handlers.has(normalized)) {
+                throw new Error(`Duplicate ${input.transport} command binding: ${normalized}`);
+            }
+            handlers.set(normalized, binding.handler);
+        }
+    }
+    return {
+        transport: input.transport,
+        commandNames: [...handlers.keys()].sort(),
+        async dispatch(request, command, argument) {
+            const normalized = normalizeChannelCommandName(command);
+            const handler = handlers.get(normalized);
+            if (!handler) {
+                return { matched: false, command: normalized };
+            }
+            await handler(request, argument, normalized);
+            return { matched: true, command: normalized };
+        },
+    };
+}
+export function channelCatalogCommandNames(transport) {
+    return CHANNEL_COMMANDS
+        .filter((entry) => {
+        if (transport === "telegram")
+            return entry.telegram !== false;
+        if (transport === "discord")
+            return entry.discord !== false;
+        return entry.slack !== false;
+    })
+        .map((entry) => normalizeChannelCommandName(entry.name))
+        .sort();
+}
+export function channelCommandCoverage(input) {
+    const advertised = new Set(channelCatalogCommandNames(input.transport));
+    const implemented = new Set([...input.implemented].map(normalizeChannelCommandName));
+    for (const [canonical, aliases] of Object.entries(input.aliases ?? {})) {
+        if (!implemented.has(normalizeChannelCommandName(canonical)))
+            continue;
+        for (const alias of aliases) {
+            implemented.add(normalizeChannelCommandName(alias));
+        }
+    }
+    const aliasNames = new Set(Object.values(input.aliases ?? {}).flat().map(normalizeChannelCommandName));
+    return {
+        advertised: [...advertised].sort(),
+        implemented: [...implemented].sort(),
+        missing: [...advertised].filter((name) => !implemented.has(name)).sort(),
+        extra: [...implemented].filter((name) => !advertised.has(name) && !aliasNames.has(name)).sort(),
+    };
+}

package/dist/channel-command-service.js

@@ -176,7 +176,11 @@ export class ChannelCommandService {
             });
         }
         const mode = this.effectiveMirrorMode(options.source, options.contextKey, options.preferencesStore);
-        const minInterval = options.source === "telegram" ? this.config.telegramMirrorMinUpdateMs : this.config.discordMirrorMinUpdateMs;
+        const minInterval = options.source === "telegram"
+            ? this.config.telegramMirrorMinUpdateMs
+            : options.source === "discord"
+                ? this.config.discordMirrorMinUpdateMs
+                : this.config.slackMirrorMinUpdateMs;
         return {
             plain: [
                 `CLI mirroring: ${mode}`,
@@ -334,13 +338,25 @@ export class ChannelCommandService {
         };
     }
     defaultMirrorMode(source) {
-        return source === "telegram" ? this.config.telegramMirrorMode : this.config.discordMirrorMode;
+        return source === "telegram"
+            ? this.config.telegramMirrorMode
+            : source === "discord"
+                ? this.config.discordMirrorMode
+                : this.config.slackMirrorMode;
     }
     defaultNotifyMode(source) {
-        return source === "telegram" ? this.config.telegramNotifyMode : this.config.discordNotifyMode;
+        return source === "telegram"
+            ? this.config.telegramNotifyMode
+            : source === "discord"
+                ? this.config.discordNotifyMode
+                : this.config.slackNotifyMode;
     }
     defaultQuietHours(source) {
-        return source === "telegram" ? this.config.telegramQuietHours : this.config.discordQuietHours;
+        return source === "telegram"
+            ? this.config.telegramQuietHours
+            : source === "discord"
+                ? this.config.discordQuietHours
+                : this.config.slackQuietHours;
     }
     effectiveMirrorMode(source, contextKey, preferencesStore) {
         return preferencesStore.get(contextKey).mirrorMode ?? this.defaultMirrorMode(source);

package/dist/channel-mirror-registry.js

@@ -49,7 +49,11 @@ export class ChannelMirrorRegistry {
         return mirrors.some((mirror) => mirror.queuePaused) || this.promptStore.isPaused(sourceContextKey);
     }
     effectiveMirrorMode(contextKey, source, preferences) {
-        const configured = source === "telegram" ? this.config.telegramMirrorMode : this.config.discordMirrorMode;
+        const configured = source === "telegram"
+            ? this.config.telegramMirrorMode
+            : source === "discord"
+                ? this.config.discordMirrorMode
+                : this.config.slackMirrorMode;
         return preferences.get(contextKey).mirrorMode ?? configured;
     }
     snapshot() {
@@ -67,11 +71,14 @@ export function activeSessionSourceForContextKey(contextKey) {
     if (channelId === "discord") {
         return "discord";
     }
+    if (channelId === "slack") {
+        return "slack";
+    }
     if (channelId === "web") {
         return "web";
     }
     return "cli";
 }
 export function isMirrorChannelSource(source) {
-    return source === "telegram" || source === "discord";
+    return source === "telegram" || source === "discord" || source === "slack";
 }

package/dist/channel-prompt-engine.js

@@ -0,0 +1,177 @@
+import { createChannelTurnLifecycle, createChannelTypingLoop } from "./channel-turn-lifecycle.js";
+export function createChannelPromptEngine(options) {
+    const lifecycle = createChannelTurnLifecycle(options.promptDescription);
+    const { progress, startedAt, turnId } = lifecycle;
+    let accumulated = "";
+    let responseMessageId;
+    let planMessageId;
+    let flushTimer;
+    const typingLoop = createChannelTypingLoop({
+        intervalMs: options.typingIntervalMs,
+        sendTyping: () => options.runtime.sendTyping(options.context),
+    });
+    let lastEditAt = 0;
+    let running = false;
+    let finalized = false;
+    const buttons = options.abortAction
+        ? [[{ label: "Abort", action: options.abortAction }]]
+        : undefined;
+    const clearFlushTimer = () => {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = undefined;
+        }
+    };
+    const ensureResponse = async () => {
+        if (responseMessageId) {
+            return;
+        }
+        const preview = options.trimMessage(accumulated || "Working...");
+        const sent = await options.runtime.sendMessage(options.context, {
+            text: preview,
+            fallbackText: preview,
+            buttons,
+        });
+        responseMessageId = sent.messageId;
+        options.onResponseMessage?.(responseMessageId);
+        lastEditAt = Date.now();
+    };
+    const flushResponse = async (force = false) => {
+        if (!accumulated.trim()) {
+            return;
+        }
+        await ensureResponse();
+        if (!responseMessageId) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - lastEditAt < options.editDebounceMs) {
+            return;
+        }
+        const rendered = options.trimMessage(accumulated);
+        await options.runtime.editMessage(options.context, responseMessageId, {
+            text: rendered,
+            fallbackText: rendered,
+            buttons,
+        });
+        lastEditAt = Date.now();
+    };
+    const scheduleFlush = () => {
+        if (flushTimer || !running) {
+            return;
+        }
+        const delay = Math.max(0, options.editDebounceMs - (Date.now() - lastEditAt));
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            void flushResponse().catch((error) => console.error(`Failed to edit ${options.logPrefix} response:`, error));
+        }, delay);
+        flushTimer.unref?.();
+    };
+    const stop = () => {
+        running = false;
+        typingLoop.stop();
+        clearFlushTimer();
+    };
+    const finalize = async () => {
+        if (finalized) {
+            return;
+        }
+        finalized = true;
+        lifecycle.recordCompleted();
+        stop();
+        const finalText = accumulated.trim() || "Done.";
+        const chunks = options.splitMessage(finalText);
+        if (responseMessageId) {
+            const [first, ...rest] = chunks;
+            await options.runtime.editMessage(options.context, responseMessageId, {
+                text: first ?? "Done.",
+                fallbackText: first ?? "Done.",
+            });
+            for (const chunk of rest) {
+                await options.runtime.sendMessage(options.context, { text: chunk, fallbackText: chunk });
+            }
+            return;
+        }
+        for (const chunk of chunks) {
+            await options.runtime.sendMessage(options.context, { text: chunk, fallbackText: chunk });
+        }
+    };
+    const fail = async (text) => {
+        finalized = true;
+        lifecycle.recordFailed(text);
+        stop();
+        const rendered = options.trimMessage(text);
+        if (responseMessageId) {
+            await options.runtime.editMessage(options.context, responseMessageId, {
+                text: rendered,
+                fallbackText: rendered,
+            }).catch(() => { });
+            return;
+        }
+        await options.runtime.sendMessage(options.context, {
+            text: rendered,
+            fallbackText: rendered,
+        }).catch(() => { });
+    };
+    const callbacks = {
+        onTextDelta: (delta) => {
+            accumulated += delta;
+            lifecycle.recordTextDelta(delta.length);
+            void ensureResponse()
+                .then(() => scheduleFlush())
+                .catch((error) => console.error(`Failed to send ${options.logPrefix} response:`, error));
+        },
+        onToolStart: (toolName) => {
+            lifecycle.recordToolStart(toolName);
+            options.onToolStart?.(toolName);
+            if (options.toolVerbosity === "all") {
+                const text = `Tool started: ${toolName}`;
+                void options.runtime.sendMessage(options.context, { text, fallbackText: text }).catch(() => { });
+            }
+        },
+        onToolUpdate: () => {
+            lifecycle.recordToolUpdate();
+        },
+        onToolEnd: (_toolCallId, isError) => {
+            lifecycle.recordToolEnd();
+            options.onToolEnd?.(isError);
+        },
+        onTodoUpdate: (items) => {
+            lifecycle.touch();
+            const text = [
+                "Plan:",
+                ...items.map((item) => `${item.completed ? "[x]" : "[ ]"} ${item.text}`),
+            ].join("\n");
+            if (!planMessageId) {
+                void options.runtime.sendMessage(options.context, { text, fallbackText: text }).then((result) => {
+                    planMessageId = result.messageId;
+                }).catch(() => { });
+            }
+            else {
+                void options.runtime.editMessage(options.context, planMessageId, { text, fallbackText: text }).catch(() => { });
+            }
+        },
+        onTurnComplete: () => { },
+        onAgentEnd: () => {
+            lifecycle.recordCompleted();
+            void finalize().catch((error) => console.error(`Failed to finalize ${options.logPrefix} response:`, error));
+        },
+    };
+    return {
+        turnId,
+        startedAt,
+        progress,
+        callbacks,
+        accumulatedText: () => accumulated,
+        start: () => {
+            if (running) {
+                return;
+            }
+            running = true;
+            typingLoop.start();
+        },
+        stop,
+        finalize,
+        fail,
+    };
+}

package/dist/channel-turn-lifecycle.js

@@ -0,0 +1,73 @@
+import { randomUUID } from "node:crypto";
+export function createChannelTurnLifecycle(promptDescription) {
+    const startedAt = Date.now();
+    const turnId = randomUUID().slice(0, 12);
+    const progress = {
+        status: "running",
+        promptDescription,
+        startedAt,
+        updatedAt: startedAt,
+        toolCounts: new Map(),
+        textCharacters: 0,
+    };
+    const touch = () => {
+        progress.updatedAt = Date.now();
+    };
+    return {
+        turnId,
+        startedAt,
+        progress,
+        touch,
+        recordTextDelta: (characters) => {
+            progress.textCharacters += Math.max(0, characters);
+            touch();
+        },
+        recordToolStart: (toolName) => {
+            progress.currentTool = toolName;
+            progress.lastTool = toolName;
+            progress.toolCounts.set(toolName, (progress.toolCounts.get(toolName) ?? 0) + 1);
+            touch();
+        },
+        recordToolUpdate: touch,
+        recordToolEnd: () => {
+            progress.currentTool = undefined;
+            touch();
+        },
+        recordCompleted: () => {
+            progress.status = "completed";
+            progress.completedAt = Date.now();
+            progress.updatedAt = progress.completedAt;
+        },
+        recordFailed: (error) => {
+            progress.status = "failed";
+            progress.error = error;
+            progress.completedAt = Date.now();
+            progress.updatedAt = progress.completedAt;
+        },
+    };
+}
+export function createChannelTypingLoop(options) {
+    let timer;
+    let running = false;
+    const sendTyping = () => {
+        void options.sendTyping().catch(() => { });
+    };
+    return {
+        start: () => {
+            if (running) {
+                return;
+            }
+            running = true;
+            timer = setInterval(sendTyping, options.intervalMs);
+            timer.unref?.();
+            sendTyping();
+        },
+        stop: () => {
+            running = false;
+            if (timer) {
+                clearInterval(timer);
+                timer = undefined;
+            }
+        },
+    };
+}