@nordbyte/nordrelay 0.5.0 → 0.5.1

package/dist/support-bundle.js

@@ -0,0 +1,205 @@
+import { spawnSync } from "node:child_process";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { getAgentUpdateLogPath, getConnectorHealth, getConnectorHome, getConnectorLogPath, getConnectorStatePath, getSourceRoot, getUpdateLogPath, getVersionChecks, readFormattedLogTail, resolveNpmSpawnCommand, } from "./operations.js";
+import { redactText } from "./redaction.js";
+import { createZipBuffer } from "./zip-writer.js";
+export async function createSupportBundle(options) {
+    const createdAt = new Date();
+    const health = options.health ?? await getConnectorHealth(cliPathOptions(options.config));
+    const versionChecks = options.versionChecks ?? await getVersionChecks(cliPathOptions(options.config));
+    const entries = [];
+    addJson(entries, "manifest.json", {
+        createdAt: createdAt.toISOString(),
+        source: options.source ?? "web",
+        package: "@nordbyte/nordrelay",
+        includedFiles: [],
+    });
+    addJson(entries, "config/redacted-config.json", redactValue(options.config));
+    addJson(entries, "config/relevant-env.json", redactValue(relevantEnvironment()));
+    addJson(entries, "runtime/health.json", redactValue(health));
+    addJson(entries, "runtime/version-checks.json", redactValue(versionChecks));
+    addJson(entries, "runtime/state-backend.json", {
+        stateBackend: options.config.stateBackend,
+        stateFile: getConnectorStatePath(),
+        connectorHome: getConnectorHome(),
+        sourceRoot: getSourceRoot(),
+        workspace: options.config.workspace,
+        databasePath: health.databasePath,
+    });
+    addJson(entries, "runtime/agent-paths.json", agentPaths(health));
+    addJson(entries, "system/info.json", systemInfo());
+    if (options.diagnostics) {
+        addJson(entries, "runtime/diagnostics.json", redactValue(options.diagnostics));
+    }
+    if (options.adapterHealth) {
+        addJson(entries, "runtime/adapter-health.json", redactValue(options.adapterHealth));
+    }
+    if (options.auditEvents) {
+        addJson(entries, "audit/recent-events.json", redactValue(options.auditEvents));
+    }
+    if (options.agentUpdateJobs) {
+        addJson(entries, "updates/jobs.json", redactValue(options.agentUpdateJobs));
+    }
+    await addLog(entries, "logs/connector.log", getConnectorLogPath());
+    await addLog(entries, "logs/nordrelay-update.log", getUpdateLogPath());
+    await addLog(entries, "logs/agent-updates.log", getAgentUpdateLogPath());
+    const includedFiles = entries.map((entry) => entry.name);
+    entries[0] = {
+        name: "manifest.json",
+        data: jsonText({
+            createdAt: createdAt.toISOString(),
+            source: options.source ?? "web",
+            package: "@nordbyte/nordrelay",
+            includedFiles,
+        }),
+        date: createdAt,
+    };
+    const buffer = createZipBuffer(entries);
+    const name = `nordrelay-diagnostics-${formatTimestamp(createdAt)}.zip`;
+    const supportDir = path.join(getConnectorHome(), "support");
+    await mkdir(supportDir, { recursive: true });
+    const bundlePath = path.join(supportDir, name);
+    await writeFile(bundlePath, buffer);
+    const stats = await stat(bundlePath);
+    return {
+        path: bundlePath,
+        name,
+        sizeBytes: stats.size,
+        createdAt: createdAt.toISOString(),
+        includedFiles,
+    };
+}
+function cliPathOptions(config) {
+    return {
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    };
+}
+function addJson(entries, name, value) {
+    entries.push({ name, data: jsonText(value) });
+}
+async function addLog(entries, name, filePath) {
+    const tail = await readFormattedLogTail(300, filePath);
+    entries.push({
+        name,
+        data: [
+            `File: ${tail.filePath}`,
+            `Updated: ${tail.updatedAt ? tail.updatedAt.toISOString() : "-"}`,
+            `Lines: ${tail.lineCount}/${tail.requestedLines}`,
+            "",
+            tail.plain || "(empty)",
+        ].join("\n"),
+    });
+}
+function jsonText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function redactValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item));
+    }
+    if (!value || typeof value !== "object") {
+        return typeof value === "string" ? redactText(value) : value;
+    }
+    const output = {};
+    for (const [key, rawValue] of Object.entries(value)) {
+        output[key] = isSecretKey(key) ? "[REDACTED]" : redactValue(rawValue);
+    }
+    return output;
+}
+function isSecretKey(key) {
+    return /(token|secret|password|authorization|api[_-]?key|apikey|botToken|webhookSecret|gatewayPassword)/i.test(key);
+}
+function relevantEnvironment() {
+    const prefixes = [
+        "NORDRELAY_",
+        "TELEGRAM_",
+        "CODEX_",
+        "PI_",
+        "HERMES_",
+        "OPENCLAW_",
+        "CLAUDE_",
+        "WORKSPACE_",
+        "ARTIFACT_",
+        "VOICE_",
+        "FASTER_WHISPER_",
+    ];
+    const exact = new Set(["MAX_FILE_SIZE", "TOOL_VERBOSITY", "CONNECTOR_LOG_FORMAT", "NODE_ENV"]);
+    return Object.fromEntries(Object.entries(process.env)
+        .filter(([key, value]) => value !== undefined && (exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix))))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => [key, value ?? ""]));
+}
+function agentPaths(health) {
+    return {
+        codex: { label: health.codexCli, path: health.codexCliPath, version: health.codexCliVersion },
+        pi: { label: health.piCli, path: health.piCliPath, version: health.piCliVersion },
+        hermes: { label: health.hermesCli, path: health.hermesCliPath, version: health.hermesCliVersion },
+        openclaw: { label: health.openClawCli, path: health.openClawCliPath, version: health.openClawCliVersion },
+        "claude-code": { label: health.claudeCodeCli, path: health.claudeCodeCliPath, version: health.claudeCodeCliVersion },
+    };
+}
+function systemInfo() {
+    const npm = resolveNpmSpawnCommand();
+    return {
+        os: {
+            platform: os.platform(),
+            release: os.release(),
+            arch: os.arch(),
+            type: os.type(),
+            homedir: os.homedir(),
+            tmpdir: os.tmpdir(),
+            cpus: os.cpus().length,
+            totalMemoryBytes: os.totalmem(),
+            freeMemoryBytes: os.freemem(),
+            uptimeSeconds: os.uptime(),
+        },
+        node: {
+            executable: process.execPath,
+            version: process.version,
+            versions: process.versions,
+            argv: process.argv,
+            cwd: process.cwd(),
+            pid: process.pid,
+            uptimeSeconds: process.uptime(),
+        },
+        npm: npm ? {
+            command: npm.display,
+            version: detectNpmVersion(npm),
+        } : {
+            command: null,
+            version: null,
+            error: "npm not found",
+        },
+    };
+}
+function detectNpmVersion(npm) {
+    const result = spawnSync(npm.command, [...npm.argsPrefix, "--version"], {
+        encoding: "utf8",
+        shell: npm.shell,
+        timeout: 3000,
+        windowsHide: true,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || "").trim() || null;
+}
+function formatTimestamp(date) {
+    return [
+        date.getFullYear(),
+        pad2(date.getMonth() + 1),
+        pad2(date.getDate()),
+        "-",
+        pad2(date.getHours()),
+        pad2(date.getMinutes()),
+        pad2(date.getSeconds()),
+    ].join("");
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}

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-command-menu.js

@@ -42,6 +42,7 @@ export async function registerCommands(bot) {
         { 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" },

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,
+    };
+}