@nordbyte/nordrelay 0.4.1 → 0.5.1

package/dist/telegram-agent-commands.js

@@ -0,0 +1,212 @@
+import { InlineKeyboard } from "grammy";
+import { agentLabel, } from "./agent.js";
+import { enabledAgents } from "./agent-factory.js";
+import { capabilitiesOf, idOf, labelOf, } from "./bot-rendering.js";
+import { checkAuthStatus } from "./codex-auth.js";
+import { contextKeyFromCtx } from "./context-key.js";
+import { friendlyErrorText } from "./error-messages.js";
+import { escapeHTML } from "./format.js";
+import { redactText } from "./redaction.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
+import { safeEditMessage, safeReply, } from "./telegram-output.js";
+export function registerTelegramAgentCommands(options) {
+    options.bot.command("agent", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            return;
+        }
+        const { contextKey, session } = contextSession;
+        if (options.isBusy(contextKey)) {
+            await safeReply(ctx, escapeHTML("Cannot switch agent while a prompt is running."), {
+                fallbackText: "Cannot switch agent while a prompt is running.",
+            });
+            return;
+        }
+        const availableAgents = enabledAgents(options.config);
+        const currentAgent = idOf(session.getInfo());
+        if (availableAgents.length <= 1) {
+            const only = agentLabel(availableAgents[0] ?? currentAgent);
+            await safeReply(ctx, `<b>Current agent:</b> <code>${escapeHTML(only)}</code>\nNo other agents are enabled.`, {
+                fallbackText: `Current agent: ${only}\nNo other agents are enabled.`,
+            });
+            return;
+        }
+        options.pendingAgentPicks.set(contextKey, availableAgents);
+        const keyboard = new InlineKeyboard();
+        for (const availableAgent of availableAgents) {
+            keyboard.text(`${agentLabel(availableAgent)}${availableAgent === currentAgent ? " ✓" : ""}`, `agent_${availableAgent}`).row();
+        }
+        await safeReply(ctx, `<b>Current agent:</b> <code>${escapeHTML(agentLabel(currentAgent))}</code>\nSelect agent for this Telegram context:`, {
+            fallbackText: `Current agent: ${agentLabel(currentAgent)}\nSelect agent for this Telegram context:`,
+            replyMarkup: keyboard,
+        });
+    });
+    options.bot.command("auth", async (ctx) => {
+        if (!ctx.chat) {
+            return;
+        }
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        const info = contextSession?.session.getInfo();
+        if (info && !capabilitiesOf(info).auth) {
+            const text = `${labelOf(info)} uses its local CLI authentication. Run its login flow on the host if needed.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const authStatus = info ? await options.checkAgentAuthStatus(info) : await checkAuthStatus(options.config.codexApiKey);
+        const icon = authStatus.authenticated ? "✅" : "❌";
+        const html = [
+            `<b>${icon} Auth status:</b> ${authStatus.authenticated ? "authenticated" : "not authenticated"}`,
+            `<b>Method:</b> <code>${escapeHTML(authStatus.method)}</code>`,
+            `<b>Detail:</b> <code>${escapeHTML(authStatus.detail)}</code>`,
+        ].join("\n");
+        const plain = [
+            `${icon} Auth status: ${authStatus.authenticated ? "authenticated" : "not authenticated"}`,
+            `Method: ${authStatus.method}`,
+            `Detail: ${authStatus.detail}`,
+        ].join("\n");
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    options.bot.command("login", async (ctx) => {
+        if (!ctx.chat) {
+            return;
+        }
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        const info = contextSession?.session.getInfo();
+        if (info && !capabilitiesOf(info).login) {
+            const text = `${labelOf(info)} login is not managed by NordRelay. Run the CLI login flow on the host.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const authStatus = await options.checkLoginAuthStatus(info);
+        if (options.agentIdForAuth(info) !== "hermes" && authStatus.authenticated) {
+            await safeReply(ctx, `<b>✅ Already authenticated</b> via <code>${escapeHTML(authStatus.method)}</code>.`, {
+                fallbackText: `✅ Already authenticated via ${authStatus.method}.`,
+            });
+            return;
+        }
+        if (!options.config.enableTelegramLogin) {
+            await safeReply(ctx, [
+                "<b>Telegram-initiated login is disabled.</b>",
+                "",
+                `Run <code>${escapeHTML(options.hostLoginCommand(info))}</code> on the host.`,
+            ].join("\n"), {
+                fallbackText: [
+                    "Telegram-initiated login is disabled.",
+                    "",
+                    `Run '${options.hostLoginCommand(info)}' on the host.`,
+                ].join("\n"),
+            });
+            return;
+        }
+        const result = await options.startAgentLogin(info);
+        if (result.success) {
+            await safeReply(ctx, `<b>🔑 Login initiated.</b>\n\n<code>${escapeHTML(redactText(result.message))}</code>`, {
+                fallbackText: `🔑 Login initiated.\n\n${redactText(result.message)}`,
+            });
+            return;
+        }
+        await safeReply(ctx, `<b>❌ Login failed.</b>\n\n<code>${escapeHTML(redactText(result.message))}</code>`, {
+            fallbackText: `❌ Login failed.\n\n${redactText(result.message)}`,
+        });
+    });
+    options.bot.command("logout", async (ctx) => {
+        if (!ctx.chat) {
+            return;
+        }
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        const info = contextSession?.session.getInfo();
+        if (info && !capabilitiesOf(info).logout) {
+            const text = `${labelOf(info)} logout is not managed by NordRelay. Run the CLI logout flow on the host.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+            return;
+        }
+        const authStatus = await options.checkLoginAuthStatus(info);
+        if (authStatus.method === "api-key") {
+            await safeReply(ctx, [
+                `<b>Cannot logout via Telegram when ${escapeHTML(options.labelForAuth(info))} uses API-key authentication.</b>`,
+                "",
+                "Remove the API key from .env to use CLI-based auth instead.",
+            ].join("\n"), {
+                fallbackText: [
+                    `Cannot logout via Telegram when ${options.labelForAuth(info)} uses API-key authentication.`,
+                    "",
+                    "Remove the API key from .env to use CLI-based auth instead.",
+                ].join("\n"),
+            });
+            return;
+        }
+        if (!options.config.enableTelegramLogin) {
+            await safeReply(ctx, [
+                "<b>Telegram-initiated auth management is disabled.</b>",
+                "",
+                `Run <code>${escapeHTML(options.hostLogoutCommand(info))}</code> on the host.`,
+            ].join("\n"), {
+                fallbackText: [
+                    "Telegram-initiated auth management is disabled.",
+                    "",
+                    `Run '${options.hostLogoutCommand(info)}' on the host.`,
+                ].join("\n"),
+            });
+            return;
+        }
+        if (options.agentIdForAuth(info) !== "hermes" && !authStatus.authenticated) {
+            await safeReply(ctx, escapeHTML("Not currently authenticated."), {
+                fallbackText: "Not currently authenticated.",
+            });
+            return;
+        }
+        const result = await options.startAgentLogout(info);
+        if (result.success) {
+            await safeReply(ctx, `<b>🔓 Logged out.</b>\n\n${escapeHTML(redactText(result.message))}`, {
+                fallbackText: `🔓 Logged out.\n\n${redactText(result.message)}`,
+            });
+            return;
+        }
+        await safeReply(ctx, `<b>❌ Logout failed.</b>\n\n<code>${escapeHTML(redactText(result.message))}</code>`, {
+            fallbackText: `❌ Logout failed.\n\n${redactText(result.message)}`,
+        });
+    });
+    options.bot.callbackQuery(/^agent_(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
+        const chatId = ctx.chat?.id;
+        const messageId = ctx.callbackQuery.message?.message_id;
+        const selectedAgent = ctx.match?.[1];
+        const contextKey = contextKeyFromCtx(ctx);
+        if (!chatId || !contextKey || !selectedAgent) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        const picks = options.pendingAgentPicks.get(contextKey);
+        if (!picks?.includes(selectedAgent)) {
+            await ctx.answerCallbackQuery({ text: "Expired, run /agent again" });
+            return;
+        }
+        if (options.isBusy(contextKey)) {
+            await ctx.answerCallbackQuery({ text: "Wait for the current prompt to finish" });
+            return;
+        }
+        await ctx.answerCallbackQuery({ text: `Switching to ${agentLabel(selectedAgent)}...` });
+        options.pendingAgentPicks.delete(contextKey);
+        try {
+            const session = await options.registry.switchAgent(contextKey, selectedAgent);
+            const info = session.getInfo();
+            const html = [`<b>Agent switched to ${escapeHTML(labelOf(info))}.</b>`, "", renderSessionInfoHTML(info)].join("\n");
+            const plain = [`Agent switched to ${labelOf(info)}.`, "", renderSessionInfoPlain(info)].join("\n");
+            if (messageId) {
+                await safeEditMessage(options.bot, chatId, messageId, html, { fallbackText: plain });
+            }
+            else {
+                await safeReply(ctx, html, { fallbackText: plain });
+            }
+        }
+        catch (error) {
+            const html = `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`;
+            const plain = `Failed: ${friendlyErrorText(error)}`;
+            if (messageId) {
+                await safeEditMessage(options.bot, chatId, messageId, html, { fallbackText: plain });
+            }
+            else {
+                await safeReply(ctx, html, { fallbackText: plain });
+            }
+        }
+    });
+}

package/dist/telegram-artifact-commands.js

@@ -0,0 +1,139 @@
+import { InlineKeyboard } from "grammy";
+import { getArtifactTurnReport, listRecentArtifactReports, removeArtifactTurn, } from "./artifacts.js";
+import { buildArtifactActionsKeyboard, filterArtifactReports, } from "./bot-rendering.js";
+import { renderArtifactReportsAction } from "./channel-actions.js";
+import { escapeHTML } from "./format.js";
+import { NOOP_PAGE_CALLBACK_DATA } from "./telegram-channel-runtime.js";
+import { safeEditMessage, safeReply, } from "./telegram-output.js";
+export function registerTelegramArtifactCommands(options) {
+    const { bot, config } = options;
+    bot.command("artifacts", async (ctx) => {
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession || !ctx.chat) {
+            return;
+        }
+        const workspace = contextSession.session.getInfo().workspace;
+        const rawText = ctx.message?.text ?? "";
+        const argument = rawText.replace(/^\/artifacts(?:@\w+)?\s*/i, "").trim();
+        const reports = await listRecentArtifactReports(workspace, 10, config.maxFileSize);
+        if (reports.length === 0) {
+            await safeReply(ctx, escapeHTML("No generated artifacts found for this workspace."), {
+                fallbackText: "No generated artifacts found for this workspace.",
+            });
+            return;
+        }
+        if (argument) {
+            const parts = argument.split(/\s+/).filter(Boolean);
+            if (parts[0]?.toLowerCase() === "delete" && parts[1]) {
+                const selected = reports.find((report) => report.turnId === parts[1] || report.turnId.startsWith(parts[1]));
+                if (!selected) {
+                    await safeReply(ctx, escapeHTML(`No artifact turn found for "${parts[1]}".`), {
+                        fallbackText: `No artifact turn found for "${parts[1]}".`,
+                    });
+                    return;
+                }
+                const removed = await removeArtifactTurn(workspace, selected.turnId);
+                const text = removed ? `Deleted artifact turn: ${selected.turnId}` : `Artifact turn not found: ${selected.turnId}`;
+                await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+                return;
+            }
+            const filtered = filterArtifactReports(reports, argument);
+            if (filtered) {
+                if (filtered.length === 0) {
+                    await safeReply(ctx, escapeHTML(`No artifacts matched "${argument}".`), {
+                        fallbackText: `No artifacts matched "${argument}".`,
+                    });
+                    return;
+                }
+                const rendered = renderArtifactReportsAction(filtered);
+                await safeReply(ctx, rendered.html, {
+                    fallbackText: rendered.plain,
+                    replyMarkup: buildArtifactActionsKeyboard(filtered),
+                });
+                return;
+            }
+            const shouldZip = parts[0]?.toLowerCase() === "zip";
+            const requestedTurn = shouldZip ? parts[1] : parts[0];
+            const selected = !requestedTurn || requestedTurn.toLowerCase() === "latest"
+                ? reports[0]
+                : reports.find((report) => report.turnId === requestedTurn || report.turnId.startsWith(requestedTurn));
+            if (!selected) {
+                await safeReply(ctx, escapeHTML(`No artifact turn found for "${argument}".`), {
+                    fallbackText: `No artifact turn found for "${argument}".`,
+                });
+                return;
+            }
+            if (shouldZip) {
+                await options.deliverArtifactReportZip(ctx, ctx.chat.id, selected, ctx.message?.message_thread_id);
+            }
+            else {
+                await options.deliverArtifactReport(ctx, ctx.chat.id, selected, ctx.message?.message_thread_id);
+            }
+            return;
+        }
+        const { html, plain } = renderArtifactReportsAction(reports);
+        await safeReply(ctx, html, {
+            fallbackText: plain,
+            replyMarkup: buildArtifactActionsKeyboard(reports),
+        });
+    });
+    bot.callbackQuery(/^artifact_(send|zip|delete|delete_confirm):([a-zA-Z0-9._-]+)$/, async (ctx) => {
+        const action = ctx.match?.[1];
+        const turnId = ctx.match?.[2];
+        const chatId = ctx.chat?.id;
+        const messageId = ctx.callbackQuery.message?.message_id;
+        if (!action || !turnId || !chatId) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
+            await ctx.answerCallbackQuery({ text: "No context" });
+            return;
+        }
+        const workspace = contextSession.session.getInfo().workspace;
+        if (action === "delete") {
+            await ctx.answerCallbackQuery({ text: "Confirm deletion" });
+            const keyboard = new InlineKeyboard()
+                .text("Delete artifacts", `artifact_delete_confirm:${turnId}`)
+                .row()
+                .text("Cancel", NOOP_PAGE_CALLBACK_DATA);
+            const html = `<b>Delete artifact turn?</b>\n<code>${escapeHTML(turnId)}</code>`;
+            const plain = `Delete artifact turn?\n${turnId}`;
+            if (messageId) {
+                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain, replyMarkup: keyboard });
+            }
+            else {
+                await safeReply(ctx, html, { fallbackText: plain, replyMarkup: keyboard });
+            }
+            return;
+        }
+        if (action === "delete_confirm") {
+            const removed = await removeArtifactTurn(workspace, turnId);
+            await ctx.answerCallbackQuery({ text: removed ? "Deleted" : "Already gone" });
+            const html = removed
+                ? `<b>Deleted artifact turn:</b> <code>${escapeHTML(turnId)}</code>`
+                : `<b>Artifact turn not found:</b> <code>${escapeHTML(turnId)}</code>`;
+            const plain = removed ? `Deleted artifact turn: ${turnId}` : `Artifact turn not found: ${turnId}`;
+            if (messageId) {
+                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain });
+            }
+            else {
+                await safeReply(ctx, html, { fallbackText: plain });
+            }
+            return;
+        }
+        const report = await getArtifactTurnReport(workspace, turnId, config.maxFileSize);
+        if (!report) {
+            await ctx.answerCallbackQuery({ text: "Artifact turn not found" });
+            return;
+        }
+        await ctx.answerCallbackQuery({ text: action === "zip" ? "Sending ZIP..." : "Sending artifacts..." });
+        if (action === "zip") {
+            await options.deliverArtifactReportZip(ctx, chatId, report, ctx.callbackQuery.message?.message_thread_id);
+        }
+        else {
+            await options.deliverArtifactReport(ctx, chatId, report, ctx.callbackQuery.message?.message_thread_id);
+        }
+    });
+}

package/dist/telegram-channel-runtime.js

@@ -0,0 +1,132 @@
+import { Bot, InlineKeyboard, InputFile } from "grammy";
+import { TelegramChannelAdapter, } from "./channel-adapter.js";
+import { redactText } from "./redaction.js";
+import { telegramRateLimiter } from "./telegram-rate-limit.js";
+import { chatBucket, safeEditMessage, sendChatActionSafe, sendTextMessage, } from "./telegram-output.js";
+const KEYBOARD_PAGE_SIZE = 6;
+export const NOOP_PAGE_CALLBACK_DATA = "noop_page";
+export function paginateKeyboard(items, page, prefix) {
+    const totalPages = Math.max(1, Math.ceil(items.length / KEYBOARD_PAGE_SIZE));
+    const currentPage = Math.min(Math.max(page, 0), totalPages - 1);
+    const start = currentPage * KEYBOARD_PAGE_SIZE;
+    const pageItems = items.slice(start, start + KEYBOARD_PAGE_SIZE);
+    const keyboard = new InlineKeyboard();
+    pageItems.forEach((item, index) => {
+        keyboard.text(item.label, item.callbackData);
+        if (index < pageItems.length - 1 || totalPages > 1) {
+            keyboard.row();
+        }
+    });
+    if (totalPages > 1) {
+        if (currentPage > 0) {
+            keyboard.text("◀️ Prev", `${prefix}_page_${currentPage - 1}`);
+        }
+        keyboard.text(`${currentPage + 1}/${totalPages}`, NOOP_PAGE_CALLBACK_DATA);
+        if (currentPage < totalPages - 1) {
+            keyboard.text("Next ▶️", `${prefix}_page_${currentPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+export function actionKeyboard(rows) {
+    if (!rows || rows.length === 0) {
+        return undefined;
+    }
+    const keyboard = new InlineKeyboard();
+    for (const row of rows) {
+        for (const button of row) {
+            keyboard.text(button.label, telegramActionData(button.action));
+        }
+        keyboard.row();
+    }
+    return keyboard;
+}
+export function telegramActionData(action) {
+    if (action === "agent-update:jobs") {
+        return "upd_jobs";
+    }
+    const agentUpdateStart = action.match(/^agent-update:start:(.+)$/);
+    if (agentUpdateStart?.[1]) {
+        return `upd_agent:${agentUpdateStart[1]}`;
+    }
+    const agentUpdateLog = action.match(/^agent-update:log:(.+)$/);
+    if (agentUpdateLog?.[1]) {
+        return `upd_log:${agentUpdateLog[1]}`;
+    }
+    const agentUpdateCancel = action.match(/^agent-update:cancel:(.+)$/);
+    if (agentUpdateCancel?.[1]) {
+        return `upd_cancel:${agentUpdateCancel[1]}`;
+    }
+    return action;
+}
+export class TelegramBotChannelRuntime {
+    bot;
+    id = "telegram";
+    label = "Telegram";
+    capabilities = new TelegramChannelAdapter().capabilities;
+    constructor(bot) {
+        this.bot = bot;
+    }
+    describe() {
+        return new TelegramChannelAdapter().describe();
+    }
+    async sendMessage(context, message) {
+        const sent = await sendTextMessage(this.bot.api, telegramChatIdFromChannelContext(context), message.text, {
+            parseMode: telegramParseMode(message.parseMode),
+            fallbackText: message.fallbackText,
+            replyMarkup: actionKeyboard(message.buttons),
+            messageThreadId: telegramThreadIdFromChannelContext(context, message.threadId),
+        });
+        return { messageId: String(sent.message_id) };
+    }
+    async editMessage(context, messageId, message) {
+        const parsedMessageId = Number.parseInt(messageId, 10);
+        if (!Number.isFinite(parsedMessageId)) {
+            throw new Error(`Invalid Telegram message id: ${messageId}`);
+        }
+        await safeEditMessage(this.bot, telegramChatIdFromChannelContext(context), parsedMessageId, message.text, {
+            parseMode: telegramParseMode(message.parseMode),
+            fallbackText: message.fallbackText,
+            replyMarkup: actionKeyboard(message.buttons),
+        });
+    }
+    async sendTyping(context) {
+        await sendChatActionSafe(this.bot.api, telegramChatIdFromChannelContext(context), "typing", telegramThreadIdFromChannelContext(context));
+    }
+    async sendFile(context, file) {
+        const chatId = telegramChatIdFromChannelContext(context);
+        const sent = await telegramRateLimiter.run(chatBucket(chatId), "sendDocument", () => this.bot.api.sendDocument(chatId, new InputFile(file.localPath, file.name), {
+            caption: file.caption ? redactText(file.caption) : undefined,
+            message_thread_id: telegramThreadIdFromChannelContext(context, file.threadId),
+        }));
+        return { messageId: String(sent.message_id) };
+    }
+}
+export function telegramChannelContextFromCtx(ctx) {
+    if (!ctx.chat?.id) {
+        return null;
+    }
+    const topicId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
+    return {
+        channelId: "telegram",
+        chatId: String(ctx.chat.id),
+        ...(topicId ? { topicId: String(topicId) } : {}),
+        ...(ctx.from?.id ? { userId: String(ctx.from.id) } : {}),
+        ...(ctx.from?.username ? { username: ctx.from.username } : {}),
+    };
+}
+export function telegramChatIdFromChannelContext(context) {
+    const numeric = Number(context.chatId);
+    return Number.isSafeInteger(numeric) ? numeric : context.chatId;
+}
+export function telegramThreadIdFromChannelContext(context, override) {
+    const value = override ?? context.topicId;
+    if (!value) {
+        return undefined;
+    }
+    const numeric = Number(value);
+    return Number.isSafeInteger(numeric) ? numeric : undefined;
+}
+export function telegramParseMode(parseMode) {
+    return parseMode === "html" ? "HTML" : undefined;
+}

package/dist/telegram-command-menu.js

@@ -0,0 +1,55 @@
+export async function registerCommands(bot) {
+    await bot.api.setMyCommands([
+        { command: "start", description: "Welcome & status" },
+        { command: "help", description: "Command reference" },
+        { command: "link", description: "Link Telegram to NordRelay user" },
+        { command: "whoami", description: "Show your NordRelay user" },
+        { command: "register_chat", description: "Admin: enable this group chat" },
+        { command: "channels", description: "Messaging adapter status" },
+        { command: "agents", description: "Agent adapter status" },
+        { command: "agent", description: "Select agent" },
+        { command: "new", description: "Start a new thread" },
+        { command: "session", description: "Current thread details" },
+        { command: "sessions", description: "Browse & switch threads" },
+        { command: "sync", description: "Sync active session from CLI state" },
+        { command: "pinned", description: "Show pinned threads" },
+        { command: "pin", description: "Pin current or given thread" },
+        { command: "unpin", description: "Unpin current or given thread" },
+        { command: "retry", description: "Resend the last prompt" },
+        { command: "queue", description: "Show queued prompts" },
+        { command: "cancel", description: "Cancel a queued prompt" },
+        { command: "clearqueue", description: "Clear queued prompts" },
+        { command: "artifacts", description: "List or resend generated files" },
+        { command: "workspaces", description: "List allowed workspaces" },
+        { command: "abort", description: "Cancel current operation" },
+        { command: "stop", description: "Cancel current operation" },
+        { command: "launch_profiles", description: "Select launch profile" },
+        { command: "fast", description: "Toggle fast mode" },
+        { command: "model", description: "View & change model" },
+        { command: "reasoning", description: "Set reasoning effort" },
+        { command: "mirror", description: "Control CLI mirroring" },
+        { command: "notify", description: "Control notifications" },
+        { command: "auth", description: "Check auth status" },
+        { command: "login", description: "Start authentication" },
+        { command: "logout", description: "Sign out" },
+        { command: "voice", description: "Voice transcription status" },
+        { command: "tasks", description: "Current turn progress" },
+        { command: "progress", description: "Current turn progress" },
+        { command: "activity", description: "Thread activity timeline" },
+        { command: "audit", description: "Admin: recent audit events" },
+        { command: "status", description: "Connector runtime status" },
+        { command: "health", description: "Connector health report" },
+        { command: "version", description: "Connector version" },
+        { command: "logs", description: "Admin: show connector logs" },
+        { command: "diagnostics", description: "Admin: connector diagnostics" },
+        { command: "support", description: "Admin: export diagnostics bundle" },
+        { command: "lock", description: "Lock session writes to you" },
+        { command: "unlock", description: "Release session write lock" },
+        { command: "locks", description: "List session write locks" },
+        { command: "restart", description: "Admin: restart connector" },
+        { command: "update", description: "Admin: update connector or agents" },
+        { command: "handback", description: "Hand session back to CLI" },
+        { command: "attach", description: "Bind a session to this topic" },
+        { command: "switch", description: "Switch to a thread by ID" },
+    ]);
+}

package/dist/telegram-command-types.js

@@ -0,0 +1 @@
+export {};

package/dist/telegram-diagnostics-command.js

@@ -0,0 +1,102 @@
+import { getAgentDiagnostics } from "./agent-activity.js";
+import { formatQuietHours } from "./bot-preferences.js";
+import { logTailRequests, parseLogsCommand, renderLogTailsAction, } from "./channel-actions.js";
+import { checkAuthStatus } from "./codex-auth.js";
+import { contextKeyFromCtx } from "./context-key.js";
+import { escapeHTML } from "./format.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "./operations.js";
+import { formatCliPathHTML, formatCliPathPlain, renderAgentDiagnostics, renderDiagnosticsHTML, renderDiagnosticsPlain, renderHealthHTML, renderHealthPlain, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
+import { getTelegramRateLimitMetrics } from "./telegram-rate-limit.js";
+import { safeReply } from "./telegram-output.js";
+export function registerTelegramDiagnosticsCommands(options) {
+    options.bot.command(["status", "health"], async (ctx) => {
+        const health = await getConnectorHealth(cliPathOptions(options.config));
+        const contextSession = await options.getContextSession(ctx, { deferThreadStart: true });
+        const authStatus = contextSession
+            ? await options.checkAgentAuthStatus(contextSession.session.getInfo())
+            : await checkAuthStatus(options.config.codexApiKey);
+        const html = renderHealthHTML(health, authStatus.authenticated, options.getUserRole(ctx));
+        const plain = renderHealthPlain(health, authStatus.authenticated, options.getUserRole(ctx));
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    options.bot.command("version", async (ctx) => {
+        const health = await getConnectorHealth(cliPathOptions(options.config));
+        const state = await readConnectorState();
+        const versions = await getVersionChecks(cliPathOptions(options.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");
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    options.bot.command("diagnostics", async (ctx) => {
+        const health = await getConnectorHealth(cliPathOptions(options.config));
+        const contextKey = contextKeyFromCtx(ctx);
+        const queueLength = contextKey ? options.promptStore.list(contextKey).length : 0;
+        const progress = contextKey ? options.turnProgress.get(contextKey) : undefined;
+        const contextSession = contextKey ? await options.getContextSession(ctx, { deferThreadStart: true }) : null;
+        const authStatus = contextSession
+            ? await options.checkAgentAuthStatus(contextSession.session.getInfo())
+            : await checkAuthStatus(options.config.codexApiKey);
+        const agentDiagnostics = contextSession
+            ? renderAgentDiagnostics(getAgentDiagnostics(contextSession.session, options.config))
+            : { plain: "Agent state: no context", html: "<b>Agent state:</b> <code>no context</code>" };
+        const runtime = {
+            rateLimit: getTelegramRateLimitMetrics(),
+            externalMirrors: options.externalMirrors.size,
+            externalQueueTimers: options.externalQueueTimers.size,
+            queueStatusMessages: options.queueStatusMessages.size,
+            mirrorMode: contextKey ? options.getEffectiveMirrorMode(contextKey) : options.config.telegramMirrorMode,
+            notifyMode: contextKey ? options.getEffectiveNotifyMode(contextKey) : options.config.telegramNotifyMode,
+            quietHours: formatQuietHours(contextKey ? options.getEffectiveQuietHours(contextKey) : options.config.telegramQuietHours),
+            voiceBackend: contextKey ? options.getEffectiveVoiceBackend(contextKey) : options.config.voicePreferredBackend,
+            voiceLanguage: contextKey ? options.getEffectiveVoiceLanguage(contextKey) ?? "auto" : options.config.voiceDefaultLanguage ?? "auto",
+            voiceTranscribeOnly: contextKey ? options.isVoiceTranscribeOnly(contextKey) : options.config.voiceTranscribeOnly,
+        };
+        const plain = `${renderDiagnosticsPlain(options.config, options.registry, health, authStatus.authenticated, options.getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.plain}`;
+        const html = `${renderDiagnosticsHTML(options.config, options.registry, health, authStatus.authenticated, options.getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.html}`;
+        await safeReply(ctx, html, { fallbackText: plain });
+    });
+    options.bot.command("logs", async (ctx) => {
+        const rawText = ctx.message?.text ?? "";
+        const argument = rawText.replace(/^\/logs(?:@\w+)?\s*/i, "").trim();
+        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),
+        })));
+        await options.replyChannelAction(ctx, renderLogTailsAction(logs));
+    });
+}
+function cliPathOptions(config) {
+    return {
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    };
+}