@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/channel-actions.js

@@ -7,7 +7,9 @@ export function renderChannelsAction(descriptors) {
     const plain = [
         "Channel adapters:",
         ...descriptors.map((descriptor) => {
-            const status = descriptor.status === "available" ? "available" : "planned";
+            const status = descriptor.status === "available"
+                ? descriptor.enabled === false ? "available / disabled" : "available / enabled"
+                : "planned";
             return `${descriptor.label}: ${status} · ${descriptor.capabilities.join(", ")}`;
         }),
     ].join("\n");
@@ -15,8 +17,11 @@ export function renderChannelsAction(descriptors) {
         "<b>Channel adapters:</b>",
         ...descriptors.map((descriptor) => {
             const statusIcon = descriptor.status === "available" ? "✅" : "🟡";
+            const status = descriptor.status === "available"
+                ? descriptor.enabled === false ? "available / disabled" : "available / enabled"
+                : descriptor.status;
             const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
-            return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(descriptor.status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
+            return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
         }),
     ].join("\n");
     return { plain, html };

package/dist/channel-adapter.js

@@ -9,14 +9,17 @@ const TELEGRAM_CAPABILITIES = [
     "topics",
     "webhooks",
 ];
+const DISCORD_CAPABILITIES = [
+    "text",
+    "streaming-edits",
+    "typing",
+    "inline-buttons",
+    "files",
+    "photos",
+    "voice",
+    "topics",
+];
 const PLANNED_CHANNELS = [
-    {
-        id: "discord",
-        label: "Discord",
-        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files", "photos", "voice"],
-        status: "planned",
-        notes: "Adapter boundary is ready; runtime integration still needs bot credentials and event mapping.",
-    },
     {
         id: "whatsapp",
         label: "WhatsApp",
@@ -42,17 +45,47 @@ export class TelegramChannelAdapter {
     label = "Telegram";
     capabilities = new Set(TELEGRAM_CAPABILITIES);
     describe() {
+        const requested = process.env.TELEGRAM_ENABLED !== "false";
+        const enabled = requested && Boolean(process.env.TELEGRAM_BOT_TOKEN);
+        return {
+            id: this.id,
+            label: this.label,
+            capabilities: [...this.capabilities],
+            status: "available",
+            enabled,
+            notes: enabled
+                ? "Telegram bot runtime is enabled."
+                : requested
+                    ? "Telegram bot runtime is disabled because TELEGRAM_BOT_TOKEN is missing."
+                    : "Telegram bot runtime is disabled.",
+        };
+    }
+}
+export class DiscordChannelAdapter {
+    id = "discord";
+    label = "Discord";
+    capabilities = new Set(DISCORD_CAPABILITIES);
+    describe() {
+        const requested = process.env.DISCORD_ENABLED === "true";
+        const enabled = requested && Boolean(process.env.DISCORD_BOT_TOKEN);
         return {
             id: this.id,
             label: this.label,
             capabilities: [...this.capabilities],
             status: "available",
+            enabled,
+            notes: enabled
+                ? "Discord bot runtime is enabled."
+                : requested
+                    ? "Discord bot runtime is disabled because DISCORD_BOT_TOKEN is missing."
+                    : "Enable with DISCORD_ENABLED=true and DISCORD_BOT_TOKEN.",
         };
     }
 }
 export function listChannelDescriptors() {
     return [
         new TelegramChannelAdapter().describe(),
+        new DiscordChannelAdapter().describe(),
         ...PLANNED_CHANNELS,
     ];
 }

package/dist/channel-command-catalog.js

@@ -0,0 +1,88 @@
+const textOption = (name = "value", description = "Value", required = false) => ({
+    type: 3,
+    name,
+    description,
+    required,
+});
+export const CHANNEL_COMMANDS = [
+    { name: "start", description: "Welcome and status", discordDescription: "Start or inspect the current NordRelay context" },
+    { name: "help", description: "Command reference", discordDescription: "Show Discord adapter help" },
+    { name: "prompt", description: "Send a prompt to the selected agent", telegram: false, discordOptions: [textOption("text", "Prompt text", true)] },
+    { name: "link", description: "Link account to NordRelay user", telegramDescription: "Link Telegram to NordRelay user", discordDescription: "Link this Discord account with a NordRelay code", discordOptions: [textOption("value", "Link code", true)] },
+    { name: "whoami", description: "Show your NordRelay user", discordDescription: "Show linked NordRelay user" },
+    { name: "register_chat", description: "Admin: enable this group chat", discord: false },
+    { name: "register_channel", description: "Enable this Discord channel for NordRelay", telegram: false },
+    { name: "channels", description: "Messaging adapter status", discordDescription: "Show channel adapters" },
+    { name: "peers", description: "NordRelay peer status", discordDescription: "Show paired NordRelay instances" },
+    { name: "target", description: "Select local or peer target", discordDescription: "Select local or peer target", discordOptions: [textOption("value", "local or peer id")] },
+    { name: "agents", description: "Agent adapter status", discordDescription: "Show agent adapters" },
+    { name: "agent", description: "Select agent", discordDescription: "Select or show the active agent", discordOptions: [textOption("value", "Agent id")] },
+    { name: "new", description: "Start a new thread", discordDescription: "Create a new session", discordOptions: [textOption("value", "Workspace path")] },
+    { name: "session", description: "Current thread details", discordDescription: "Show the active session" },
+    { name: "sessions", description: "Browse and switch threads", discordDescription: "Browse recent sessions", discordOptions: [textOption("query", "Search query")] },
+    { name: "switch", description: "Switch to a thread by ID", discordDescription: "Switch to a session", discordOptions: [textOption("thread_id", "Thread id", true)] },
+    { name: "attach", description: "Bind a session to this topic", discordDescription: "Attach a session", discordOptions: [textOption("thread_id", "Thread id", true)] },
+    { name: "handback", description: "Hand session back to CLI", discordDescription: "Hand the active session back to the native CLI" },
+    { name: "sync", description: "Sync active session from CLI state", discordDescription: "Sync from local agent state" },
+    { name: "pinned", description: "Show pinned threads" },
+    { name: "pin", description: "Pin current or given thread", discordOptions: [textOption("value", "Thread id")] },
+    { name: "unpin", description: "Unpin current or given thread", discordOptions: [textOption("value", "Thread id")] },
+    { name: "retry", description: "Resend the last prompt", discordDescription: "Retry the last prompt" },
+    { name: "queue", description: "Show queued prompts", discordDescription: "Show or manage queue", discordOptions: [textOption("action", "pause/resume/clear/run/cancel/top/up/down"), textOption("id", "Queue id")] },
+    { name: "cancel", description: "Cancel a queued prompt", discordOptions: [textOption("value", "Queue id", true)] },
+    { name: "clearqueue", description: "Clear queued prompts", discordDescription: "Clear queue" },
+    { name: "artifacts", description: "List or resend generated files", discordDescription: "List or send artifacts", discordOptions: [textOption("value", "zip <turn-id>")] },
+    { name: "workspaces", description: "List allowed workspaces" },
+    { name: "abort", description: "Cancel current operation", discordDescription: "Abort the active task" },
+    { name: "stop", description: "Cancel current operation", discordDescription: "Abort the active task" },
+    { name: "launch", description: "Select launch profile", discordOptions: [textOption("value", "Launch profile id")] },
+    { name: "launch_profiles", description: "Select launch profile", discordOptions: [textOption("value", "Launch profile id")] },
+    { name: "fast", description: "Toggle fast mode", discordOptions: [textOption("value", "on/off")] },
+    { name: "model", description: "View and change model", discordDescription: "Select or show models", discordOptions: [textOption("value", "Model id")] },
+    { name: "effort", description: "Set reasoning effort", discordDescription: "Select reasoning effort", discordOptions: [textOption("value", "Reasoning value")] },
+    { name: "reasoning", description: "Set reasoning effort", discordDescription: "Select reasoning effort", discordOptions: [textOption("value", "Reasoning value")] },
+    { name: "mirror", description: "Control CLI mirroring", discordDescription: "Set mirror mode", discordOptions: [textOption("value", "off/status/final/full")] },
+    { name: "notify", description: "Control notifications", discordDescription: "Set notification mode", discordOptions: [textOption("value", "off/minimal/all")] },
+    { name: "auth", description: "Check auth status", discordDescription: "Show selected agent auth status" },
+    { name: "login", description: "Start authentication", discordDescription: "Start selected agent login" },
+    { name: "logout", description: "Sign out", discordDescription: "Sign out of the selected agent" },
+    { name: "voice", description: "Voice transcription status", discordDescription: "Show or change voice settings", discordOptions: [textOption("value", "transcribe-only on/off")] },
+    { name: "tasks", description: "Current turn progress", discordDescription: "Show recent tasks", discordOptions: [textOption("value", "Limit")] },
+    { name: "progress", description: "Current turn progress", discordDescription: "Show current turn progress" },
+    { name: "activity", description: "Thread activity timeline", discordDescription: "Show recent activity", discordOptions: [textOption("value", "Limit")] },
+    { name: "audit", description: "Admin: recent audit events", discordDescription: "Show recent audit events", discordOptions: [textOption("value", "Limit")] },
+    { name: "status", description: "Connector runtime status", discordDescription: "Show status" },
+    { name: "health", description: "Connector health report", discordDescription: "Show health" },
+    { name: "version", description: "Connector version", discordDescription: "Show versions" },
+    { name: "logs", description: "Admin: show connector logs", discordDescription: "Show logs", discordOptions: [textOption("value", "Target and line count")] },
+    { name: "diagnostics", description: "Admin: connector diagnostics", discordDescription: "Show diagnostics" },
+    { name: "support", description: "Admin: export diagnostics bundle", discordDescription: "Show support diagnostics" },
+    { name: "lock", description: "Lock session writes to you", discordDescription: "Lock this context" },
+    { name: "unlock", description: "Release session write lock", discordDescription: "Unlock this context" },
+    { name: "locks", description: "List session write locks", discordDescription: "List locks" },
+    { name: "restart", description: "Admin: restart connector", discordDescription: "Restart NordRelay" },
+    { name: "update", description: "Admin: update connector or agents", discordDescription: "Update NordRelay or agents", discordOptions: [textOption("target", "jobs, install, log, cancel, input, or agent id"), textOption("agent", "Agent id or job id"), textOption("input", "Text for update input")] },
+];
+export function telegramCommandCatalog() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.telegram !== false)
+        .map((entry) => ({
+        command: entry.name,
+        description: entry.telegramDescription ?? entry.description,
+    }));
+}
+export function discordCommandCatalog() {
+    return CHANNEL_COMMANDS
+        .filter((entry) => entry.discord !== false)
+        .map((entry) => ({
+        name: entry.name,
+        description: entry.discordDescription ?? entry.description,
+        options: entry.discordOptions ?? [],
+    }));
+}
+export function discordHelpCommandList() {
+    return discordCommandCatalog()
+        .filter((entry) => !["start", "help", "prompt"].includes(entry.name))
+        .map((entry) => `/${entry.name}`)
+        .join(", ");
+}

package/dist/channel-command-service.js

@@ -0,0 +1,369 @@
+import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { enabledAgents } from "./agent-factory.js";
+import { formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
+import { logTailRequests, parseLogsCommand, renderAgentsAction, renderChannelsAction, renderLogTailsAction, } from "./channel-actions.js";
+import { listChannelDescriptors } from "./channel-adapter.js";
+import { friendlyErrorText } from "./error-messages.js";
+import { escapeHTML } from "./format.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "./operations.js";
+import { PeerStore } from "./peer-store.js";
+import { formatCliPathHTML, formatCliPathPlain, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, parseToggle, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain } from "./session-format.js";
+import { getAvailableBackends } from "./voice.js";
+export class ChannelCommandService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    renderChannels() {
+        return renderChannelsAction(listChannelDescriptors());
+    }
+    renderAgents(agentIds = enabledAgents(this.config)) {
+        return renderAgentsAction(listAgentAdapterDescriptors(), agentIds);
+    }
+    renderPeers() {
+        const peers = new PeerStore().listPublic();
+        if (peers.length === 0) {
+            return {
+                plain: "No NordRelay peers configured.",
+                html: "No NordRelay peers configured.",
+            };
+        }
+        const plain = peers.map((peer) => [
+            `${peer.name} (${peer.id}) ${peer.enabled ? "enabled" : "disabled"}`,
+            `URL: ${peer.url ?? "-"}`,
+            `Node: ${peer.nodeId}`,
+            `Scopes: ${peer.scopes.join(", ") || "-"}`,
+            peer.remoteStatus || peer.lastLatencyMs !== undefined ? `Health: ${peer.remoteStatus ?? "seen"}${peer.lastLatencyMs !== undefined ? ` / ${peer.lastLatencyMs}ms` : ""}${peer.remoteVersion ? ` / v${peer.remoteVersion}` : ""}` : "",
+            Object.keys(peer.workspaceAliases ?? {}).length > 0 ? `Aliases: ${Object.entries(peer.workspaceAliases).map(([alias, workspace]) => `${alias}=${workspace}`).join(", ")}` : "",
+            peer.lastSeenAt ? `Last seen: ${peer.lastSeenAt}` : "",
+            peer.lastError ? `Last error: ${peer.lastError}` : "",
+        ].filter(Boolean).join("\n")).join("\n\n");
+        const html = peers.map((peer) => [
+            `<b>${escapeHTML(peer.name)} (${escapeHTML(peer.id)})</b> <code>${peer.enabled ? "enabled" : "disabled"}</code>`,
+            `<b>URL:</b> <code>${escapeHTML(peer.url ?? "-")}</code>`,
+            `<b>Node:</b> <code>${escapeHTML(peer.nodeId)}</code>`,
+            `<b>Scopes:</b> <code>${escapeHTML(peer.scopes.join(", ") || "-")}</code>`,
+            peer.remoteStatus || peer.lastLatencyMs !== undefined ? `<b>Health:</b> <code>${escapeHTML(`${peer.remoteStatus ?? "seen"}${peer.lastLatencyMs !== undefined ? ` / ${peer.lastLatencyMs}ms` : ""}${peer.remoteVersion ? ` / v${peer.remoteVersion}` : ""}`)}</code>` : "",
+            Object.keys(peer.workspaceAliases ?? {}).length > 0 ? `<b>Aliases:</b> <code>${escapeHTML(Object.entries(peer.workspaceAliases).map(([alias, workspace]) => `${alias}=${workspace}`).join(", "))}</code>` : "",
+            peer.lastSeenAt ? `<b>Last seen:</b> <code>${escapeHTML(peer.lastSeenAt)}</code>` : "",
+            peer.lastError ? `<b>Last error:</b> <code>${escapeHTML(peer.lastError)}</code>` : "",
+        ].filter(Boolean).join("\n")).join("\n\n");
+        return { plain, html };
+    }
+    renderTargetPreference(options) {
+        const argument = options.argument.trim();
+        const peers = new PeerStore().listPublic().filter((peer) => peer.enabled && peer.url);
+        if (argument) {
+            const normalized = argument.toLowerCase();
+            if (normalized === "local") {
+                options.preferencesStore.update(options.contextKey, { targetPeerId: null });
+            }
+            else {
+                const peer = peers.find((candidate) => candidate.id === argument || candidate.name.toLowerCase() === normalized || candidate.nodeId === argument);
+                if (!peer) {
+                    return usageResponse("Unknown peer target. Use /target local or /target <peer-id>.");
+                }
+                options.preferencesStore.update(options.contextKey, { targetPeerId: peer.id });
+            }
+        }
+        const current = options.preferencesStore.get(options.contextKey).targetPeerId;
+        const currentPeer = current ? peers.find((peer) => peer.id === current) : null;
+        const target = currentPeer ? `${currentPeer.name} (${currentPeer.id})` : "local";
+        const available = peers.map((peer) => `${peer.id} ${peer.name}`).join("\n") || "No enabled outbound peers.";
+        return {
+            plain: [`Target: ${target}`, "", "Available peers:", available].join("\n"),
+            html: [`<b>Target:</b> <code>${escapeHTML(target)}</code>`, "", "<b>Available peers:</b>", `<code>${escapeHTML(available)}</code>`].join("\n"),
+        };
+    }
+    async renderLogs(argument) {
+        const logRequest = parseLogsCommand(argument);
+        const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
+            title: request.title,
+            tail: await readFormattedLogTail(logRequest.lines, request.path),
+        })));
+        return renderLogTailsAction(logs);
+    }
+    async renderVersion() {
+        const health = await getConnectorHealth(cliPathOptions(this.config));
+        const state = await readConnectorState();
+        const versions = await getVersionChecks(cliPathOptions(this.config));
+        const plain = [
+            renderVersionCheckPlain(versions.nordrelay),
+            `Runtime status: ${state.status ?? "unknown"}`,
+            formatCliPathPlain("Codex CLI", health.codexCliPath, health.codexCli),
+            renderVersionCheckPlain(versions.codex),
+            formatCliPathPlain("Pi CLI", health.piCliPath, health.piCli),
+            renderVersionCheckPlain(versions.pi),
+            formatCliPathPlain("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckPlain(versions.hermes),
+            formatCliPathPlain("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckPlain(versions.openclaw),
+            formatCliPathPlain("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckPlain(versions.claudeCode),
+        ].join("\n");
+        const html = [
+            renderVersionCheckHTML(versions.nordrelay),
+            `<b>Runtime status:</b> <code>${escapeHTML(state.status ?? "unknown")}</code>`,
+            formatCliPathHTML("Codex CLI", health.codexCliPath, health.codexCli),
+            renderVersionCheckHTML(versions.codex),
+            formatCliPathHTML("Pi CLI", health.piCliPath, health.piCli),
+            renderVersionCheckHTML(versions.pi),
+            formatCliPathHTML("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckHTML(versions.hermes),
+            formatCliPathHTML("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckHTML(versions.openclaw),
+            formatCliPathHTML("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckHTML(versions.claudeCode),
+        ].join("\n");
+        return { plain, html };
+    }
+    renderAuthStatus(status) {
+        const icon = status.authenticated ? "✅" : "❌";
+        return {
+            plain: [
+                `${icon} ${status.label} auth: ${status.authenticated ? "authenticated" : "not authenticated"}`,
+                `Method: ${status.method ?? "-"}`,
+                `Detail: ${status.detail}`,
+            ].join("\n"),
+            html: [
+                `<b>${icon} ${escapeHTML(status.label)} auth:</b> <code>${status.authenticated ? "authenticated" : "not authenticated"}</code>`,
+                `<b>Method:</b> <code>${escapeHTML(status.method ?? "-")}</code>`,
+                `<b>Detail:</b> <code>${escapeHTML(status.detail)}</code>`,
+            ].join("\n"),
+        };
+    }
+    renderAuthActionResult(action, result) {
+        const label = action === "login" ? "Login" : "Logout";
+        const icon = result.success ? "✅" : "❌";
+        return {
+            plain: [`${icon} ${label} ${result.success ? "started" : "failed"}.`, "", result.message].join("\n"),
+            html: [`<b>${icon} ${escapeHTML(label)} ${result.success ? "started" : "failed"}.</b>`, "", `<code>${escapeHTML(result.message)}</code>`].join("\n"),
+        };
+    }
+    renderHostAuthInstruction(label, command, action) {
+        const text = `${label} ${action} is not managed remotely. Run this on the host: ${command}`;
+        return {
+            plain: text,
+            html: `<b>${escapeHTML(label)} ${escapeHTML(action)} is not managed remotely.</b>\nRun this on the host:\n<code>${escapeHTML(command)}</code>`,
+        };
+    }
+    renderProgress(progress, queueLength, busyState, info) {
+        return {
+            plain: renderProgressPlain(progress, queueLength, busyState, info),
+            html: renderProgressHTML(progress, queueLength, busyState, info),
+        };
+    }
+    renderActivity(threadId, events, options) {
+        return renderActivityTimeline(threadId, events, options);
+    }
+    renderAudit(events) {
+        return renderAuditEvents(events);
+    }
+    renderMirrorPreference(options) {
+        if (options.cliMirrorSupported === false) {
+            const text = `CLI mirroring is not supported for ${options.agentLabel ?? "this agent"} yet.`;
+            return { plain: text, html: escapeHTML(text) };
+        }
+        const argument = options.argument.trim();
+        if (argument) {
+            const normalized = argument.toLowerCase();
+            if (!["off", "status", "final", "full"].includes(normalized)) {
+                return usageResponse("Usage: /mirror [off|status|final|full]");
+            }
+            options.preferencesStore.update(options.contextKey, {
+                mirrorMode: parseMirrorMode(argument, this.defaultMirrorMode(options.source)),
+            });
+        }
+        const mode = this.effectiveMirrorMode(options.source, options.contextKey, options.preferencesStore);
+        const minInterval = options.source === "telegram" ? this.config.telegramMirrorMinUpdateMs : this.config.discordMirrorMinUpdateMs;
+        return {
+            plain: [
+                `CLI mirroring: ${mode}`,
+                `Minimum update interval: ${minInterval} ms`,
+                "Modes: off, status, final, full",
+            ].join("\n"),
+            html: [
+                `<b>CLI mirroring:</b> <code>${escapeHTML(mode)}</code>`,
+                `<b>Minimum update interval:</b> <code>${minInterval} ms</code>`,
+                "<b>Modes:</b> <code>off</code>, <code>status</code>, <code>final</code>, <code>full</code>",
+            ].join("\n"),
+        };
+    }
+    renderNotifyPreference(options) {
+        const argument = options.argument.trim();
+        if (argument) {
+            const quietMatch = argument.match(/^quiet\s+(.+)$/i);
+            if (quietMatch) {
+                try {
+                    const quietHours = quietMatch[1].toLowerCase() === "off" ? null : parseQuietHours(quietMatch[1]);
+                    options.preferencesStore.update(options.contextKey, { quietHours });
+                }
+                catch (error) {
+                    const text = `Invalid quiet hours: ${friendlyErrorText(error)}`;
+                    return { plain: text, html: escapeHTML(text) };
+                }
+            }
+            else {
+                const normalized = argument.toLowerCase();
+                if (!["off", "minimal", "all"].includes(normalized)) {
+                    return usageResponse("Usage: /notify [off|minimal|all] or /notify quiet HH-HH");
+                }
+                options.preferencesStore.update(options.contextKey, {
+                    notifyMode: parseNotifyMode(argument, this.defaultNotifyMode(options.source)),
+                });
+            }
+        }
+        const mode = this.effectiveNotifyMode(options.source, options.contextKey, options.preferencesStore);
+        const quietHours = this.effectiveQuietHours(options.source, options.contextKey, options.preferencesStore);
+        return {
+            plain: [
+                `Notifications: ${mode}`,
+                `Quiet hours: ${formatQuietHours(quietHours)}`,
+                `Currently quiet: ${isQuietNow(quietHours) ? "yes" : "no"}`,
+            ].join("\n"),
+            html: [
+                `<b>Notifications:</b> <code>${escapeHTML(mode)}</code>`,
+                `<b>Quiet hours:</b> <code>${escapeHTML(formatQuietHours(quietHours))}</code>`,
+                `<b>Currently quiet:</b> <code>${isQuietNow(quietHours) ? "yes" : "no"}</code>`,
+            ].join("\n"),
+        };
+    }
+    async renderVoicePreference(options) {
+        const argument = options.argument.trim();
+        if (argument) {
+            const parts = argument.split(/\s+/);
+            const key = parts[0]?.toLowerCase();
+            const value = parts.slice(1).join(" ").trim();
+            if (key === "backend" && value) {
+                const normalized = value.toLowerCase();
+                if (!["auto", "parakeet", "faster-whisper", "openai"].includes(normalized)) {
+                    return usageResponse("Usage: /voice backend auto|parakeet|faster-whisper|openai");
+                }
+                options.preferencesStore.update(options.contextKey, { voiceBackend: parseVoiceBackendPreference(value) });
+            }
+            else if (key === "language") {
+                options.preferencesStore.update(options.contextKey, { voiceLanguage: value && value.toLowerCase() !== "auto" ? value : null });
+            }
+            else if (key === "transcribe_only" || key === "transcribe-only") {
+                const enabled = parseToggle(value);
+                if (enabled === undefined) {
+                    return usageResponse("Usage: /voice transcribe_only on|off");
+                }
+                options.preferencesStore.update(options.contextKey, { voiceTranscribeOnly: enabled });
+            }
+            else {
+                return usageResponse("Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|language-code, /voice transcribe_only on|off");
+            }
+        }
+        const backends = await getAvailableBackends().catch(() => []);
+        if (backends.length === 0) {
+            const plain = [
+                "Voice transcription is not available.",
+                "",
+                "Install faster-whisper + ffmpeg, install parakeet-coreml on macOS Apple Silicon, or set OPENAI_API_KEY.",
+                "Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.",
+            ].join("\n");
+            const html = [
+                "<b>Voice transcription is not available.</b>",
+                "",
+                "Install <code>faster-whisper</code> + ffmpeg, install <code>parakeet-coreml</code> on macOS Apple Silicon, or set <code>OPENAI_API_KEY</code>.",
+                "<i>Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.</i>",
+            ].join("\n");
+            return { plain, html };
+        }
+        const prefs = options.preferencesStore.get(options.contextKey);
+        const backendPreference = prefs.voiceBackend ?? this.config.voicePreferredBackend;
+        const language = prefs.voiceLanguage === undefined ? this.config.voiceDefaultLanguage ?? null : prefs.voiceLanguage;
+        const transcribeOnly = prefs.voiceTranscribeOnly ?? this.config.voiceTranscribeOnly;
+        const joined = backends.join(" + ");
+        return {
+            plain: [
+                `Voice backends: ${joined}`,
+                `Preferred backend: ${backendPreference}`,
+                `Language: ${language ?? "auto"}`,
+                `Transcribe only: ${transcribeOnly ? "on" : "off"}`,
+            ].join("\n"),
+            html: [
+                `<b>Voice backends:</b> <code>${escapeHTML(joined)}</code>`,
+                `<b>Preferred backend:</b> <code>${escapeHTML(backendPreference)}</code>`,
+                `<b>Language:</b> <code>${escapeHTML(language ?? "auto")}</code>`,
+                `<b>Transcribe only:</b> <code>${transcribeOnly ? "on" : "off"}</code>`,
+            ].join("\n"),
+        };
+    }
+    renderWorkspaces(info, workspaces) {
+        const unique = [...new Set(workspaces)].filter(Boolean);
+        const rows = unique.length > 0
+            ? unique.map((workspace, index) => `${index + 1}. ${workspace}${workspace === info.workspace ? " (current)" : ""}`)
+            : [`No workspaces found in ${info.agentLabel} state.`];
+        return {
+            plain: [`${info.agentLabel} workspaces:`, ...rows].join("\n"),
+            html: [
+                `<b>${escapeHTML(info.agentLabel)} workspaces:</b>`,
+                ...rows.map((line) => `<code>${escapeHTML(line)}</code>`),
+            ].join("\n"),
+        };
+    }
+    renderHandback(result) {
+        const command = result.command ?? (result.threadId
+            ? `cd ${shellEscape(result.workspace)} && codex resume ${shellEscape(result.threadId)}`
+            : "");
+        if (!result.threadId || !command) {
+            const text = "This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or start a new session.";
+            return { plain: text, html: escapeHTML(text) };
+        }
+        const label = result.label ?? "Agent CLI";
+        return {
+            plain: [
+                `Thread handed back to ${label}.`,
+                "",
+                "Run this in your terminal:",
+                command,
+                "",
+                "Send any message here to start a new NordRelay thread.",
+            ].join("\n"),
+            html: [
+                `<b>Thread handed back to ${escapeHTML(label)}.</b>`,
+                "",
+                "Run this in your terminal:",
+                `<pre>${escapeHTML(command)}</pre>`,
+                "",
+                "Send any message here to start a new NordRelay thread.",
+            ].join("\n"),
+        };
+    }
+    defaultMirrorMode(source) {
+        return source === "telegram" ? this.config.telegramMirrorMode : this.config.discordMirrorMode;
+    }
+    defaultNotifyMode(source) {
+        return source === "telegram" ? this.config.telegramNotifyMode : this.config.discordNotifyMode;
+    }
+    defaultQuietHours(source) {
+        return source === "telegram" ? this.config.telegramQuietHours : this.config.discordQuietHours;
+    }
+    effectiveMirrorMode(source, contextKey, preferencesStore) {
+        return preferencesStore.get(contextKey).mirrorMode ?? this.defaultMirrorMode(source);
+    }
+    effectiveNotifyMode(source, contextKey, preferencesStore) {
+        return preferencesStore.get(contextKey).notifyMode ?? this.defaultNotifyMode(source);
+    }
+    effectiveQuietHours(source, contextKey, preferencesStore) {
+        const prefs = preferencesStore.get(contextKey);
+        return prefs.quietHours === undefined ? this.defaultQuietHours(source) : prefs.quietHours;
+    }
+}
+export function cliPathOptions(config) {
+    return {
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    };
+}
+function shellEscape(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function usageResponse(text) {
+    return { plain: text, html: escapeHTML(text) };
+}

package/dist/channel-mirror-registry.js

@@ -0,0 +1,77 @@
+import { channelIdForContextKey } from "./context-key.js";
+export class ChannelMirrorRegistry {
+    config;
+    promptStore;
+    states = new Map();
+    constructor(config, promptStore) {
+        this.config = config;
+        this.promptStore = promptStore;
+    }
+    activeMirrorsForThread(agentId, threadId, knownContexts, preferences) {
+        const mirrors = [];
+        const seen = new Set();
+        for (const meta of knownContexts) {
+            const metaAgentId = meta.agentId ?? this.config.defaultAgent;
+            if (meta.threadId !== threadId || metaAgentId !== agentId) {
+                continue;
+            }
+            const source = activeSessionSourceForContextKey(meta.contextKey);
+            if (!isMirrorChannelSource(source) || seen.has(meta.contextKey)) {
+                continue;
+            }
+            const mode = this.effectiveMirrorMode(meta.contextKey, source, preferences);
+            if (mode === "off") {
+                this.states.delete(this.stateKey(source, meta.contextKey, agentId, threadId));
+                continue;
+            }
+            seen.add(meta.contextKey);
+            const mirror = {
+                source,
+                contextKey: meta.contextKey,
+                mode,
+                queueLength: this.promptStore.list(meta.contextKey).length,
+                queuePaused: this.promptStore.isPaused(meta.contextKey),
+            };
+            mirrors.push(mirror);
+            this.states.set(this.stateKey(source, meta.contextKey, agentId, threadId), {
+                ...mirror,
+                agentId,
+                threadId,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        return mirrors;
+    }
+    queueLengthForExternalSource(sourceContextKey, mirrors) {
+        return mirrors.reduce((sum, mirror) => sum + mirror.queueLength, this.promptStore.list(sourceContextKey).length);
+    }
+    queuePausedForExternalSource(sourceContextKey, mirrors) {
+        return mirrors.some((mirror) => mirror.queuePaused) || this.promptStore.isPaused(sourceContextKey);
+    }
+    effectiveMirrorMode(contextKey, source, preferences) {
+        const configured = source === "telegram" ? this.config.telegramMirrorMode : this.config.discordMirrorMode;
+        return preferences.get(contextKey).mirrorMode ?? configured;
+    }
+    snapshot() {
+        return [...this.states.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+    }
+    stateKey(source, contextKey, agentId, threadId) {
+        return `${source}:${contextKey}:${agentId}:${threadId}`;
+    }
+}
+export function activeSessionSourceForContextKey(contextKey) {
+    const channelId = channelIdForContextKey(contextKey);
+    if (channelId === "telegram") {
+        return "telegram";
+    }
+    if (channelId === "discord") {
+        return "discord";
+    }
+    if (channelId === "web") {
+        return "web";
+    }
+    return "cli";
+}
+export function isMirrorChannelSource(source) {
+    return source === "telegram" || source === "discord";
+}