appback-remoteagent 0.17.1 → 0.20.0

package/dist/bot.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
@@ -10,6 +11,7 @@ import { ProviderSetupService } from "./services/provider-setup-service.js";
 import { RemoteShellService } from "./services/remote-shell-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
 import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
+import { exportSecrets } from "./services/secret-transfer-service.js";
 import { deleteTelegramCommandMenu, setTelegramCommandMenu } from "./telegram-command-menu.js";
 const execFileAsync = promisify(execFile);
 const HELP_TEXT = [
@@ -32,7 +34,7 @@ const HELP_TEXT = [
     "/state [clear|note <text>]",
     "/artifacts list|cleanup <days>",
     "/cleanup",
-    "/secret set|list|remove",
+    "/secret set|list|remove|export",
     "/docs pin|find|list|remove|reinforce",
     "/macro set|list|remove|<alias|number>",
     "/매크로 set|list|remove|<alias|number>",
@@ -104,6 +106,41 @@ const workLoopTails = new Map();
 const workLoopGenerations = new Map();
 const queuedWorkLoops = new Map();
 let nextQueuedWorkSequence = 1;
+class InlineActionRegistry {
+    records = new Map();
+    ttlMs = 6 * 60 * 60 * 1000;
+    maxRecords = 1_000;
+    register(action, chatId, userId) {
+        this.prune();
+        while (this.records.size >= this.maxRecords) {
+            const oldest = this.records.keys().next().value;
+            if (!oldest) {
+                break;
+            }
+            this.records.delete(oldest);
+        }
+        const id = randomUUID().replace(/-/g, "").slice(0, 20);
+        this.records.set(id, { action, chatId, userId, createdAt: Date.now() });
+        return `remoteagent:action:${id}`;
+    }
+    resolve(data, chatId, userId) {
+        this.prune();
+        const match = /^remoteagent:action:([a-f0-9]{20})$/i.exec(data);
+        const record = match ? this.records.get(match[1]) : undefined;
+        if (!record || record.chatId !== chatId || record.userId !== userId) {
+            return undefined;
+        }
+        return record.action;
+    }
+    prune() {
+        const expiresBefore = Date.now() - this.ttlMs;
+        for (const [id, record] of this.records) {
+            if (record.createdAt < expiresBefore) {
+                this.records.delete(id);
+            }
+        }
+    }
+}
 const REPORT_CONTINUE_PROMPT = [
     "Continue the same task now.",
     "Do more concrete work before replying again.",
@@ -185,6 +222,7 @@ class AutoContinueController {
 }
 export function createBot(token, bridge, botManagement, botInfo) {
     const bot = new Bot(token, { botInfo });
+    const inlineActions = new InlineActionRegistry();
     const autoContinue = new AutoContinueController(path.join(config.dataDir, "stop-gates.json"));
     const shellService = new RemoteShellService(config.commandTimeoutMs);
     const memoryService = new AgentMemoryService(config.dataDir);
@@ -229,6 +267,20 @@ export function createBot(token, bridge, botManagement, botInfo) {
             throw error;
         }
     };
+    const actionButton = (ctx, text, action) => {
+        if (!ctx.chat || !ctx.from) {
+            throw new Error("Telegram action button requires chat and user context.");
+        }
+        return {
+            text,
+            callback_data: inlineActions.register(action, String(ctx.chat.id), String(ctx.from.id)),
+        };
+    };
+    const keyboardOptions = (rows) => {
+        return rows.length > 0
+            ? { reply_markup: JSON.stringify({ inline_keyboard: rows }) }
+            : undefined;
+    };
     const removeQueuedInstruction = async (botId, chatId, selector) => {
         const mapping = await bridge.status(botId, chatId);
         const activeKey = workLoopKey(botId, chatId, mapping?.session.sessionId);
@@ -329,14 +381,14 @@ ${bridge.formatStatus(mapping)}`);
     bot.command("help", async (ctx) => {
         await reply(ctx, HELP_TEXT);
     });
-    const replySessionList = async (ctx) => {
+    const replySessionList = async (ctx, requestedShowAll) => {
         if (!ctx.chat) {
             throw new Error("Telegram chat context is missing.");
         }
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 1);
-        const showAll = args[0] === "-a" || args[0] === "--all";
+        const showAll = requestedShowAll ?? (args[0] === "-a" || args[0] === "--all");
         const [mapping, sessions] = await Promise.all([
             bridge.status(botId, chatId),
             bridge.listSessions(),
@@ -345,9 +397,33 @@ ${bridge.formatStatus(mapping)}`);
         const sessionList = showAll
             ? await bridge.formatSessionListDetailed(sessions, mapping?.session.sessionId, await bridge.listActiveSessionIds())
             : bridge.formatSessionList(sessions, mapping?.session.sessionId);
-        for (const chunk of flattenChunks([`${sessionList}\n\n${botSummary}`], 3900)) {
-            await reply(ctx, chunk);
+        const sessionButtons = sessions.slice(0, showAll ? 20 : 10).map((session) => [
+            actionButton(ctx, truncateButtonLabel(`${session.sessionId === mapping?.session.sessionId ? "✓ " : ""}${session.publicId} · ${workspaceLeaf(session.workspace)}`), { kind: "session.switch", selector: session.publicId }),
+        ]);
+        if (!showAll && sessions.length > 10) {
+            sessionButtons.push([actionButton(ctx, `Show all ${sessions.length} sessions`, { kind: "session.list", showAll: true })]);
+        }
+        const chunks = flattenChunks([`${sessionList}\n\n${botSummary}`], 3900);
+        for (const [index, chunk] of chunks.entries()) {
+            await reply(ctx, chunk, index === chunks.length - 1 ? keyboardOptions(sessionButtons) : undefined);
+        }
+    };
+    const switchChatSession = async (ctx, selector) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const previous = await bridge.status(botId, chatId).catch(() => undefined);
+        const mapping = await bridge.switchSession(botId, chatId, selector);
+        if (previous && previous.session.sessionId !== mapping.session.sessionId) {
+            autoContinue.requestSessionStop(previous.session.sessionId);
+            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
+            messageBatcher.cancelPending(botId, chatId);
+            messageBatcher.cancelManual(botId, chatId);
+            await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
         }
+        return `Switched this chat to session ${mapping.session.publicId}.\n\n${bridge.formatCurrentSession(mapping)}`;
     };
     bot.command("list", async (ctx) => {
         await replySessionList(ctx);
@@ -361,8 +437,6 @@ ${bridge.formatStatus(mapping)}`);
         await reply(ctx, `Created and bound a new ${mapping.session.mode} session.\n\n${bridge.formatCurrentSession(mapping)}`);
     });
     bot.command("switch", async (ctx) => {
-        const botId = getBotId();
-        const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 1);
         const sessionId = args[0];
         if (!sessionId) {
@@ -371,16 +445,7 @@ ${bridge.formatStatus(mapping)}`);
             });
             return;
         }
-        const previous = await bridge.status(botId, chatId).catch(() => undefined);
-        const mapping = await bridge.switchSession(botId, chatId, sessionId);
-        if (previous && previous.session.sessionId !== mapping.session.sessionId) {
-            autoContinue.requestSessionStop(previous.session.sessionId);
-            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
-            messageBatcher.cancelPending(botId, chatId);
-            messageBatcher.cancelManual(botId, chatId);
-            await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
-        }
-        await reply(ctx, `Switched this chat to session ${sessionId}.\n\n${bridge.formatCurrentSession(mapping)}`);
+        await reply(ctx, await switchChatSession(ctx, sessionId));
     });
     bot.command("plan", async (ctx) => {
         const { args, rest } = parseCommand(ctx.message?.text, 1);
@@ -449,6 +514,14 @@ ${bridge.formatStatus(mapping)}`);
 
 ${bridge.formatStatus(mapping)}`);
     });
+    const setChatModel = async (ctx, model) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const mapping = await bridge.setModel(getBotId(), String(ctx.chat.id), model);
+        const selectedModel = mapping.session[mapping.session.mode]?.model ?? model;
+        return `Set ${mapping.session.mode} model to ${selectedModel}.\n\n${bridge.formatStatus(mapping)}`;
+    };
     bot.command("model", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
@@ -461,13 +534,17 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!model) {
+            const selection = await bridge.getModelSelection(botId, chatId);
+            const rows = selection.presets.map((preset) => [
+                actionButton(ctx, `${preset === selection.currentModel ? "✓ " : ""}${preset}`, { kind: "model.set", model: preset }),
+            ]);
             await reply(ctx, await bridge.formatModelSelection(botId, chatId), {
                 parse_mode: "Markdown",
+                ...(keyboardOptions(rows) ?? {}),
             });
             return;
         }
-        const mapping = await bridge.setModel(botId, chatId, model);
-        await reply(ctx, `Set ${mapping.session.mode} model to ${model}.\n\n${bridge.formatStatus(mapping)}`);
+        await reply(ctx, await setChatModel(ctx, model));
     });
     bot.command("queue", async (ctx) => {
         const botId = getBotId();
@@ -482,7 +559,15 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!action || action === "list") {
-            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId));
+            const queued = listQueuedWorkLoops(activeKey);
+            const rows = queued.map((entry) => [{
+                    text: `Remove ${entry.id}`,
+                    callback_data: `remoteagent:queue:remove:${entry.id}`,
+                }]);
+            if (queued.length > 0) {
+                rows.push([{ text: "Remove latest", callback_data: "remoteagent:queue:del" }]);
+            }
+            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId), keyboardOptions(rows));
             return;
         }
         if ((action === "remove" || action === "rm") && !selector) {
@@ -533,7 +618,16 @@ ${bridge.formatStatus(mapping)}`);
         const option = args[0]?.toLowerCase();
         const value = args[1];
         if (!option) {
-            await reply(ctx, formatRuntimeOptions());
+            await reply(ctx, formatRuntimeOptions(), keyboardOptions([
+                [
+                    actionButton(ctx, "Retry", { kind: "option.show", option: "retry" }),
+                    actionButton(ctx, "Timeout", { kind: "option.show", option: "timeout" }),
+                ],
+                [
+                    actionButton(ctx, "Intent", { kind: "option.show", option: "intent" }),
+                    actionButton(ctx, "Command menu", { kind: "option.show", option: "command-menu" }),
+                ],
+            ]));
             return;
         }
         if (option !== "retry" && option !== "timeout" && option !== "intent" && option !== "command-menu") {
@@ -543,14 +637,7 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!value) {
-            const current = option === "retry"
-                ? `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``
-                : option === "intent"
-                    ? `Current untagged intent retry limit: ${formatRetryLimit(config.telegramUntaggedIntentRetries)}\n\nUsage: \`/option intent <count>\``
-                    : option === "command-menu"
-                        ? `Current Telegram command menu: ${config.telegramCommandMenuEnabled ? "on" : "off"}\n\nUsage: \`/option command-menu on\`, \`/option command-menu off\`, or \`/option command-menu refresh\``
-                        : `Current provider execution timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)}\n\nUsage: \`/option timeout <seconds>\``;
-            await reply(ctx, current, {
+            await reply(ctx, formatRuntimeOptionDetail(option), {
                 parse_mode: "Markdown",
             });
             return;
@@ -697,9 +784,46 @@ ${bridge.formatStatus(mapping)}`);
                 return;
             }
             await memoryService.setSecret(key, rest.trim());
+            if (ctx.chat && ctx.message?.message_id) {
+                await deleteTelegramMessage(token, ctx.chat.id, ctx.message.message_id).catch((error) => {
+                    console.warn(`[secret] failed to delete source message for ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
             await reply(ctx, `Stored secret key ${key}. Value is hidden from agents and chat output.`);
             return;
         }
+        if (action === "export") {
+            if (!key || !ctx.chat) {
+                await reply(ctx, formatSecretHelp(), { parse_mode: "Markdown" });
+                return;
+            }
+            const passphrase = await memoryService.getSecret(key);
+            if (!passphrase) {
+                await reply(ctx, `Secret key was not found: ${key}`);
+                return;
+            }
+            const selectedKeys = rest
+                ?.split(/\s+/)
+                .map((value) => value.trim().toUpperCase())
+                .filter(Boolean);
+            const mapping = await bridge.status(getBotId(), String(ctx.chat.id)).catch(() => undefined);
+            const exportDir = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-secret-export-"));
+            const exportPath = path.join(exportDir, `remoteagent-secrets-${mapping?.session.publicId ?? "install"}-${new Date().toISOString().slice(0, 10)}.ra-secrets`);
+            try {
+                const result = await exportSecrets(config.dataDir, exportPath, passphrase, {
+                    includeKeys: selectedKeys,
+                    excludeKeys: [key],
+                });
+                await sendTelegramDocument(token, ctx.chat.id, {
+                    path: result.outputPath,
+                    caption: `Encrypted RemoteAgent Secret bundle (${result.count} key(s)). Secret values are not shown.`,
+                });
+            }
+            finally {
+                await fs.rm(exportDir, { recursive: true, force: true }).catch(() => undefined);
+            }
+            return;
+        }
         if (action === "remove") {
             if (!key) {
                 await reply(ctx, formatSecretHelp(), { parse_mode: "Markdown" });
@@ -762,15 +886,29 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/docs list`, `/docs find <keyword>`, `/docs pin <keyword> <path>`, `/docs remove <keyword>`, or `/docs reinforce <1-10>`", { parse_mode: "Markdown" });
     });
-    const handleMacroCommand = async (ctx, text) => {
+    const runMacro = async (ctx, target) => {
         if (!ctx.chat) {
             throw new Error("Telegram chat context is missing.");
         }
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
+        const macro = await memoryService.getMacro(target);
+        if (!macro) {
+            return `Macro was not found: ${target}\n\n${await memoryService.listMacros()}`;
+        }
+        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
+        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
+        return undefined;
+    };
+    const handleMacroCommand = async (ctx, text) => {
+        const botId = getBotId();
         const parsed = parseMacroCommandText(text, botId);
         if (parsed.kind === "help") {
-            await reply(ctx, await formatMacroHelp(memoryService));
+            const macros = await memoryService.getMacros();
+            const rows = macros.slice(0, 20).map((macro) => [
+                actionButton(ctx, truncateButtonLabel(macro.alias), { kind: "macro.run", alias: macro.alias }),
+            ]);
+            await reply(ctx, await formatMacroHelp(memoryService), keyboardOptions(rows));
             return;
         }
         if (parsed.kind === "set") {
@@ -785,25 +923,34 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, removed ? `Removed macro '${parsed.alias}'.` : `Macro was not found: ${parsed.alias}`);
             return;
         }
-        const macro = await memoryService.getMacro(parsed.target);
-        if (!macro) {
-            await reply(ctx, `Macro was not found: ${parsed.target}\n\n${await memoryService.listMacros()}`);
-            return;
+        const result = await runMacro(ctx, parsed.target);
+        if (result) {
+            await reply(ctx, result);
         }
-        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
-        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
     };
     bot.command("macro", async (ctx) => {
         await handleMacroCommand(ctx, ctx.message?.text ?? "/macro");
     });
-    bot.command("bots", async (ctx) => {
+    const replyBotList = async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const pendingNotice = await botManagement.getPendingOperationNotice();
-        if (pendingNotice?.pending) {
-            await reply(ctx, `${pendingNotice.message}\n\n${await botManagement.listBots()}`);
-            return;
-        }
-        await reply(ctx, await botManagement.listBots());
+        const [botList, choices] = await Promise.all([
+            botManagement.listBots(),
+            botManagement.listBotChoices(),
+        ]);
+        const rows = [];
+        for (let index = 0; index < choices.length; index += 2) {
+            rows.push(choices.slice(index, index + 2).map((choice) => ({
+                text: `@${choice.username}`,
+                url: `https://t.me/${choice.username}`,
+            })));
+        }
+        rows.push([actionButton(ctx, "Refresh", { kind: "bots.refresh" })]);
+        const message = pendingNotice?.pending ? `${pendingNotice.message}\n\n${botList}` : botList;
+        await reply(ctx, message, keyboardOptions(rows));
+    };
+    bot.command("bots", async (ctx) => {
+        await replyBotList(ctx);
     });
     bot.command("bot", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
@@ -882,20 +1029,39 @@ ${bridge.formatStatus(mapping)}`);
             return { chunks: flattenChunks([output], 3900) };
         });
     });
+    const setChatSandbox = async (ctx, sandboxMode) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const mapping = await bridge.setCodexSandboxMode(getBotId(), String(ctx.chat.id), sandboxMode);
+        return `Set Codex sandbox to ${sandboxMode}.\n\n${bridge.formatStatus(mapping)}`;
+    };
     bot.command("sandbox", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 2);
         const provider = args[0]?.toLowerCase();
         const sandboxMode = args[1]?.toLowerCase();
+        if (!provider && !sandboxMode) {
+            const mapping = await bridge.status(botId, chatId);
+            if (!mapping?.session.codex) {
+                await reply(ctx, "No Codex session is paired with this chat.");
+                return;
+            }
+            const current = mapping.session.codex.sandboxMode ?? config.codexSandboxMode;
+            const modes = ["read-only", "workspace-write", "danger-full-access"];
+            await reply(ctx, `Codex sandbox\ncurrent: ${current}\n\nChoose a mode:`, keyboardOptions(modes.map((mode) => [
+                actionButton(ctx, `${mode === current ? "✓ " : ""}${mode}`, { kind: "sandbox.set", mode }),
+            ])));
+            return;
+        }
         if (provider !== "codex" || !sandboxMode || !isCodexSandboxMode(sandboxMode)) {
             await reply(ctx, "Usage: `/sandbox codex <read-only|workspace-write|danger-full-access>`", {
                 parse_mode: "Markdown",
             });
             return;
         }
-        const mapping = await bridge.setCodexSandboxMode(botId, chatId, sandboxMode);
-        await reply(ctx, `Set Codex sandbox to ${sandboxMode}.\n\n${bridge.formatStatus(mapping)}`);
+        await reply(ctx, await setChatSandbox(ctx, sandboxMode));
     });
     bot.command("reset", async (ctx) => {
         const botId = getBotId();
@@ -905,26 +1071,86 @@ ${bridge.formatStatus(mapping)}`);
         await reply(ctx, "Cleared all pairings for this chat.");
     });
     bot.on("callback_query:data", async (ctx) => {
-        const match = /^remoteagent:queue:(remove:(Q\d+)|del)$/i.exec(ctx.callbackQuery.data);
-        if (!match) {
-            return;
-        }
+        const data = ctx.callbackQuery.data;
         const callbackChat = ctx.callbackQuery.message?.chat;
         if (!callbackChat) {
             await callTelegramApi(token, "answerCallbackQuery", {
                 callback_query_id: ctx.callbackQuery.id,
-                text: "This queue action is no longer available.",
+                text: "This action is no longer available.",
             });
             return;
         }
         const botId = getBotId();
         const chatId = String(callbackChat.id);
-        const result = await removeQueuedInstruction(botId, chatId, match[2]);
+        const queueMatch = /^remoteagent:queue:(remove:(Q\d+)|del)$/i.exec(data);
+        if (queueMatch) {
+            const result = await removeQueuedInstruction(botId, chatId, queueMatch[2]);
+            await callTelegramApi(token, "answerCallbackQuery", {
+                callback_query_id: ctx.callbackQuery.id,
+                text: result.split("\n", 1)[0],
+            });
+            await sendTelegramMessage(token, callbackChat.id, result);
+            return;
+        }
+        if (!data.startsWith("remoteagent:action:")) {
+            return;
+        }
+        const action = inlineActions.resolve(data, chatId, String(ctx.from.id));
+        if (!action) {
+            await callTelegramApi(token, "answerCallbackQuery", {
+                callback_query_id: ctx.callbackQuery.id,
+                text: "This button expired. Open the command list again.",
+            });
+            return;
+        }
         await callTelegramApi(token, "answerCallbackQuery", {
             callback_query_id: ctx.callbackQuery.id,
-            text: result.split("\n", 1)[0],
+            text: action.kind === "macro.run" ? "Macro selected." : "Applying...",
         });
-        await sendTelegramMessage(token, callbackChat.id, result);
+        try {
+            if (action.kind === "session.switch") {
+                await reply(ctx, await switchChatSession(ctx, action.selector));
+                return;
+            }
+            if (action.kind === "session.list") {
+                await replySessionList(ctx, action.showAll);
+                return;
+            }
+            if (action.kind === "model.set") {
+                await reply(ctx, await setChatModel(ctx, action.model));
+                return;
+            }
+            if (action.kind === "macro.run") {
+                const result = await runMacro(ctx, action.alias);
+                if (result) {
+                    await reply(ctx, result);
+                }
+                return;
+            }
+            if (action.kind === "option.show") {
+                await ensureOwnerControlAccess(ctx);
+                await reply(ctx, formatRuntimeOptionDetail(action.option), { parse_mode: "Markdown" });
+                return;
+            }
+            if (action.kind === "bots.refresh") {
+                await replyBotList(ctx);
+                return;
+            }
+            if (action.mode === "danger-full-access" && !action.confirmed) {
+                await reply(ctx, "Confirm Codex sandbox change to danger-full-access.", keyboardOptions([[
+                        actionButton(ctx, "Confirm danger-full-access", {
+                            kind: "sandbox.set",
+                            mode: "danger-full-access",
+                            confirmed: true,
+                        }),
+                    ]]));
+                return;
+            }
+            await reply(ctx, await setChatSandbox(ctx, action.mode));
+        }
+        catch (error) {
+            await reply(ctx, error instanceof Error ? error.message : String(error));
+        }
     });
     bot.on("message", async (ctx) => {
         const botId = getBotId();
@@ -2224,12 +2450,15 @@ function formatSecretHelp() {
         "/secret set KEY value",
         "/secret list",
         "/secret remove KEY",
+        "/secret export PASSPHRASE_KEY [KEY ...]",
         "```",
         "",
         "Example:",
         "```text",
         "/secret set GIFTISHOW_AUTH_KEY REAL...",
         "/secret set GIFTISHOW_TOKEN_KEY xNC...",
+        "/secret set REMOTEAGENT_TRANSFER_PASSPHRASE a-long-private-passphrase",
+        "/secret export REMOTEAGENT_TRANSFER_PASSPHRASE GIFTISHOW_AUTH_KEY GIFTISHOW_TOKEN_KEY",
         "```",
         "",
         "Then tell the agent:",
@@ -2267,6 +2496,26 @@ function formatRuntimeOptions() {
         "`command-menu refresh` reapplies Telegram slash-command autocomplete without changing the saved option.",
     ].join("\n");
 }
+function formatRuntimeOptionDetail(option) {
+    if (option === "retry") {
+        return `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``;
+    }
+    if (option === "intent") {
+        return `Current untagged intent retry limit: ${formatRetryLimit(config.telegramUntaggedIntentRetries)}\n\nUsage: \`/option intent <count>\``;
+    }
+    if (option === "command-menu") {
+        return `Current Telegram command menu: ${config.telegramCommandMenuEnabled ? "on" : "off"}\n\nUsage: \`/option command-menu on\`, \`/option command-menu off\`, or \`/option command-menu refresh\``;
+    }
+    return `Current provider execution timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)}\n\nUsage: \`/option timeout <seconds>\``;
+}
+function truncateButtonLabel(value, maxLength = 48) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3)}...`;
+}
+function workspaceLeaf(workspace) {
+    const normalized = workspace.replace(/[\\/]+$/, "");
+    return normalized.split(/[\\/]/).at(-1) || workspace;
+}
 function formatRetryLimit(value) {
     return value === 0 ? "unlimited" : `${value}`;
 }
@@ -2802,6 +3051,25 @@ async function sendTelegramDocument(botToken, chatId, document) {
     }
     return payload.result;
 }
+async function deleteTelegramMessage(botToken, chatId, messageId) {
+    const { stdout, stderr } = await execFileAsync("curl", [
+        "-sS",
+        "--max-time",
+        "20",
+        "-d",
+        `chat_id=${chatId}`,
+        "-d",
+        `message_id=${messageId}`,
+        `https://api.telegram.org/bot${botToken}/deleteMessage`,
+    ]);
+    if (stderr?.trim()) {
+        console.error(`curl stderr for deleteMessage: ${stderr.trim()}`);
+    }
+    const payload = JSON.parse(stdout);
+    if (!payload.ok) {
+        throw new Error(payload.description || "Telegram API deleteMessage failed.");
+    }
+}
 async function sendTelegramMessage(botToken, chatId, text, extra) {
     const startedAt = Date.now();
     try {