@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/telegram-preference-commands.js

@@ -1,8 +1,5 @@
-import { formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
-import { capabilitiesOf, idOf, labelOf, parseToggle, } from "./bot-rendering.js";
-import { friendlyErrorText } from "./error-messages.js";
+import { capabilitiesOf, labelOf, } from "./bot-rendering.js";
 import { escapeHTML } from "./format.js";
-import { getAvailableBackends } from "./voice.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces, renderWorkspacePolicyLine, } from "./workspace-policy.js";
 import { safeReply } from "./telegram-output.js";
 export function registerTelegramPreferenceCommands(options) {
@@ -18,28 +15,15 @@ export function registerTelegramPreferenceCommands(options) {
             return;
         }
         const argument = (ctx.message?.text ?? "").replace(/^\/mirror(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const mode = parseMirrorMode(argument, options.getEffectiveMirrorMode(contextKey));
-            if (!["off", "status", "final", "full"].includes(argument.toLowerCase())) {
-                await safeReply(ctx, escapeHTML("Usage: /mirror [off|status|final|full]"), {
-                    fallbackText: "Usage: /mirror [off|status|final|full]",
-                });
-                return;
-            }
-            options.preferencesStore.update(contextKey, { mirrorMode: mode });
-        }
-        const mode = options.getEffectiveMirrorMode(contextKey);
-        const plain = [
-            `CLI mirroring: ${mode}`,
-            `Minimum update interval: ${options.config.telegramMirrorMinUpdateMs} ms`,
-            "Modes: off, status, final, full",
-        ].join("\n");
-        const html = [
-            `<b>CLI mirroring:</b> <code>${escapeHTML(mode)}</code>`,
-            `<b>Minimum update interval:</b> <code>${options.config.telegramMirrorMinUpdateMs} ms</code>`,
-            "<b>Modes:</b> <code>off</code>, <code>status</code>, <code>final</code>, <code>full</code>",
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const response = options.commandService.renderMirrorPreference({
+            source: "telegram",
+            contextKey,
+            argument,
+            preferencesStore: options.preferencesStore,
+            cliMirrorSupported: capabilitiesOf(session.getInfo()).cliMirror,
+            agentLabel: labelOf(session.getInfo()),
+        });
+        await safeReply(ctx, response.html, { fallbackText: response.plain });
     });
     options.bot.command("notify", async (ctx) => {
         const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
@@ -48,45 +32,13 @@ export function registerTelegramPreferenceCommands(options) {
         }
         const { contextKey } = contextSession;
         const argument = (ctx.message?.text ?? "").replace(/^\/notify(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const quietMatch = argument.match(/^quiet\s+(.+)$/i);
-            if (quietMatch) {
-                let quietHours;
-                try {
-                    quietHours = quietMatch[1].toLowerCase() === "off" ? null : parseQuietHours(quietMatch[1]);
-                }
-                catch (error) {
-                    await safeReply(ctx, escapeHTML(`Invalid quiet hours: ${friendlyErrorText(error)}`), {
-                        fallbackText: `Invalid quiet hours: ${friendlyErrorText(error)}`,
-                    });
-                    return;
-                }
-                options.preferencesStore.update(contextKey, { quietHours });
-            }
-            else {
-                const mode = parseNotifyMode(argument, options.getEffectiveNotifyMode(contextKey));
-                if (!["off", "minimal", "all"].includes(argument.toLowerCase())) {
-                    await safeReply(ctx, escapeHTML("Usage: /notify [off|minimal|all] or /notify quiet HH-HH"), {
-                        fallbackText: "Usage: /notify [off|minimal|all] or /notify quiet HH-HH",
-                    });
-                    return;
-                }
-                options.preferencesStore.update(contextKey, { notifyMode: mode });
-            }
-        }
-        const mode = options.getEffectiveNotifyMode(contextKey);
-        const quietHours = options.getEffectiveQuietHours(contextKey);
-        const plain = [
-            `Notifications: ${mode}`,
-            `Quiet hours: ${formatQuietHours(quietHours)}`,
-            `Currently quiet: ${isQuietNow(quietHours) ? "yes" : "no"}`,
-        ].join("\n");
-        const 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");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const response = options.commandService.renderNotifyPreference({
+            source: "telegram",
+            contextKey,
+            argument,
+            preferencesStore: options.preferencesStore,
+        });
+        await safeReply(ctx, response.html, { fallbackText: response.plain });
     });
     options.bot.command("workspaces", async (ctx) => {
         const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
@@ -131,68 +83,12 @@ export function registerTelegramPreferenceCommands(options) {
         }
         const { contextKey } = contextSession;
         const argument = (ctx.message?.text ?? "").replace(/^\/voice(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const parts = argument.split(/\s+/);
-            const key = parts[0]?.toLowerCase();
-            const value = parts.slice(1).join(" ").trim();
-            if (key === "backend" && value) {
-                options.preferencesStore.update(contextKey, { voiceBackend: parseVoiceBackendPreference(value) });
-            }
-            else if (key === "language") {
-                options.preferencesStore.update(contextKey, { voiceLanguage: value && value.toLowerCase() !== "auto" ? value : null });
-            }
-            else if (key === "transcribe_only" || key === "transcribe-only") {
-                const enabled = parseToggle(value);
-                if (enabled === undefined) {
-                    await safeReply(ctx, escapeHTML("Usage: /voice transcribe_only on|off"), {
-                        fallbackText: "Usage: /voice transcribe_only on|off",
-                    });
-                    return;
-                }
-                options.preferencesStore.update(contextKey, { voiceTranscribeOnly: enabled });
-            }
-            else {
-                await safeReply(ctx, escapeHTML("Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|<code>, /voice transcribe_only on|off"), {
-                    fallbackText: "Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|<code>, /voice transcribe_only on|off",
-                });
-                return;
-            }
-        }
-        const backends = await getAvailableBackends().catch(() => []);
-        if (backends.length === 0) {
-            await safeReply(ctx, [
-                "<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"), {
-                fallbackText: [
-                    "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"),
-            });
-            return;
-        }
-        const joined = backends.join(" + ");
-        const backendPreference = options.getEffectiveVoiceBackend(contextKey);
-        const language = options.getEffectiveVoiceLanguage(contextKey);
-        const transcribeOnly = options.isVoiceTranscribeOnly(contextKey);
-        const plain = [
-            `Voice backends: ${joined}`,
-            `Preferred backend: ${backendPreference}`,
-            `Language: ${language ?? "auto"}`,
-            `Transcribe only: ${transcribeOnly ? "on" : "off"}`,
-        ].join("\n");
-        const 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");
-        await safeReply(ctx, html, {
-            fallbackText: plain,
+        const response = await options.commandService.renderVoicePreference({
+            source: "telegram",
+            contextKey,
+            argument,
+            preferencesStore: options.preferencesStore,
         });
+        await safeReply(ctx, response.html, { fallbackText: response.plain });
     });
 }

package/dist/telegram-queue-commands.js

@@ -48,12 +48,21 @@ export function registerTelegramQueueCommands(options) {
             const minutes = Math.min(7 * 24 * 60, Math.max(1, Number(laterMatch[1])));
             const text = laterMatch[2].trim();
             const notBefore = Date.now() + minutes * 60 * 1000;
-            const item = promptStore.enqueue(contextKey, toPromptEnvelope(text), { notBefore });
+            const item = promptStore.enqueue(contextKey, {
+                ...toPromptEnvelope(text),
+                activityActor: options.activityActor?.(ctx),
+            }, { notBefore });
             const message = `Queued prompt ${item.id} for ${formatLocalDateTime(new Date(notBefore))}.`;
             await safeReply(ctx, escapeHTML(message), {
                 fallbackText: message,
                 replyMarkup: createQueuedPromptCancelKeyboard(contextKey, item.id),
             });
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "queued",
+                type: "prompt_queued",
+                prompt: item.description,
+                detail: `Queued prompt ${item.id} for ${formatLocalDateTime(new Date(notBefore))}.`,
+            });
             options.auditContext(ctx, contextKey, session, {
                 action: "prompt_queued",
                 status: "ok",
@@ -81,12 +90,22 @@ export function registerTelegramQueueCommands(options) {
             const message = `Queue paused. ${promptStore.list(contextKey).length} queued.`;
             await safeReply(ctx, escapeHTML(message), { fallbackText: message });
             await options.updateQueueStatusMessage(contextKey, message);
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "info",
+                type: "queue_pause",
+                detail: message,
+            });
             return;
         }
         if (/^resume$/i.test(argument)) {
             promptStore.resume(contextKey);
             const message = `Queue resumed. ${promptStore.list(contextKey).length} queued.`;
             await safeReply(ctx, escapeHTML(message), { fallbackText: message });
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "info",
+                type: "queue_resume",
+                detail: message,
+            });
             if (chatId) {
                 void options.drainQueuedPrompts(ctx, contextKey, chatId, session).catch((error) => {
                     console.error("Failed to drain queue after resume:", error);
@@ -110,6 +129,12 @@ export function registerTelegramQueueCommands(options) {
             }
             const message = `Moved queued prompt ${item.id} ${direction}.`;
             await safeReply(ctx, escapeHTML(message), { fallbackText: message });
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "info",
+                type: "queue_move",
+                prompt: item.description,
+                detail: message,
+            });
             return;
         }
         const runMatch = argument.match(/^run\s+([a-z0-9]+)$/i);
@@ -123,6 +148,12 @@ export function registerTelegramQueueCommands(options) {
             }
             promptStore.enqueueFront(contextKey, item);
             promptStore.resume(contextKey);
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "info",
+                type: "queue_run",
+                prompt: item.description,
+                detail: `Queued prompt ${item.id} moved to next.`,
+            });
             if (!chatId) {
                 return;
             }
@@ -159,9 +190,15 @@ export function registerTelegramQueueCommands(options) {
         if (!contextSession) {
             return;
         }
-        const count = promptStore.clear(contextSession.contextKey);
+        const { contextKey, session } = contextSession;
+        const count = promptStore.clear(contextKey);
         const message = `Cleared ${count} queued prompt${count === 1 ? "" : "s"}.`;
         await safeReply(ctx, escapeHTML(message), { fallbackText: message });
+        options.appendActivity?.(ctx, contextKey, session, {
+            status: "info",
+            type: "queue_clear",
+            detail: message,
+        });
     });
     bot.command("cancel", async (ctx) => {
         const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
@@ -176,7 +213,8 @@ export function registerTelegramQueueCommands(options) {
             });
             return;
         }
-        const removed = promptStore.remove(contextSession.contextKey, id);
+        const { contextKey, session } = contextSession;
+        const removed = promptStore.remove(contextKey, id);
         if (!removed) {
             await safeReply(ctx, escapeHTML(`No queued prompt found with id ${id}.`), {
                 fallbackText: `No queued prompt found with id ${id}.`,
@@ -186,6 +224,12 @@ export function registerTelegramQueueCommands(options) {
         await safeReply(ctx, escapeHTML(`Cancelled queued prompt ${removed.id}.`), {
             fallbackText: `Cancelled queued prompt ${removed.id}.`,
         });
+        options.appendActivity?.(ctx, contextKey, session, {
+            status: "aborted",
+            type: "queue_cancel",
+            prompt: removed.description,
+            detail: `Cancelled queued prompt ${removed.id}.`,
+        });
     });
     bot.callbackQuery(/^queue_(cancel|remove|top|up|down|run):(-?\d+(?::\d+)?):([a-z0-9]+)$/, async (ctx) => {
         const action = ctx.match?.[1];
@@ -209,6 +253,15 @@ export function registerTelegramQueueCommands(options) {
                     ? promptStore.moveUp(contextKey, queueId)
                     : promptStore.moveDown(contextKey, queueId);
             await ctx.answerCallbackQuery({ text: item ? `Moved ${queueId} ${action}.` : "Queued prompt not found." });
+            const session = item ? options.getSession(contextKey) : undefined;
+            if (item && session) {
+                options.appendActivity?.(ctx, contextKey, session, {
+                    status: "info",
+                    type: "queue_move",
+                    prompt: item.description,
+                    detail: `Moved queued prompt ${item.id} ${action}.`,
+                });
+            }
             if (chatId && messageId) {
                 const rendered = renderQueueList(promptStore, contextKey, promptStore.list(contextKey));
                 await safeEditMessage(bot, chatId, messageId, rendered.html, {
@@ -227,6 +280,15 @@ export function registerTelegramQueueCommands(options) {
             promptStore.enqueueFront(contextKey, item);
             promptStore.resume(contextKey);
             await ctx.answerCallbackQuery({ text: `Queued prompt ${queueId} moved to next.` });
+            const session = options.getSession(contextKey);
+            if (session) {
+                options.appendActivity?.(ctx, contextKey, session, {
+                    status: "info",
+                    type: "queue_run",
+                    prompt: item.description,
+                    detail: `Queued prompt ${item.id} moved to next.`,
+                });
+            }
             if (chatId && messageId) {
                 const rendered = renderQueueList(promptStore, contextKey, promptStore.list(contextKey));
                 await safeEditMessage(bot, chatId, messageId, rendered.html, {
@@ -234,7 +296,6 @@ export function registerTelegramQueueCommands(options) {
                     replyMarkup: rendered.keyboard,
                 });
             }
-            const session = options.getSession(contextKey);
             if (chatId && session && !options.getBusyReason(contextKey).busy) {
                 void options.drainQueuedPrompts(ctx, contextKey, chatId, session).catch((error) => {
                     console.error("Failed to drain queue after run-now callback:", error);
@@ -262,6 +323,15 @@ export function registerTelegramQueueCommands(options) {
         }
         const message = `Cancelled queued prompt ${removed.id}.`;
         await ctx.answerCallbackQuery({ text: message });
+        const session = options.getSession(contextKey);
+        if (session) {
+            options.appendActivity?.(ctx, contextKey, session, {
+                status: "aborted",
+                type: "queue_cancel",
+                prompt: removed.description,
+                detail: message,
+            });
+        }
         if (!chatId || !messageId) {
             return;
         }

package/dist/telegram-support-command.js

@@ -26,6 +26,13 @@ export function registerTelegramSupportCommands(options) {
                 action: "command",
                 status: "ok",
                 contextKey,
+                actor: {
+                    channel: "telegram",
+                    id: ctx.from?.id !== undefined ? `telegram:${ctx.from.id}` : undefined,
+                    label: ctx.from?.username || ctx.from?.first_name || (ctx.from?.id !== undefined ? String(ctx.from.id) : undefined),
+                    username: ctx.from?.username,
+                    channelUserId: ctx.from?.id !== undefined ? String(ctx.from.id) : undefined,
+                },
                 actorId: ctx.from?.id,
                 actorRole: options.getUserRole(ctx),
                 description: "export diagnostics bundle",

package/dist/telegram-update-commands.js

@@ -33,12 +33,26 @@ export function registerTelegramUpdateCommands(deps) {
         }
         if (subcommand === "cancel" && tokens[1]) {
             const job = agentUpdates.cancel(tokens[1]);
+            deps.appendActivity?.(ctx, {
+                status: "aborted",
+                type: "agent_update_cancel_requested",
+                threadId: null,
+                agentId: job.agentId,
+                detail: `${job.agentLabel} ${job.operation} cancellation requested.`,
+            });
             const rendered = renderAgentUpdateJobAction(job);
             await replyChannelAction(ctx, rendered);
             return;
         }
         if ((subcommand === "input" || subcommand === "send") && tokens[1] && tokens.slice(2).join(" ").trim()) {
             const job = agentUpdates.sendInput(tokens[1], tokens.slice(2).join(" "));
+            deps.appendActivity?.(ctx, {
+                status: "info",
+                type: "agent_update_input_sent",
+                threadId: null,
+                agentId: job.agentId,
+                detail: `Input sent to ${job.agentLabel} ${job.operation}.`,
+            });
             const rendered = renderAgentUpdateJobAction(job);
             await replyChannelAction(ctx, rendered);
             return;
@@ -54,6 +68,12 @@ export function registerTelegramUpdateCommands(deps) {
             return;
         }
         const update = spawnSelfUpdate();
+        deps.appendActivity?.(ctx, {
+            status: "info",
+            type: "update_started",
+            threadId: null,
+            detail: `${update.method}: ${update.summary}`,
+        });
         const rendered = renderSelfUpdateStartedAction(update);
         await replyChannelAction(ctx, rendered);
     });
@@ -87,6 +107,13 @@ export function registerTelegramUpdateCommands(deps) {
             return;
         }
         const job = agentUpdates.cancel(id);
+        deps.appendActivity?.(ctx, {
+            status: "aborted",
+            type: "agent_update_cancel_requested",
+            threadId: null,
+            agentId: job.agentId,
+            detail: `${job.agentLabel} ${job.operation} cancellation requested.`,
+        });
         const rendered = renderAgentUpdateJobAction(job);
         await replyChannelAction(ctx, rendered);
     });