@nordbyte/nordrelay 0.8.0 → 0.8.2

package/dist/{bot.js → channels/telegram/bot.js}

@@ -3,36 +3,38 @@ import { readFile, unlink } from "node:fs/promises";
 import path from "node:path";
 import { autoRetry } from "@grammyjs/auto-retry";
 import { Bot, InlineKeyboard, InputFile } from "grammy";
-import { ADMIN_GROUP_ID } from "./access-control.js";
-import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
-import { collectArtifactReport, collectRecentWorkspaceArtifacts, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, isTelegramImagePreview, persistWorkspaceArtifactReport, pruneConnectorTurnDirs, telegramArtifactFilename, totalArtifactSize, } from "./artifacts.js";
-import { AgentUpdateManager } from "./agent-updates.js";
-import { AuditLogStore } from "./audit-log.js";
+import { ADMIN_GROUP_ID } from "../../access/access-control.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "../../artifacts/attachments.js";
+import { collectArtifactReport, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, isTelegramImagePreview, pruneConnectorTurnDirs, telegramArtifactFilename, totalArtifactSize, } from "../../artifacts/artifacts.js";
+import { AgentUpdateManager } from "../../agents/shared/agent-updates.js";
+import { AuditLogStore } from "../../access/audit-log.js";
 import { formatSessionLabel } from "./bot-ui.js";
-import { BotPreferencesStore, isQuietNow, } from "./bot-preferences.js";
-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";
-import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
-import { formatLaunchProfileBehavior } from "./codex-launch.js";
-import { contextKeyFromCtx, isTelegramContextKey, isTopicContextKey, parseContextKey } from "./context-key.js";
-import { friendlyErrorText } from "./error-messages.js";
-import { escapeHTML } from "./format.js";
-import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
-import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
-import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
-import { RemoteRelayClient } from "./peer-client.js";
-import { checkPiAuthStatus } from "./pi-auth.js";
-import { configureRedaction, redactText } from "./redaction.js";
-import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
-import { renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
-import { SessionRegistry } from "./session-registry.js";
-import { transcribeAudio } from "./voice.js";
+import { BotPreferencesStore, isQuietNow, } from "../../state/bot-preferences.js";
+import { renderAgentUpdateJobAction } from "../shared/channel-actions.js";
+import { createChannelBusyStore } from "../shared/channel-bridge-controller.js";
+import { ChannelCommandService } from "../shared/channel-command-service.js";
+import { runChannelPeerPrompt } from "../shared/channel-peer-prompt.js";
+import { deliverChannelAction } from "../shared/channel-runtime.js";
+import { deliverChannelCliArtifacts } from "../shared/channel-cli-artifacts.js";
+import { createChannelExternalMirrorController } from "../shared/channel-external-mirror-controller.js";
+import { monitorChannelExternalContexts } from "../shared/channel-external-monitor.js";
+import { createChannelTurnLifecycle, createChannelTypingLoop } from "../shared/channel-turn-lifecycle.js";
+import { agentLabel, agentReasoningLabel, agentReasoningOptions, } from "../../agents/shared/agent.js";
+import { agentIdForAuth as resolveAgentIdForAuth, agentLabelForAuth, hostAgentLoginCommand, hostAgentLogoutCommand, } from "../../agents/shared/agent-auth-commands.js";
+import { getExternalActivityForSession, } from "../../agents/shared/agent-activity.js";
+import { checkAuthStatus, clearAuthCache, startLogin as startCodexLogin, startLogout as startCodexLogout } from "../../agents/codex/codex-auth.js";
+import { formatLaunchProfileBehavior } from "../../agents/codex/codex-launch.js";
+import { contextKeyFromCtx, isTelegramContextKey, isTopicContextKey, parseContextKey } from "../shared/context-key.js";
+import { friendlyErrorText } from "../../core/error-messages.js";
+import { escapeHTML } from "../../core/format.js";
+import { PromptStore, toPromptEnvelope } from "../../state/prompt-store.js";
+import { RemoteRelayClient } from "../../peers/peer-client.js";
+import { RelayAuthService } from "../../runtime/relay-auth-service.js";
+import { configureRedaction, redactText } from "../../core/redaction.js";
+import { canWriteWithLock, SessionLockStore } from "../../access/session-locks.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain, } from "../shared/session-format.js";
+import { SessionRegistry } from "../../state/session-registry.js";
+import { transcribeAudio } from "../../artifacts/voice.js";
 import { telegramRateLimiter } from "./telegram-rate-limit.js";
 import { chatBucket, downloadTelegramFile, isMessageNotModifiedError, renderMarkdownChunkWithinLimit, safeEditMessage, safeEditReplyMarkup, safeReply, sendChatActionSafe, sendTextMessage, splitMarkdownForTelegram, } from "./telegram-output.js";
 import { NOOP_PAGE_CALLBACK_DATA, TelegramBotChannelRuntime, paginateKeyboard, telegramChannelContextFromCtx, } from "./telegram-channel-runtime.js";
@@ -47,11 +49,11 @@ import { registerTelegramPreferenceCommands } from "./telegram-preference-comman
 import { createQueuedPromptCancelKeyboard, registerTelegramQueueCommands, } from "./telegram-queue-commands.js";
 import { registerTelegramSupportCommands } from "./telegram-support-command.js";
 import { registerTelegramUpdateCommands } from "./telegram-update-commands.js";
-import { appendWithCap, authHelpText, buildStreamingPreview, capabilitiesOf, filterSessions, formatAgentLaunchProfileLabel, formatAgentSettingScope, formatDurationSeconds, formatError, formatLocalDateTime, formatLockOwner, formatModelButtonLabel, formatRelativeTime, formatTelegramName, formatToolSummaryLine, formatTurnUsageLine, getWorkspaceShortName, idOf, isEmptyArtifactReport, isPromptEnvelopeLike, isQueuedPromptLike, labelOf, orderPinnedSessions, parseFastModeArgument, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, renderTodoList, renderToolEndMessage, renderToolStartMessage, requiresTurnApproval, trimLine, } from "./bot-rendering.js";
-import { UserStore } from "./user-management.js";
-import { WebActivityStore } from "./web-state.js";
-import { evaluateWorkspacePolicy, filterAllowedWorkspaces, renderWorkspacePolicyLine, } from "./workspace-policy.js";
-export { formatToolSummaryLine, formatTurnUsageLine, summarizeToolName } from "./bot-rendering.js";
+import { appendWithCap, authHelpText, buildStreamingPreview, capabilitiesOf, filterSessions, formatAgentLaunchProfileLabel, formatAgentSettingScope, formatDurationSeconds, formatError, formatLocalDateTime, formatLockOwner, formatModelButtonLabel, formatRelativeTime, formatTelegramName, formatToolSummaryLine, formatTurnUsageLine, getWorkspaceShortName, idOf, isEmptyArtifactReport, isPromptEnvelopeLike, isQueuedPromptLike, labelOf, orderPinnedSessions, parseFastModeArgument, renderPromptFailure, renderTodoList, renderToolEndMessage, renderToolStartMessage, requiresTurnApproval, trimLine, } from "../shared/bot-rendering.js";
+import { UserStore } from "../../access/user-management.js";
+import { WebActivityStore } from "../../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces, renderWorkspacePolicyLine, } from "../../core/workspace-policy.js";
+export { formatToolSummaryLine, formatTurnUsageLine, summarizeToolName } from "../shared/bot-rendering.js";
 export { registerCommands } from "./telegram-command-menu.js";
 const EDIT_DEBOUNCE_MS = 1500;
 const TYPING_INTERVAL_MS = 4500;
@@ -73,7 +75,12 @@ export function createBot(config, registry) {
     const bot = new Bot(config.telegramBotToken);
     bot.api.config.use(autoRetry({ maxRetryAttempts: 3, maxDelaySeconds: 10 }));
     const telegramChannelRuntime = new TelegramBotChannelRuntime(bot);
-    const contextBusy = new Map();
+    const contextBusy = createChannelBusyStore(() => ({
+        processing: false,
+        switching: false,
+        transcribing: false,
+        approving: false,
+    }));
     const pendingApprovals = new Map();
     const pendingSessionPicks = new Map();
     const pendingWorkspacePicks = new Map();
@@ -93,6 +100,7 @@ export function createBot(config, registry) {
     const auditLog = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
     const userStore = new UserStore();
+    const authService = new RelayAuthService(config);
     const contextUsers = new WeakMap();
     const agentUpdateActors = new Map();
     const agentUpdateStates = new Map();
@@ -155,17 +163,10 @@ export function createBot(config, registry) {
             }
         }
     });
-    const getBusyState = (contextKey) => {
-        let state = contextBusy.get(contextKey);
-        if (!state) {
-            state = { processing: false, switching: false, transcribing: false, approving: false };
-            contextBusy.set(contextKey, state);
-        }
-        return state;
-    };
+    const getBusyState = (contextKey) => contextBusy.get(contextKey);
     const getExternalActivity = (session) => getExternalActivityForSession(session, config);
     const getBusyReason = (contextKey) => {
-        const state = contextBusy.get(contextKey);
+        const state = contextBusy.peek(contextKey);
         const session = registry.get(contextKey);
         if (state?.processing || state?.switching || state?.transcribing || state?.approving || session?.isProcessing()) {
             return { busy: true, kind: "connector", state: state ?? getBusyState(contextKey) };
@@ -191,41 +192,14 @@ export function createBot(config, registry) {
         registry.updateMetadata(contextKey, session);
     };
     const checkAgentAuthStatus = async (info) => {
-        if (idOf(info) === "pi") {
-            return checkPiAuthStatus(info.model);
-        }
-        if (idOf(info) === "hermes") {
-            return checkHermesAuthStatus({
-                baseUrl: config.hermesApiBaseUrl,
-                apiKey: config.hermesApiKey,
-            });
-        }
-        if (idOf(info) === "openclaw") {
-            return checkOpenClawAuthStatus({
-                gatewayUrl: config.openClawGatewayUrl,
-                token: config.openClawGatewayToken,
-                password: config.openClawGatewayPassword,
-            });
-        }
-        if (idOf(info) === "claude-code") {
-            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
-        }
-        return checkAuthStatus(config.codexApiKey);
+        const status = await authService.check(info);
+        return { ...status, method: status.method ?? "unknown" };
     };
-    const agentIdForAuth = (info) => info ? idOf(info) : "codex";
-    const labelForAuth = (info) => info ? labelOf(info) : "Codex";
+    const agentIdForAuth = resolveAgentIdForAuth;
+    const labelForAuth = agentLabelForAuth;
     const checkLoginAuthStatus = async (info) => {
-        const agentId = agentIdForAuth(info);
-        if (agentId === "hermes") {
-            return checkHermesAuthStatus({
-                baseUrl: config.hermesApiBaseUrl,
-                apiKey: config.hermesApiKey,
-            });
-        }
-        if (agentId === "claude-code") {
-            return checkClaudeCodeAuthStatus(config.claudeCodeCliPath);
-        }
-        return checkAuthStatus(config.codexApiKey);
+        const status = info ? await authService.check(info) : await checkAuthStatus(config.codexApiKey);
+        return { ...status, method: status.method ?? "unknown" };
     };
     const replyChannelAction = async (ctx, rendered) => {
         const channelContext = telegramChannelContextFromCtx(ctx);
@@ -280,44 +254,16 @@ export function createBot(config, registry) {
         }
     };
     const startAgentLogin = (info) => {
-        const agentId = agentIdForAuth(info);
-        if (agentId === "hermes") {
-            return startHermesLogin(config.hermesCliPath);
-        }
-        if (agentId === "claude-code") {
-            return startClaudeCodeLogin(config.claudeCodeCliPath);
-        }
-        return startCodexLogin();
+        return info ? authService.startLogin(info) : startCodexLogin();
     };
     const startAgentLogout = (info) => {
-        const agentId = agentIdForAuth(info);
-        if (agentId === "hermes") {
-            return startHermesLogout(config.hermesCliPath);
-        }
-        if (agentId === "claude-code") {
-            return startClaudeCodeLogout(config.claudeCodeCliPath);
-        }
-        return startCodexLogout();
+        return info ? authService.startLogout(info) : startCodexLogout();
     };
     const hostLoginCommand = (info) => {
-        const agentId = agentIdForAuth(info);
-        if (agentId === "hermes") {
-            return `${config.hermesCliPath ?? "hermes"} login --no-browser`;
-        }
-        if (agentId === "claude-code") {
-            return `${config.claudeCodeCliPath ?? "claude"} auth login`;
-        }
-        return "codex login --device-auth";
+        return hostAgentLoginCommand(config, info);
     };
     const hostLogoutCommand = (info) => {
-        const agentId = agentIdForAuth(info);
-        if (agentId === "hermes") {
-            return `${config.hermesCliPath ?? "hermes"} logout`;
-        }
-        if (agentId === "claude-code") {
-            return `${config.claudeCodeCliPath ?? "claude"} auth logout`;
-        }
-        return "codex logout";
+        return hostAgentLogoutCommand(config, info);
     };
     const isTopicContext = (contextKey) => isTopicContextKey(contextKey);
     const getPreferences = (contextKey) => preferencesStore.get(contextKey);
@@ -421,276 +367,24 @@ export function createBot(config, registry) {
         return item;
     };
     const monitorExternalContexts = async () => {
-        const contextKeys = new Set([
-            ...registry.listContexts().map((context) => context.contextKey),
-            ...promptStore.listContextKeys(),
-        ].filter(isTelegramContextKey));
-        for (const contextKey of contextKeys) {
-            await monitorExternalContext(contextKey);
-        }
-    };
-    const monitorExternalContext = async (contextKey) => {
-        if (!isTelegramContextKey(contextKey)) {
-            return;
-        }
-        if (!canSendSystemMessagesToContext(contextKey)) {
-            return;
-        }
-        const session = await registry.getOrCreate(contextKey, { deferThreadStart: true }).catch(() => null);
-        if (!session) {
-            return;
-        }
-        const info = session.getInfo();
-        if (!capabilitiesOf(info).externalActivity) {
-            const parsed = parseContextKey(contextKey);
-            const queueLength = promptStore.list(contextKey).length;
-            if (queueLength > 0 && !promptStore.isPaused(contextKey) && !session.isProcessing()) {
-                await drainQueuedPrompts(createSystemContext(contextKey), contextKey, parsed.chatId, session);
-            }
-            return;
-        }
-        const threadId = session.getActiveThreadId();
-        const parsed = parseContextKey(contextKey);
-        const queueLength = promptStore.list(contextKey).length;
-        const paused = promptStore.isPaused(contextKey);
-        if (!threadId) {
-            if (queueLength > 0 && !paused && !session.isProcessing()) {
-                await drainQueuedPrompts(createSystemContext(contextKey), contextKey, parsed.chatId, session);
-            }
-            return;
-        }
-        const previous = externalMirrors.get(contextKey);
-        const snapshot = getExternalSnapshotForSession(session, config, {
-            afterLine: previous?.lastLine ?? Number.MAX_SAFE_INTEGER,
-        }) ?? getExternalSnapshotForSession(session, config, {
-            maxEvents: 0,
-        });
-        if (!snapshot) {
-            if (queueLength > 0 && !paused && !session.isProcessing()) {
+        await monitorChannelExternalContexts({
+            config,
+            registry,
+            promptStore,
+            isContextKey: isTelegramContextKey,
+            canSendSystemMessages: canSendSystemMessagesToContext,
+            contextForKey: channelContextFromTelegramKey,
+            previousLastLine: (contextKey) => externalMirrors.get(contextKey)?.lastLine,
+            mirrorSnapshot: async (contextKey, _context, session, snapshot) => {
+                const parsed = parseContextKey(contextKey);
+                await mirrorExternalSnapshot(contextKey, parsed.chatId, session, snapshot);
+            },
+            updateQueueStatus: (contextKey, _context, text) => updateQueueStatusMessage(contextKey, text),
+            drainQueue: async (contextKey, _context, session) => {
+                const parsed = parseContextKey(contextKey);
                 await drainQueuedPrompts(createSystemContext(contextKey), contextKey, parsed.chatId, session);
-            }
-            return;
-        }
-        if (!session.isProcessing()) {
-            await mirrorExternalSnapshot(contextKey, parsed.chatId, session, snapshot);
-        }
-        const activity = snapshot.activity;
-        if (activity.active && queueLength > 0) {
-            await updateQueueStatusMessage(contextKey, `Waiting for ${info.agentLabel} CLI task... ${queueLength} queued${paused ? " (paused)" : ""}.`);
-            return;
-        }
-        if (!activity.active && queueLength > 0 && !paused && !session.isProcessing()) {
-            await updateQueueStatusMessage(contextKey, `CLI task finished, running queued prompt 1/${queueLength}.`);
-            await drainQueuedPrompts(createSystemContext(contextKey), contextKey, parsed.chatId, session);
-        }
-    };
-    const sendExternalMirrorTyping = async (chatId, messageThreadId, state) => {
-        const now = Date.now();
-        if (state.lastTypingAt && now - state.lastTypingAt < TYPING_INTERVAL_MS) {
-            return;
-        }
-        state.lastTypingAt = now;
-        await sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
-    };
-    const sendExternalWorkingNotice = async (chatId, messageThreadId, state, snapshot) => {
-        const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
-        if (state.workingNoticeTurnKey === turnKey) {
-            return;
-        }
-        const prompt = trimLine(snapshot.latestUserMessage ?? "", 250);
-        const fallbackText = prompt ? `Working on ${prompt}` : `Working on external ${snapshot.agentLabel} task...`;
-        const html = prompt
-            ? `<b>Working on</b> ${escapeHTML(prompt)}`
-            : `<b>Working on</b> external ${escapeHTML(snapshot.agentLabel)} task...`;
-        await sendTextMessage(bot.api, chatId, html, {
-            fallbackText,
-            messageThreadId,
+            },
         });
-        state.workingNoticeTurnKey = turnKey;
-    };
-    const mirrorExternalSnapshot = async (contextKey, chatId, session, snapshot) => {
-        const parsed = parseContextKey(contextKey);
-        const previous = externalMirrors.get(contextKey);
-        let state = previous;
-        if (!state || state.threadId !== snapshot.threadId || state.rolloutPath !== snapshot.sourcePath) {
-            state = {
-                threadId: snapshot.threadId,
-                rolloutPath: snapshot.sourcePath,
-                lastLine: snapshot.lineCount,
-                turnId: snapshot.activity.turnId,
-                startedAt: snapshot.activity.startedAt,
-            };
-            externalMirrors.set(contextKey, state);
-        }
-        const mirrorMode = getEffectiveMirrorMode(contextKey);
-        if (snapshot.activity.active) {
-            state.turnId = snapshot.activity.turnId;
-            state.startedAt = snapshot.activity.startedAt;
-            const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
-            if (state.activityStartedTurnKey !== turnKey) {
-                const info = session.getInfo();
-                appendActivity({
-                    source: "cli",
-                    status: "running",
-                    type: "cli_turn_started",
-                    contextKey,
-                    threadId: snapshot.threadId,
-                    workspace: info.workspace,
-                    agentId: info.agentId,
-                    actor: CLI_ACTIVITY_ACTOR,
-                    prompt: snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`,
-                    detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
-                });
-                state.activityStartedTurnKey = turnKey;
-                state.activityFinishedTurnKey = undefined;
-                state.activityToolStartLines = [];
-                state.activityToolEndLines = [];
-            }
-            if (mirrorMode !== "off") {
-                await sendExternalMirrorTyping(chatId, parsed.messageThreadId, state);
-            }
-            if (mirrorMode === "final") {
-                await sendExternalWorkingNotice(chatId, parsed.messageThreadId, state, snapshot);
-                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-                return;
-            }
-            if (mirrorMode === "off") {
-                state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-                return;
-            }
-            const status = renderExternalMirrorStatus(snapshot, promptStore.list(contextKey).length);
-            const now = Date.now();
-            const canUpdateStatus = !state.latestStatusAt || now - state.latestStatusAt >= config.telegramMirrorMinUpdateMs;
-            if (!state.statusMessageId) {
-                const message = await sendTextMessage(bot.api, chatId, status.html, {
-                    fallbackText: status.plain,
-                    messageThreadId: parsed.messageThreadId,
-                });
-                state.statusMessageId = message.message_id;
-                state.latestStatusAt = now;
-            }
-            else if (state.latestStatus !== status.plain && canUpdateStatus) {
-                await safeEditMessage(bot, chatId, state.statusMessageId, status.html, {
-                    fallbackText: status.plain,
-                });
-                state.latestStatusAt = now;
-            }
-            state.latestStatus = status.plain;
-            if (mirrorMode === "full") {
-                const newEvents = snapshot.events
-                    .filter((event) => event.lineNumber > (state.latestMirroredEventLine ?? state.lastLine))
-                    .filter((event) => event.kind === "tool" || event.kind === "task")
-                    .slice(-4);
-                for (const event of newEvents) {
-                    const rendered = renderExternalMirrorEvent(event);
-                    if (!rendered) {
-                        continue;
-                    }
-                    await sendTextMessage(bot.api, chatId, rendered.html, {
-                        fallbackText: rendered.plain,
-                        messageThreadId: parsed.messageThreadId,
-                    });
-                    state.latestMirroredEventLine = event.lineNumber;
-                }
-            }
-            const info = session.getInfo();
-            const loggedStartLines = new Set(state.activityToolStartLines ?? []);
-            const loggedEndLines = new Set(state.activityToolEndLines ?? []);
-            for (const event of snapshot.events.filter((event) => event.lineNumber > state.lastLine && event.kind === "tool")) {
-                if (event.status === "started" && !loggedStartLines.has(event.lineNumber)) {
-                    appendActivity({
-                        source: "cli",
-                        status: "running",
-                        type: "cli_tool_started",
-                        contextKey,
-                        threadId: snapshot.threadId,
-                        workspace: info.workspace,
-                        agentId: info.agentId,
-                        actor: CLI_ACTIVITY_ACTOR,
-                        prompt: snapshot.latestUserMessage ?? undefined,
-                        detail: event.toolName ?? "tool",
-                    });
-                    loggedStartLines.add(event.lineNumber);
-                }
-                if ((event.status === "finished" || event.status === "failed") && !loggedEndLines.has(event.lineNumber)) {
-                    appendActivity({
-                        source: "cli",
-                        status: event.status === "failed" ? "failed" : "completed",
-                        type: event.status === "failed" ? "cli_tool_failed" : "cli_tool_completed",
-                        contextKey,
-                        threadId: snapshot.threadId,
-                        workspace: info.workspace,
-                        agentId: info.agentId,
-                        actor: CLI_ACTIVITY_ACTOR,
-                        prompt: snapshot.latestUserMessage ?? undefined,
-                        detail: event.toolName ?? "tool",
-                    });
-                    loggedEndLines.add(event.lineNumber);
-                }
-            }
-            state.activityToolStartLines = [...loggedStartLines].slice(-200);
-            state.activityToolEndLines = [...loggedEndLines].slice(-200);
-            state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-            return;
-        }
-        if (!previous) {
-            state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
-            return;
-        }
-        const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
-        if (terminalEvent) {
-            const turnKey = terminalEvent.turnId ?? snapshot.activity.turnId ?? state.startedAt?.toString() ?? "unknown";
-            if (state.activityFinishedTurnKey !== turnKey) {
-                const info = session.getInfo();
-                const startedAt = state.startedAt instanceof Date ? state.startedAt : state.startedAt ? new Date(state.startedAt) : snapshot.activity.startedAt;
-                appendActivity({
-                    source: "cli",
-                    status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
-                    type: "cli_turn_finished",
-                    contextKey,
-                    threadId: snapshot.threadId,
-                    workspace: info.workspace,
-                    agentId: info.agentId,
-                    actor: CLI_ACTIVITY_ACTOR,
-                    prompt: snapshot.latestUserMessage ?? undefined,
-                    detail: `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`,
-                    durationMs: startedAt && terminalEvent.timestamp ? Math.max(0, terminalEvent.timestamp.getTime() - startedAt.getTime()) : undefined,
-                });
-                state.activityFinishedTurnKey = turnKey;
-            }
-            if (mirrorMode !== "off") {
-                const doneText = `${snapshot.agentLabel} CLI task ${terminalEvent.status}.`;
-                if (state.statusMessageId) {
-                    await safeEditMessage(bot, chatId, state.statusMessageId, escapeHTML(doneText), {
-                        fallbackText: doneText,
-                    });
-                }
-                else if (shouldNotify(contextKey, "minimal")) {
-                    await sendTextMessage(bot.api, chatId, escapeHTML(doneText), {
-                        fallbackText: doneText,
-                        messageThreadId: parsed.messageThreadId,
-                    });
-                }
-            }
-            const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
-            if (mirrorMode !== "off" && mirrorMode !== "status" && finalAgent?.text && finalAgent.lineNumber !== state.latestAgentLine) {
-                await sendTextMessage(bot.api, chatId, `<b>${escapeHTML(snapshot.agentLabel)} CLI final answer:</b>`, {
-                    fallbackText: `${snapshot.agentLabel} CLI final answer:`,
-                    messageThreadId: parsed.messageThreadId,
-                });
-                for (const chunk of splitMarkdownForTelegram(finalAgent.text)) {
-                    await sendTextMessage(bot.api, chatId, chunk.text, {
-                        parseMode: chunk.parseMode,
-                        fallbackText: chunk.fallbackText,
-                        messageThreadId: parsed.messageThreadId,
-                    });
-                }
-                state.latestAgentLine = finalAgent.lineNumber;
-            }
-            await deliverCliGeneratedArtifacts(contextKey, chatId, session, state.startedAt, terminalEvent.turnId, parsed.messageThreadId);
-        }
-        state.workingNoticeTurnKey = undefined;
-        state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
     };
     const canSendSystemMessagesToContext = (contextKey) => {
         if (!userStore.hasAdminUser()) {
@@ -706,59 +400,116 @@ export function createBot(config, registry) {
         if (!canSendSystemMessagesToContext(contextKey)) {
             return;
         }
-        if (!startedAt || !turnId) {
-            return;
-        }
-        const state = externalMirrors.get(contextKey);
-        if (state?.artifactsDeliveredForTurnId === turnId) {
-            return;
-        }
-        const workspace = session.getInfo().workspace;
-        const report = await collectRecentWorkspaceArtifacts(workspace, {
-            since: startedAt,
-            until: new Date(),
-            maxFileSize: config.maxFileSize,
-            limit: 5,
-            ignoreDirs: config.artifactIgnoreDirs,
-            ignoreGlobs: config.artifactIgnoreGlobs,
-        });
-        if (isEmptyArtifactReport(report)) {
-            if (state)
-                state.artifactsDeliveredForTurnId = turnId;
-            return;
-        }
-        const persistedReport = await persistWorkspaceArtifactReport(workspace, turnId, report).catch((error) => {
-            console.error("Failed to persist CLI artifact report:", error);
-            return null;
-        });
-        if (!config.telegramAutoSendArtifacts) {
-            if (state)
-                state.artifactsDeliveredForTurnId = turnId;
-            return;
-        }
-        const summary = formatArtifactSummary(report.artifacts, report.skippedCount, report.omittedCount);
-        await sendTextMessage(bot.api, chatId, escapeHTML(summary), {
-            fallbackText: summary,
-            messageThreadId,
-        });
-        for (const artifact of (persistedReport?.artifacts ?? report.artifacts)) {
-            await sendArtifactFileByApi(bot.api, chatId, artifact, messageThreadId);
-        }
-        const info = session.getInfo();
-        appendActivity({
-            source: "cli",
-            status: "info",
-            type: "artifacts_sent",
+        await deliverChannelCliArtifacts({
+            config,
             contextKey,
-            threadId: info.threadId,
-            workspace: info.workspace,
-            agentId: info.agentId,
-            actor: CLI_ACTIVITY_ACTOR,
-            detail: summary,
+            session,
+            startedAt,
+            turnId,
+            state: externalMirrors.get(contextKey),
+            autoSend: config.telegramAutoSendArtifacts,
+            sendSummaryWhenAutoSendDisabled: false,
+            logPrefix: "Telegram",
+            sendSummary: (summary) => sendTextMessage(bot.api, chatId, escapeHTML(summary), {
+                fallbackText: summary,
+                messageThreadId,
+            }).then(() => { }),
+            sendArtifact: (artifact) => sendArtifactFileByApi(bot.api, chatId, artifact, messageThreadId).then(() => { }),
+            appendActivity,
         });
-        if (state)
-            state.artifactsDeliveredForTurnId = turnId;
     };
+    const channelContextFromTelegramKey = (contextKey) => {
+        const parsed = parseContextKey(contextKey);
+        return {
+            channelId: "telegram",
+            chatId: String(parsed.chatId),
+            ...(parsed.messageThreadId ? { topicId: String(parsed.messageThreadId) } : {}),
+        };
+    };
+    const externalMirrorController = createChannelExternalMirrorController({
+        config,
+        states: externalMirrors,
+        typingIntervalMs: TYPING_INTERVAL_MS,
+        minUpdateMs: () => config.telegramMirrorMinUpdateMs,
+        mirrorMode: (contextKey) => getEffectiveMirrorMode(contextKey),
+        queueLength: (contextKey) => promptStore.list(contextKey).length,
+        activityActor: () => CLI_ACTIVITY_ACTOR,
+        appendActivity,
+        sendTyping: async (contextKey) => {
+            const parsed = parseContextKey(contextKey);
+            await sendChatActionSafe(bot.api, parsed.chatId, "typing", parsed.messageThreadId).catch(() => { });
+        },
+        sendWorkingNotice: async (contextKey, _context, state, snapshot, prompt) => {
+            const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
+            if (state.workingNoticeTurnKey === turnKey) {
+                return;
+            }
+            const parsed = parseContextKey(contextKey);
+            const fallbackText = prompt ? `Working on ${prompt}` : `Working on external ${snapshot.agentLabel} task...`;
+            const html = prompt
+                ? `<b>Working on</b> ${escapeHTML(prompt)}`
+                : `<b>Working on</b> external ${escapeHTML(snapshot.agentLabel)} task...`;
+            await sendTextMessage(bot.api, parsed.chatId, html, {
+                fallbackText,
+                messageThreadId: parsed.messageThreadId,
+            });
+            state.workingNoticeTurnKey = turnKey;
+        },
+        sendStatus: async (contextKey, _context, _state, rendered) => {
+            const parsed = parseContextKey(contextKey);
+            const message = await sendTextMessage(bot.api, parsed.chatId, rendered.html, {
+                fallbackText: rendered.plain,
+                messageThreadId: parsed.messageThreadId,
+            });
+            return message.message_id;
+        },
+        editStatus: async (contextKey, _context, _state, messageId, rendered) => {
+            const parsed = parseContextKey(contextKey);
+            await safeEditMessage(bot, parsed.chatId, messageId, rendered.html, {
+                fallbackText: rendered.plain,
+            });
+        },
+        sendEvent: async (contextKey, _context, _state, rendered) => {
+            const parsed = parseContextKey(contextKey);
+            await sendTextMessage(bot.api, parsed.chatId, rendered.html, {
+                fallbackText: rendered.plain,
+                messageThreadId: parsed.messageThreadId,
+            });
+        },
+        sendDone: async (contextKey, _context, state, text) => {
+            const parsed = parseContextKey(contextKey);
+            if (state.statusMessageId) {
+                await safeEditMessage(bot, parsed.chatId, state.statusMessageId, escapeHTML(text), {
+                    fallbackText: text,
+                });
+                return;
+            }
+            await sendTextMessage(bot.api, parsed.chatId, escapeHTML(text), {
+                fallbackText: text,
+                messageThreadId: parsed.messageThreadId,
+            });
+        },
+        sendFinalAnswer: async (contextKey, _context, _state, snapshot, text) => {
+            const parsed = parseContextKey(contextKey);
+            await sendTextMessage(bot.api, parsed.chatId, `<b>${escapeHTML(snapshot.agentLabel)} CLI final answer:</b>`, {
+                fallbackText: `${snapshot.agentLabel} CLI final answer:`,
+                messageThreadId: parsed.messageThreadId,
+            });
+            for (const chunk of splitMarkdownForTelegram(text)) {
+                await sendTextMessage(bot.api, parsed.chatId, chunk.text, {
+                    parseMode: chunk.parseMode,
+                    fallbackText: chunk.fallbackText,
+                    messageThreadId: parsed.messageThreadId,
+                });
+            }
+        },
+        deliverArtifacts: (contextKey, _context, session, state, turnId) => {
+            const parsed = parseContextKey(contextKey);
+            return deliverCliGeneratedArtifacts(contextKey, parsed.chatId, session, state.startedAt, turnId, parsed.messageThreadId);
+        },
+        shouldSendDone: (contextKey) => shouldNotify(contextKey, "minimal"),
+    });
+    const mirrorExternalSnapshot = (contextKey, _chatId, session, snapshot) => externalMirrorController.mirror(contextKey, channelContextFromTelegramKey(contextKey), session, snapshot);
     const scheduleExternalQueueDrain = (ctx, contextKey, chatId, session) => {
         if (externalQueueTimers.has(contextKey)) {
             return;