@nordbyte/nordrelay 0.4.1 → 0.5.1

package/dist/telegram-general-commands.js

@@ -0,0 +1,52 @@
+import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { enabledAgents } from "./agent-factory.js";
+import { renderWelcomeFirstTime, renderWelcomeReturning, renderHelpMessage, } from "./bot-ui.js";
+import { authHelpText, capabilitiesOf, labelOf, } from "./bot-rendering.js";
+import { renderAgentsAction, renderChannelsAction, } from "./channel-actions.js";
+import { listChannelDescriptors } from "./channel-adapter.js";
+import { escapeHTML } from "./format.js";
+import { spawnConnectorRestart } from "./operations.js";
+import { renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
+import { safeReply } from "./telegram-output.js";
+export function registerTelegramGeneralCommands(options) {
+    options.bot.command("start", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const { contextKey, session } = contextSession;
+        const info = session.getInfo();
+        const authStatus = capabilitiesOf(info).auth ? await options.checkAgentAuthStatus(info) : null;
+        const authWarning = authStatus && !authStatus.authenticated
+            ? [`${labelOf(info)} is not authenticated.`, authStatus.detail, authHelpText(info)].filter(Boolean).join(" ")
+            : undefined;
+        const isReturning = options.registry.hasMetadata(contextKey);
+        if (isReturning) {
+            const welcome = renderWelcomeReturning(renderSessionInfoHTML(info), renderSessionInfoPlain(info), options.isTopicContext(contextKey), authWarning);
+            await safeReply(ctx, welcome.html, { fallbackText: welcome.plain });
+            return;
+        }
+        const welcome = renderWelcomeFirstTime(authWarning);
+        await safeReply(ctx, [welcome.html, "", renderLaunchSummaryHTML(info)].join("\n"), {
+            fallbackText: [welcome.plain, "", renderLaunchSummaryPlain(info)].join("\n"),
+        });
+    });
+    options.bot.command("help", async (ctx) => {
+        const help = renderHelpMessage();
+        await safeReply(ctx, help.html, { fallbackText: help.plain });
+    });
+    options.bot.command("channels", async (ctx) => {
+        await options.replyChannelAction(ctx, renderChannelsAction(listChannelDescriptors()));
+    });
+    options.bot.command("agents", async (ctx) => {
+        await options.replyChannelAction(ctx, renderAgentsAction(listAgentAdapterDescriptors(), enabledAgents(options.config)));
+    });
+    options.bot.command("restart", async (ctx) => {
+        await safeReply(ctx, escapeHTML("Restarting connector..."), {
+            fallbackText: "Restarting connector...",
+        });
+        setTimeout(() => {
+            spawnConnectorRestart();
+        }, 300);
+    });
+}

package/dist/telegram-operational-commands.js

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+import { unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { InputFile } from "grammy";
+import { getAgentActivityLog } from "./agent-activity.js";
+import { capabilitiesOf, filterActivityEvents, formatLocalDateTime, formatLockOwner, formatTelegramName, labelOf, parseActivityOptions, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, renderSessionLocks, } from "./bot-rendering.js";
+import { escapeHTML } from "./format.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain } from "./session-format.js";
+import { chatBucket, safeReply } from "./telegram-output.js";
+import { telegramRateLimiter } from "./telegram-rate-limit.js";
+export function registerTelegramOperationalCommands(options) {
+    const { bot, config, promptStore, auditLog, lockStore, turnProgress, } = options;
+    bot.command(["tasks", "progress"], async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const progress = turnProgress.get(contextSession.contextKey);
+        const queue = promptStore.list(contextSession.contextKey);
+        const externalActivity = options.getExternalActivity(contextSession.session);
+        const busyState = {
+            ...options.getBusyState(contextSession.contextKey),
+            external: Boolean(externalActivity?.active),
+        };
+        const info = contextSession.session.getInfo();
+        const plain = renderProgressPlain(progress, queue.length, busyState, info);
+        const html = renderProgressHTML(progress, queue.length, busyState, info);
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    bot.command("activity", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const info = contextSession.session.getInfo();
+        if (!capabilitiesOf(info).activityLog) {
+            const text = `${labelOf(info)} activity timelines are not available yet.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const threadId = contextSession.session.getActiveThreadId();
+        if (!threadId) {
+            await safeReply(ctx, escapeHTML("No active thread yet."), { fallbackText: "No active thread yet." });
+            return;
+        }
+        const activityOptions = parseActivityOptions((ctx.message?.text ?? "").replace(/^\/activity(?:@\w+)?\s*/i, "").trim());
+        const events = filterActivityEvents(getAgentActivityLog(contextSession.session, config, activityOptions.exportFile ? 200 : activityOptions.limit), activityOptions);
+        const rendered = renderActivityTimeline(threadId, events, activityOptions);
+        if (activityOptions.exportFile && ctx.chat) {
+            const exportPath = path.join(tmpdir(), `nordrelay-activity-${threadId}-${randomUUID().slice(0, 8)}.txt`);
+            await writeFile(exportPath, rendered.plain, "utf8");
+            try {
+                await telegramRateLimiter.run(chatBucket(ctx.chat.id), "sendDocument", () => ctx.api.sendDocument(ctx.chat.id, new InputFile(exportPath, path.basename(exportPath)), {
+                    ...(ctx.message?.message_thread_id ? { message_thread_id: ctx.message.message_thread_id } : {}),
+                }));
+            }
+            finally {
+                await unlink(exportPath).catch(() => { });
+            }
+            return;
+        }
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.command("audit", async (ctx) => {
+        const rawText = ctx.message?.text ?? "";
+        const limitArg = rawText.replace(/^\/audit(?:@\w+)?\s*/i, "").trim();
+        const limit = /^\d+$/.test(limitArg) ? Number(limitArg) : 20;
+        const events = auditLog.list(limit);
+        const rendered = renderAuditEvents(events);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.command("lock", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession || !ctx.from) {
+            return;
+        }
+        const { contextKey, session } = contextSession;
+        const existing = lockStore.get(contextKey);
+        if (existing && existing.ownerId !== ctx.from.id && !options.isAdminUser(ctx)) {
+            const text = `Session is already locked by ${formatLockOwner(existing)}.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const lock = lockStore.set(contextKey, ctx.from.id, formatTelegramName(ctx), config.sessionLockTtlMs);
+        options.auditContext(ctx, contextKey, session, {
+            action: "lock_updated",
+            status: "ok",
+            detail: `locked by ${lock.ownerId}`,
+        });
+        const text = `Session locked by ${formatLockOwner(lock)}${lock.expiresAt ? ` until ${formatLocalDateTime(new Date(lock.expiresAt))}` : ""}.`;
+        await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+    });
+    bot.command("unlock", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const { contextKey, session } = contextSession;
+        const lock = lockStore.get(contextKey);
+        if (lock && lock.ownerId !== ctx.from?.id && !options.isAdminUser(ctx)) {
+            const text = `Only ${formatLockOwner(lock)} or an admin can unlock this session.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const removed = lockStore.clear(contextKey);
+        options.auditContext(ctx, contextKey, session, {
+            action: "lock_updated",
+            status: "ok",
+            detail: removed ? "unlocked" : "no lock",
+        });
+        const text = removed ? "Session lock released." : "No active lock for this session.";
+        await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+    });
+    bot.command("locks", async (ctx) => {
+        const locks = lockStore.list();
+        const rendered = renderSessionLocks(locks);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.command("sync", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const sessionInfo = contextSession.session.getInfo();
+        if (!capabilitiesOf(sessionInfo).externalActivity) {
+            const plain = [`${labelOf(sessionInfo)} has no external CLI state watcher to sync.`, "", renderSessionInfoPlain(sessionInfo)].join("\n");
+            const html = [`<b>${escapeHTML(labelOf(sessionInfo))} has no external CLI state watcher to sync.</b>`, "", renderSessionInfoHTML(sessionInfo)].join("\n");
+            await safeReply(ctx, html, { fallbackText: plain });
+            return;
+        }
+        const result = contextSession.session.syncFromAgentState({ reattach: true });
+        if (result.changed) {
+            options.updateSessionMetadata(contextSession.contextKey, contextSession.session);
+        }
+        const fields = result.changedFields.length > 0 ? result.changedFields.join(", ") : "none";
+        const plain = [
+            result.changed ? `Synced from ${labelOf(sessionInfo)} state.` : "Already in sync.",
+            `Changed: ${fields}`,
+            `Reattached: ${result.reattached ? "yes" : "no"}`,
+            "",
+            renderSessionInfoPlain(result.info),
+        ].join("\n");
+        const html = [
+            result.changed ? `<b>Synced from ${escapeHTML(labelOf(sessionInfo))} state.</b>` : "<b>Already in sync.</b>",
+            `<b>Changed:</b> <code>${escapeHTML(fields)}</code>`,
+            `<b>Reattached:</b> <code>${result.reattached ? "yes" : "no"}</code>`,
+            "",
+            renderSessionInfoHTML(result.info),
+        ].join("\n");
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+}

package/dist/telegram-output.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { Bot, InlineKeyboard } from "grammy";
+import { formatTelegramHTML } from "./format.js";
+import { redactText } from "./redaction.js";
+import { telegramRateLimiter } from "./telegram-rate-limit.js";
+const TELEGRAM_MESSAGE_LIMIT = 4000;
+const FORMATTED_CHUNK_TARGET = 3000;
+const MAX_AUDIO_FILE_SIZE = 25 * 1024 * 1024;
+export async function safeReply(ctx, text, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId) {
+        return;
+    }
+    const parseMode = options.parseMode !== undefined ? options.parseMode : "HTML";
+    const messageThreadId = options.messageThreadId ?? ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
+    const chunks = splitTelegramText(redactText(text));
+    const fallbackChunks = options.fallbackText ? splitTelegramText(redactText(options.fallbackText)) : [];
+    for (const [index, chunk] of chunks.entries()) {
+        await sendTextMessage(ctx.api, chatId, chunk, {
+            parseMode,
+            fallbackText: fallbackChunks[index] ?? chunk,
+            replyMarkup: index === 0 ? options.replyMarkup : undefined,
+            messageThreadId,
+        });
+    }
+}
+export async function sendTextMessage(api, chatId, text, options = {}) {
+    const parseMode = Object.prototype.hasOwnProperty.call(options, "parseMode") ? options.parseMode : "HTML";
+    const safeText = redactText(text);
+    const safeFallbackText = options.fallbackText === undefined ? undefined : redactText(options.fallbackText);
+    const bucket = chatBucket(chatId);
+    try {
+        return await telegramRateLimiter.run(bucket, "sendMessage", () => api.sendMessage(chatId, safeText, {
+            ...(parseMode ? { parse_mode: parseMode } : {}),
+            ...(options.messageThreadId ? { message_thread_id: options.messageThreadId } : {}),
+            reply_markup: options.replyMarkup,
+        }));
+    }
+    catch (error) {
+        if (parseMode && safeFallbackText !== undefined && isTelegramParseError(error)) {
+            return await telegramRateLimiter.run(bucket, "sendMessage", () => api.sendMessage(chatId, safeFallbackText, {
+                ...(options.messageThreadId ? { message_thread_id: options.messageThreadId } : {}),
+                reply_markup: options.replyMarkup,
+            }));
+        }
+        throw error;
+    }
+}
+export async function safeEditMessage(bot, chatId, messageId, text, options = {}) {
+    const parseMode = Object.prototype.hasOwnProperty.call(options, "parseMode") ? options.parseMode : "HTML";
+    const safeText = redactText(text);
+    const safeFallbackText = options.fallbackText === undefined ? undefined : redactText(options.fallbackText);
+    const bucket = `${chatBucket(chatId)}:${messageId}`;
+    try {
+        await telegramRateLimiter.run(bucket, "editMessageText", () => bot.api.editMessageText(chatId, messageId, safeText, {
+            ...(parseMode ? { parse_mode: parseMode } : {}),
+            reply_markup: options.replyMarkup,
+        }));
+    }
+    catch (error) {
+        if (isMessageNotModifiedError(error)) {
+            return;
+        }
+        if (parseMode && safeFallbackText !== undefined && isTelegramParseError(error)) {
+            await telegramRateLimiter.run(bucket, "editMessageText", () => bot.api.editMessageText(chatId, messageId, safeFallbackText, {
+                reply_markup: options.replyMarkup,
+            }));
+            return;
+        }
+        throw error;
+    }
+}
+export async function safeEditReplyMarkup(bot, chatId, messageId, replyMarkup) {
+    try {
+        await telegramRateLimiter.run(`${chatBucket(chatId)}:${messageId}`, "editMessageReplyMarkup", () => bot.api.editMessageReplyMarkup(chatId, messageId, {
+            reply_markup: replyMarkup ?? new InlineKeyboard(),
+        }));
+    }
+    catch (error) {
+        if (!isMessageNotModifiedError(error)) {
+            throw error;
+        }
+    }
+}
+export async function sendChatActionSafe(api, chatId, action, messageThreadId) {
+    await telegramRateLimiter.run(chatBucket(chatId), "sendChatAction", () => api.sendChatAction(chatId, action, {
+        ...(messageThreadId ? { message_thread_id: messageThreadId } : {}),
+    }));
+}
+export function chatBucket(chatId) {
+    return `chat:${String(chatId)}`;
+}
+export async function downloadTelegramFile(api, token, fileId, maxBytes = MAX_AUDIO_FILE_SIZE) {
+    const file = await api.getFile(fileId);
+    if (!file.file_path) {
+        throw new Error("Telegram did not return a file path");
+    }
+    if (file.file_size && file.file_size > maxBytes) {
+        throw new Error(`Telegram file too large (${Math.round(file.file_size / 1024 / 1024)} MB, max ${Math.round(maxBytes / 1024 / 1024)} MB)`);
+    }
+    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download Telegram file: ${response.status}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const extension = path.extname(file.file_path) || ".bin";
+    const tempPath = path.join(tmpdir(), `nordrelay-file-${randomUUID()}${extension}`);
+    await writeFile(tempPath, buffer);
+    return tempPath;
+}
+export function splitMarkdownForTelegram(markdown) {
+    if (!markdown) {
+        return [];
+    }
+    const chunks = [];
+    let remaining = markdown;
+    while (remaining) {
+        const maxLength = Math.min(remaining.length, FORMATTED_CHUNK_TARGET);
+        const initialCut = findPreferredSplitIndex(remaining, maxLength);
+        const candidate = remaining.slice(0, initialCut) || remaining.slice(0, 1);
+        const rendered = renderMarkdownChunkWithinLimit(candidate);
+        chunks.push(rendered);
+        remaining = remaining.slice(rendered.sourceText.length).trimStart();
+    }
+    return chunks;
+}
+export function renderMarkdownChunkWithinLimit(markdown) {
+    if (!markdown) {
+        return {
+            text: "",
+            fallbackText: "",
+            parseMode: "HTML",
+            sourceText: "",
+        };
+    }
+    let sourceText = markdown;
+    let rendered = formatMarkdownMessage(sourceText);
+    while (rendered.text.length > TELEGRAM_MESSAGE_LIMIT && sourceText.length > 1) {
+        const nextLength = Math.max(1, sourceText.length - Math.max(100, Math.ceil(sourceText.length * 0.1)));
+        sourceText = sourceText.slice(0, nextLength).trimEnd() || sourceText.slice(0, nextLength);
+        rendered = formatMarkdownMessage(sourceText);
+    }
+    return {
+        ...rendered,
+        sourceText,
+    };
+}
+export function isMessageNotModifiedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("message is not modified");
+}
+function splitTelegramText(text) {
+    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > TELEGRAM_MESSAGE_LIMIT) {
+        let cut = remaining.lastIndexOf("\n", TELEGRAM_MESSAGE_LIMIT);
+        if (cut < TELEGRAM_MESSAGE_LIMIT * 0.5) {
+            cut = remaining.lastIndexOf(" ", TELEGRAM_MESSAGE_LIMIT);
+        }
+        if (cut < TELEGRAM_MESSAGE_LIMIT * 0.5) {
+            cut = TELEGRAM_MESSAGE_LIMIT;
+        }
+        chunks.push(remaining.slice(0, cut).trimEnd());
+        remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining) {
+        chunks.push(remaining);
+    }
+    return chunks.length > 0 ? chunks : [""];
+}
+function formatMarkdownMessage(markdown) {
+    try {
+        return {
+            text: formatTelegramHTML(markdown),
+            fallbackText: markdown,
+            parseMode: "HTML",
+        };
+    }
+    catch (error) {
+        console.error("Failed to format Telegram HTML, falling back to plain text", error);
+        return {
+            text: markdown,
+            fallbackText: markdown,
+            parseMode: undefined,
+        };
+    }
+}
+function findPreferredSplitIndex(text, maxLength) {
+    if (text.length <= maxLength) {
+        return Math.max(1, text.length);
+    }
+    const newlineIndex = text.lastIndexOf("\n", maxLength);
+    if (newlineIndex >= maxLength * 0.5) {
+        return Math.max(1, newlineIndex);
+    }
+    const spaceIndex = text.lastIndexOf(" ", maxLength);
+    if (spaceIndex >= maxLength * 0.5) {
+        return Math.max(1, spaceIndex);
+    }
+    return Math.max(1, maxLength);
+}
+function isTelegramParseError(error) {
+    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    return (message.includes("can't parse entities") ||
+        message.includes("unsupported start tag") ||
+        message.includes("unexpected end tag") ||
+        message.includes("entity name") ||
+        message.includes("parse entities"));
+}

package/dist/telegram-preference-commands.js

@@ -0,0 +1,198 @@
+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 { 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) {
+    options.bot.command("mirror", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const { contextKey, session } = contextSession;
+        if (!capabilitiesOf(session.getInfo()).cliMirror) {
+            const text = `CLI mirroring is not supported for ${labelOf(session.getInfo())} yet.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            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 });
+    });
+    options.bot.command("notify", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        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 });
+    });
+    options.bot.command("workspaces", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const { session } = contextSession;
+        const agentName = labelOf(session.getInfo());
+        const workspaces = filterAllowedWorkspaces(session.listWorkspaces(), options.config);
+        const currentWorkspace = session.getInfo().workspace;
+        const lines = workspaces.slice(0, 20).map((workspace, index) => {
+            const prefix = workspace === currentWorkspace ? "*" : `${index + 1}.`;
+            const policy = renderWorkspacePolicyLine(workspace, options.config);
+            return `${prefix} ${workspace}${policy ? ` (${policy})` : ""}`;
+        });
+        const currentPolicy = evaluateWorkspacePolicy(currentWorkspace, options.config);
+        const header = [
+            "Workspaces:",
+            `Current: ${currentWorkspace}`,
+            currentPolicy.warning ? `Current warning: ${currentPolicy.warning}` : undefined,
+            options.config.workspaceAllowedRoots.length > 0 ? `Allowed roots: ${options.config.workspaceAllowedRoots.join(", ")}` : "Allowed roots: unrestricted",
+            "",
+        ].filter((line) => Boolean(line));
+        const plain = [...header, ...(lines.length > 0 ? lines : [`No workspaces found in ${agentName} state.`])].join("\n");
+        const html = [
+            "<b>Workspaces:</b>",
+            `<b>Current:</b> <code>${escapeHTML(currentWorkspace)}</code>`,
+            currentPolicy.warning ? `<b>Current warning:</b> <code>${escapeHTML(currentPolicy.warning)}</code>` : undefined,
+            `<b>Allowed roots:</b> <code>${escapeHTML(options.config.workspaceAllowedRoots.length > 0 ? options.config.workspaceAllowedRoots.join(", ") : "unrestricted")}</code>`,
+            "",
+            ...(lines.length > 0 ? lines.map((line) => `<code>${escapeHTML(line)}</code>`) : [`<code>No workspaces found in ${escapeHTML(agentName)} state.</code>`]),
+        ].filter((line) => Boolean(line)).join("\n");
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    options.bot.command("voice", async (ctx) => {
+        if (!ctx.chat) {
+            return;
+        }
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        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,
+        });
+    });
+}