@offerpilot/axiomruntime 0.0.1

package/dist/telegram/handler-registry.js

@@ -0,0 +1,28 @@
+export class TelegramHandlerRegistry {
+    handlers = new Map();
+    register(name, registrar) {
+        const normalizedName = name.trim();
+        if (!normalizedName) {
+            throw new Error("Telegram handler name cannot be empty.");
+        }
+        this.handlers.set(normalizedName, registrar);
+    }
+    install(bot, deps) {
+        for (const registrar of this.handlers.values()) {
+            registrar(bot, deps);
+        }
+    }
+    list() {
+        return [...this.handlers.keys()];
+    }
+}
+const defaultTelegramHandlerRegistry = new TelegramHandlerRegistry();
+export function registerTelegramHandler(name, registrar) {
+    defaultTelegramHandlerRegistry.register(name, registrar);
+}
+export function installTelegramHandlers(bot, deps) {
+    defaultTelegramHandlerRegistry.install(bot, deps);
+}
+export function listTelegramHandlers() {
+    return defaultTelegramHandlerRegistry.list();
+}

package/dist/telegram/handlers/callback.js

@@ -0,0 +1,311 @@
+import { InputFile } from "grammy";
+import { Formatter } from "../interaction/formatter.js";
+import { askCustomWorkdir, completeAgentProfile, selectCli, selectReadyCli, selectReadyMode, selectReadyModel, selectSetupModel, showAgentProfile, setWorkdir, showReadyCard, showReadyCliPicker, showReadyModePicker, showReadyModelPicker, showReadyProviderPicker, showSetupModelPicker, showSetupProviderPicker, showWorkdirList, showWorkdirStart } from "./setup.js";
+import { executePrompt, runCliInit, resultStore } from "./message.js";
+import { handleMemoryManageCallback, handleRememberScopeCallback } from "./memory.js";
+import { handleProviderAdminCallback } from "./provider.js";
+import { askUsagePrice, showUsagePanel } from "./usage.js";
+import { withTelegramNetworkRetry } from "../network-retry.js";
+export function registerCallbackHandler(bot, deps) {
+    bot.on("callback_query:data", async (ctx) => {
+        const data = ctx.callbackQuery.data;
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        if (await handleProviderAdminCallback(ctx, data))
+            return;
+        if (data.startsWith("perm:")) {
+            const [, action, id] = data.split(":");
+            if (!id) {
+                await ctx.answerCallbackQuery({ text: "Invalid permission request." });
+                return;
+            }
+            if (action === "approve") {
+                deps.approvalManager.resolve(id, true);
+                await ctx.answerCallbackQuery({ text: "Allowed" });
+                return;
+            }
+            if (action === "deny" || action === "skip") {
+                deps.approvalManager.resolve(id, false);
+                await ctx.answerCallbackQuery({ text: action === "skip" ? "Skipped" : "Denied" });
+                return;
+            }
+            if (action === "approve_all") {
+                const session = deps.sessionManager.getOrCreate(chatId);
+                deps.sessionManager.update(session.id, { approveAll: true });
+                deps.approvalManager.resolve(id, true);
+                await ctx.answerCallbackQuery({ text: "Allowed for this session" });
+                return;
+            }
+        }
+        if (data.startsWith("setup:")) {
+            const [, category, action, first, second, third] = data.split(":");
+            const forcedEngine = parseTelegramEngine(category === "model" ? third : second);
+            if (category === "provider" && action === "show") {
+                await ctx.answerCallbackQuery();
+                await showSetupProviderPicker(ctx, deps, { edit: true, forcedEngine: parseTelegramEngine(first), reselect: Boolean(first) });
+                return;
+            }
+            if (category === "provider" && action === "pick" && first) {
+                await ctx.answerCallbackQuery();
+                await showSetupModelPicker(ctx, deps, Number(first), { forcedEngine });
+                return;
+            }
+            if (category === "model" && action === "pick" && first && second) {
+                await ctx.answerCallbackQuery({ text: "Provider / Model 已选择" });
+                await selectSetupModel(ctx, deps, Number(first), Number(second), { forcedEngine });
+                return;
+            }
+            if (category === "workdir" && action === "list") {
+                await ctx.answerCallbackQuery();
+                await showWorkdirList(ctx, deps, { edit: true });
+                return;
+            }
+            if (category === "workdir" && action === "list_empty") {
+                await ctx.answerCallbackQuery({ text: "还没有记录过工作路径" });
+                await showWorkdirList(ctx, deps, { edit: true });
+                return;
+            }
+            if (category === "workdir" && action === "custom") {
+                await ctx.answerCallbackQuery();
+                await askCustomWorkdir(ctx, deps);
+                return;
+            }
+            if (category === "workdir" && action === "back") {
+                const session = deps.sessionManager.getOrCreate(chatId);
+                deps.sessionManager.update(session.id, { setupStep: "workdir" });
+                await ctx.answerCallbackQuery();
+                await showWorkdirStart(ctx, deps, { edit: true });
+                return;
+            }
+            if (category === "workdir" && action === "pick" && first) {
+                const cwd = resolveWorkdirCallbackValue(first, deps.sessionManager.getWorkdirs(chatId));
+                if (!cwd) {
+                    await ctx.answerCallbackQuery({ text: "工作路径不存在" });
+                    await showWorkdirList(ctx, deps);
+                    return;
+                }
+                await ctx.answerCallbackQuery({ text: "工作路径已选择" });
+                await setWorkdir(ctx, deps, cwd, {
+                    edit: true,
+                    afterSet: (next) => runCliInit(ctx, deps, next.engine, { edit: true })
+                });
+                return;
+            }
+            if (category === "cli" && (action === "claude" || action === "codex")) {
+                await ctx.answerCallbackQuery({ text: `CLI: ${action}` });
+                await selectCli(ctx, deps, action);
+                return;
+            }
+            if (category === "agent" && action === "skip") {
+                await ctx.answerCallbackQuery({ text: "已跳过画像" });
+                await completeAgentProfile(ctx, deps, undefined, { edit: true });
+                return;
+            }
+        }
+        if (data.startsWith("ready:")) {
+            const [, category, action, first, second, third] = data.split(":");
+            const forcedEngine = parseTelegramEngine(category === "model" ? third : second);
+            if (category === "back") {
+                await ctx.answerCallbackQuery();
+                await showReadyCard(ctx, deps, deps.sessionManager.getOrCreate(chatId), { edit: true });
+                return;
+            }
+            if (category === "cli" && !action) {
+                await ctx.answerCallbackQuery();
+                await showReadyCliPicker(ctx, deps);
+                return;
+            }
+            if (category === "agent" && !action) {
+                await ctx.answerCallbackQuery();
+                await showAgentProfile(ctx, deps);
+                return;
+            }
+            if (category === "provider" && action === "show") {
+                await ctx.answerCallbackQuery();
+                await showReadyProviderPicker(ctx, deps, { forcedEngine: parseTelegramEngine(first), reselect: Boolean(first) });
+                return;
+            }
+            if (category === "cli" && action === "pick" && (first === "claude" || first === "codex")) {
+                await ctx.answerCallbackQuery({ text: `CLI: ${first}` });
+                await selectReadyCli(ctx, deps, first);
+                return;
+            }
+            if (category === "provider" && !action) {
+                await ctx.answerCallbackQuery();
+                await showReadyProviderPicker(ctx, deps);
+                return;
+            }
+            if (category === "provider" && action === "pick" && first) {
+                await ctx.answerCallbackQuery();
+                await showReadyModelPicker(ctx, deps, Number(first), { forcedEngine });
+                return;
+            }
+            if (category === "model" && action === "pick" && first && second) {
+                await ctx.answerCallbackQuery({ text: "Provider / Model 已更新" });
+                await selectReadyModel(ctx, deps, Number(first), Number(second), { forcedEngine });
+                return;
+            }
+            if (category === "mode" && !action) {
+                await ctx.answerCallbackQuery();
+                await showReadyModePicker(ctx);
+                return;
+            }
+            if (category === "mode" && action === "pick" && isTelegramPermissionMode(first)) {
+                await ctx.answerCallbackQuery({ text: "权限模式已更新" });
+                await selectReadyMode(ctx, deps, first);
+                return;
+            }
+            if (category === "workdir" && !action) {
+                const session = deps.sessionManager.getOrCreate(chatId);
+                deps.sessionManager.update(session.id, { setupStep: "workdir" });
+                await ctx.answerCallbackQuery();
+                await showWorkdirStart(ctx, deps, { edit: true, scope: "ready" });
+                return;
+            }
+            if (category === "workdir" && action === "list") {
+                await ctx.answerCallbackQuery();
+                await showWorkdirList(ctx, deps, { edit: true, scope: "ready" });
+                return;
+            }
+            if (category === "workdir" && action === "list_empty") {
+                await ctx.answerCallbackQuery({ text: "还没有记录过工作路径" });
+                await showWorkdirList(ctx, deps, { edit: true, scope: "ready" });
+                return;
+            }
+            if (category === "workdir" && action === "custom") {
+                await ctx.answerCallbackQuery();
+                await askCustomWorkdir(ctx, deps, { edit: true, returnToReady: true });
+                return;
+            }
+            if (category === "workdir" && action === "back") {
+                const session = deps.sessionManager.getOrCreate(chatId);
+                deps.sessionManager.update(session.id, { setupStep: "ready" });
+                await ctx.answerCallbackQuery();
+                await showReadyCard(ctx, deps, deps.sessionManager.getOrCreate(chatId), { edit: true });
+                return;
+            }
+            if (category === "workdir" && action === "pick" && first) {
+                const cwd = resolveWorkdirCallbackValue(first, deps.sessionManager.getWorkdirs(chatId));
+                if (!cwd) {
+                    await ctx.answerCallbackQuery({ text: "工作路径不存在" });
+                    await showWorkdirList(ctx, deps, { scope: "ready" });
+                    return;
+                }
+                await ctx.answerCallbackQuery({ text: "工作路径已更新" });
+                await setWorkdir(ctx, deps, cwd, {
+                    returnToReady: true,
+                    edit: true,
+                    afterSet: (next) => runCliInit(ctx, deps, next.engine, { edit: true })
+                });
+                return;
+            }
+        }
+        if (data.startsWith("usage:")) {
+            const [, category, action] = data.split(":");
+            if (category === "price" && action === "input") {
+                await ctx.answerCallbackQuery();
+                await askUsagePrice(ctx, deps, { edit: true });
+                return;
+            }
+            if (category === "price" && action === "unknown") {
+                await ctx.answerCallbackQuery({ text: "只显示 token" });
+                await showUsagePanel(ctx, deps, { edit: true, tokenOnly: true });
+                return;
+            }
+        }
+        if (data.startsWith("memory:remember:scope:")) {
+            const mode = parseRememberScopeMode(data.split(":")[3]);
+            if (!mode) {
+                await ctx.answerCallbackQuery({ text: "Invalid memory scope." });
+                return;
+            }
+            await ctx.answerCallbackQuery();
+            await handleRememberScopeCallback(ctx, deps, mode);
+            return;
+        }
+        if (data.startsWith("memory:manage:")) {
+            const [, , action, scope] = data.split(":");
+            await ctx.answerCallbackQuery();
+            await handleMemoryManageCallback(ctx, deps, parseMemoryManageAction(action), scope);
+            return;
+        }
+        if (data === "command:cancel") {
+            const session = deps.sessionManager.getOrCreate(chatId);
+            deps.sessionManager.update(session.id, { setupStep: "ready" });
+            await ctx.answerCallbackQuery({ text: "已关闭" });
+            await ctx.editMessageText("已关闭命令注册。", { reply_markup: { inline_keyboard: [] } });
+            return;
+        }
+        if (data === "command:back") {
+            const session = deps.sessionManager.getOrCreate(chatId);
+            deps.sessionManager.update(session.id, { setupStep: "command_name" });
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(Formatter.commandNamePrompt(), {
+                reply_markup: { inline_keyboard: [[{ text: "关闭", callback_data: "command:cancel" }]] }
+            });
+            return;
+        }
+        if (data === "retry:last") {
+            const session = deps.sessionManager.getOrCreate(chatId);
+            const lastTurn = session.conversation[session.conversation.length - 1];
+            if (!lastTurn?.user) {
+                await ctx.answerCallbackQuery({ text: "没有可重试的消息" });
+                return;
+            }
+            await ctx.answerCallbackQuery({ text: "正在重新执行…" });
+            await executePrompt(ctx, deps, lastTurn.user);
+            return;
+        }
+        if (data.startsWith("result:")) {
+            const action = data.slice("result:".length);
+            const cached = resultStore.get(chatId);
+            if (action === "full") {
+                if (!cached?.response) {
+                    await ctx.answerCallbackQuery({ text: "输出已过期" });
+                    return;
+                }
+                await ctx.answerCallbackQuery();
+                await withTelegramNetworkRetry(() => ctx.replyWithDocument(new InputFile(Buffer.from(cached.response, "utf8"), "output.md"), { caption: "完整输出" }));
+                return;
+            }
+            if (action === "diff") {
+                if (!cached?.diff) {
+                    await ctx.answerCallbackQuery({ text: "Diff 已过期" });
+                    return;
+                }
+                await ctx.answerCallbackQuery();
+                await withTelegramNetworkRetry(() => ctx.replyWithDocument(new InputFile(Buffer.from(cached.diff, "utf8"), "changes.diff"), { caption: "Diff" }));
+                return;
+            }
+        }
+        await ctx.answerCallbackQuery();
+    });
+}
+function resolveWorkdirCallbackValue(value, workdirs) {
+    if (/^\d+$/.test(value)) {
+        return workdirs[Number(value)] ?? null;
+    }
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return null;
+    }
+}
+function isTelegramPermissionMode(value) {
+    return value === "default" || value === "acceptEdits" || value === "bypassPermissions";
+}
+function parseTelegramEngine(value) {
+    return value === "claude" || value === "codex" ? value : undefined;
+}
+function parseRememberScopeMode(value) {
+    return value === "global" || value === "bot" || value === "auto" ? value : null;
+}
+function parseMemoryManageAction(value) {
+    if (value === "promote" || value === "clear" || value === "clear_confirm")
+        return value;
+    return "panel";
+}

package/dist/telegram/handlers/command.js

@@ -0,0 +1,272 @@
+import fs from "node:fs";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { InputFile } from "grammy";
+import { createCommandPermissionRequest } from "../engine/engine-utils.js";
+import { requiresDangerousConfirmation } from "../interaction/approval.js";
+import { safeResetChatCommandMenu, safeSetChatCommandMenu } from "../interaction/command-menu.js";
+import { Formatter, escapeHtml } from "../interaction/formatter.js";
+import { runCliInit } from "./message.js";
+import { handleForgetCommand, handleMemoriesCommand, handleMemoryCommand, handleRememberCommand } from "./memory.js";
+import { showProviderAdminPanel } from "./provider.js";
+import { showConfigPanel, showReadyProviderPicker, showSetupProviderPicker, showWorkdirStart, startSetup } from "./setup.js";
+import { showUsagePanel } from "./usage.js";
+import { writeTelegramLog } from "../log.js";
+const execAsync = promisify(exec);
+const FRESH_DELETE_SCAN_LIMIT = 1000;
+const TELEGRAM_DELETE_BATCH_SIZE = 100;
+const START_COMMAND_DEDUP_MS = 10000;
+const recentStartCommands = new Map();
+export function registerCommands(bot, deps) {
+    bot.command("start", async (ctx) => {
+        if (!shouldHandleStartCommand(ctx.chat.id)) {
+            await safeDeleteCommandMessage(ctx);
+            return;
+        }
+        await safeResetChatCommandMenu(bot, ctx.chat.id);
+        await startSetup(ctx, deps);
+    });
+    bot.command("reset", async (ctx) => {
+        deps.engines.claude.abort(ctx.chat.id);
+        deps.engines.codex.abort(ctx.chat.id);
+        deps.approvalManager.resolveAll(ctx.chat.id, false);
+        await safeResetChatCommandMenu(bot, ctx.chat.id);
+        await startSetup(ctx, deps);
+    });
+    bot.command("stop", async (ctx) => {
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        if (session.status !== "running" && session.status !== "waiting_approval") {
+            await ctx.reply("当前没有正在运行的任务。");
+            return;
+        }
+        deps.engines.claude.abort(ctx.chat.id);
+        deps.engines.codex.abort(ctx.chat.id);
+        deps.approvalManager.resolveAll(ctx.chat.id, false);
+        deps.sessionManager.update(session.id, { status: "idle" });
+        const hasLastMessage = session.conversation.length > 0;
+        await ctx.reply("已停止当前任务。", hasLastMessage ? {
+            reply_markup: { inline_keyboard: [[{ text: "🔁 重新执行上一条", callback_data: "retry:last" }]] }
+        } : undefined);
+    });
+    bot.command("fresh", async (ctx) => {
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        if (session.status === "running" || session.status === "waiting_approval") {
+            await ctx.reply("已有任务正在运行，请等待完成。");
+            return;
+        }
+        await ctx.reply(Formatter.sessionCleared(session), { parse_mode: "HTML" });
+        await deleteRecentChatMessages(ctx, ctx.chat.id, ctx.message?.message_id);
+    });
+    bot.command("config", async (ctx) => {
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        await showConfigPanel(ctx, deps, session);
+    });
+    bot.command("model", async (ctx) => {
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        if (session.setupStep === "ready") {
+            await showReadyProviderPicker(ctx, deps, { reselect: true });
+            return;
+        }
+        await showSetupProviderPicker(ctx, deps, { reselect: true });
+    });
+    bot.command("provider", async (ctx) => {
+        await showProviderAdminPanel(ctx);
+    });
+    bot.command("usage", async (ctx) => {
+        await showUsagePanel(ctx, deps);
+    });
+    bot.command("remember", async (ctx) => {
+        await handleRememberCommand(ctx, deps);
+    });
+    bot.command("forget", async (ctx) => {
+        await handleForgetCommand(ctx, deps);
+    });
+    bot.command("memories", async (ctx) => {
+        await handleMemoriesCommand(ctx, deps);
+    });
+    bot.command("memory", async (ctx) => {
+        await handleMemoryCommand(ctx, deps);
+    });
+    bot.command("usge", async (ctx) => {
+        await showUsagePanel(ctx, deps);
+    });
+    bot.command("help", async (ctx) => {
+        await ctx.reply(Formatter.help(), { parse_mode: "HTML" });
+    });
+    bot.command("claude", async (ctx) => {
+        await runEngineCommand(ctx, deps, bot, "claude");
+    });
+    bot.command("codex", async (ctx) => {
+        await runEngineCommand(ctx, deps, bot, "codex");
+    });
+    bot.command("cwd", async (ctx) => {
+        const cwd = String(ctx.match ?? "").trim();
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        if (!cwd) {
+            deps.sessionManager.update(session.id, { setupStep: "ready" });
+            await showWorkdirStart(ctx, deps, { scope: "ready", prompt: Formatter.workdirChangePrompt() });
+            return;
+        }
+        if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+            await ctx.reply(`Directory not found: <code>${escapeHtml(cwd)}</code>`, { parse_mode: "HTML" });
+            return;
+        }
+        const next = deps.sessionManager.update(session.id, {
+            cwd,
+            engineSessionId: null,
+            botContextFingerprint: null
+        });
+        await runCliInit(ctx, deps, next.engine);
+        const customCommands = deps.sessionManager.listCustomCommands(ctx.chat.id, cwd);
+        await safeSetChatCommandMenu(bot, ctx.chat.id, next.engine, customCommands);
+        await ctx.reply(`cwd: <code>${escapeHtml(cwd)}</code>`, { parse_mode: "HTML" });
+    });
+    bot.command("command", async (ctx) => {
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        const next = deps.sessionManager.update(session.id, { setupStep: "command_name" });
+        void writeTelegramLog({ action: "command_register_start", message: `chatId=${ctx.chat.id} sessionId=${session.id} before=${session.setupStep} after=${next.setupStep}` });
+        await ctx.reply(Formatter.commandNamePrompt(), {
+            reply_markup: { inline_keyboard: [[{ text: "关闭", callback_data: "command:cancel" }]] }
+        });
+    });
+    bot.command("pin", async (ctx) => {
+        const reply = ctx.message?.reply_to_message;
+        if (!reply) {
+            await ctx.reply("用法：回复一条 bot 消息并发送 /pin 来固定该对话。");
+            return;
+        }
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        const replyText = "text" in reply ? reply.text : "caption" in reply ? reply.caption : undefined;
+        const normalizedReply = normalizePinText(replyText ?? "");
+        const turn = [...session.conversation].reverse().find((item) => {
+            const assistant = normalizePinText(item.assistant);
+            const sample = assistant.slice(0, Math.min(80, assistant.length));
+            return Boolean(sample && (normalizedReply.includes(sample) || assistant.includes(normalizedReply)));
+        });
+        if (!turn) {
+            await ctx.reply("未找到对应的对话记录，只能固定 bot 回复的消息。");
+            return;
+        }
+        deps.sessionManager.pinTurn(ctx.chat.id, reply.message_id, { user: turn.user, assistant: turn.assistant });
+        await ctx.reply("📌 已固定该对话，后续请求会优先携带此上下文。");
+    });
+    bot.command("unpin", async (ctx) => {
+        const reply = ctx.message?.reply_to_message;
+        if (!reply) {
+            const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+            if (!session.pinnedTurns.length) {
+                await ctx.reply("当前没有固定的对话。");
+                return;
+            }
+            deps.sessionManager.unpinTurn(ctx.chat.id, session.pinnedTurns[session.pinnedTurns.length - 1].messageId);
+            await ctx.reply("已取消最近一条固定对话。");
+            return;
+        }
+        deps.sessionManager.unpinTurn(ctx.chat.id, reply.message_id);
+        await ctx.reply("已取消固定该对话。");
+    });
+    bot.command("terminal", async (ctx) => {
+        const shell = String(ctx.match ?? "").trim();
+        if (!shell) {
+            await ctx.reply("用法：<code>/terminal &lt;命令&gt;</code>\n例如：<code>/terminal ls -la</code>", { parse_mode: "HTML" });
+            return;
+        }
+        const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+        const cwd = session.cwd || process.cwd();
+        if (requiresDangerousConfirmation(shell)) {
+            deps.sessionManager.update(session.id, { status: "waiting_approval" });
+            const approved = await deps.approvalManager.request(ctx.chat.id, createCommandPermissionRequest("Telegram terminal", shell));
+            deps.sessionManager.update(session.id, { status: "idle" });
+            if (!approved) {
+                await ctx.reply("已取消高风险终端命令。");
+                return;
+            }
+        }
+        await ctx.reply(`⚙️ 执行中：<code>${escapeHtml(shell)}</code>`, { parse_mode: "HTML" });
+        try {
+            const { stdout, stderr } = await execAsync(shell, { cwd, timeout: 60_000, maxBuffer: 10 * 1024 * 1024 });
+            const output = (stdout || stderr || "（无输出）").trim();
+            if (output.length <= 3800) {
+                await ctx.reply(`<pre>${escapeHtml(output)}</pre>`, { parse_mode: "HTML" });
+            }
+            else {
+                await ctx.replyWithDocument(new InputFile(Buffer.from(output, "utf-8"), "output.txt"));
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.length <= 3800) {
+                await ctx.reply(`❌ 执行失败：\n<pre>${escapeHtml(msg)}</pre>`, { parse_mode: "HTML" });
+            }
+            else {
+                await ctx.replyWithDocument(new InputFile(Buffer.from(msg, "utf-8"), "error.txt"));
+            }
+        }
+    });
+    bot.command("restart", async (ctx) => {
+        await ctx.reply("🔄 Bot 正在重启…");
+        setTimeout(() => process.kill(process.pid, "SIGHUP"), 500).unref?.();
+    });
+}
+function normalizePinText(value) {
+    return value
+        .replace(/^✅\s*完成(?:\s*·[^\n]+)?/u, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function shouldHandleStartCommand(chatId, now = Date.now(), recent = recentStartCommands) {
+    const previous = recent.get(chatId);
+    recent.set(chatId, now);
+    return !previous || now - previous > START_COMMAND_DEDUP_MS;
+}
+async function safeDeleteCommandMessage(ctx) {
+    try {
+        await ctx.deleteMessage();
+    }
+    catch {
+        // The duplicate /start prompt is best-effort cleanup only.
+    }
+}
+async function runEngineCommand(ctx, deps, bot, engine) {
+    const session = deps.sessionManager.getOrCreate(ctx.chat.id);
+    if (session.setupStep !== "ready") {
+        await showSetupProviderPicker(ctx, deps, { forcedEngine: engine, reselect: true });
+        return;
+    }
+    const customCommands = deps.sessionManager.listCustomCommands(ctx.chat.id, session.cwd);
+    await safeSetChatCommandMenu(bot, ctx.chat.id, engine, customCommands);
+    await showReadyProviderPicker(ctx, deps, { forcedEngine: engine, reselect: true });
+}
+export async function deleteRecentChatMessages(ctx, chatId, fromMessageId, scanLimit = FRESH_DELETE_SCAN_LIMIT) {
+    if (!fromMessageId || scanLimit <= 0)
+        return 0;
+    const messageIds = [];
+    for (let messageId = fromMessageId; messageId > 0 && messageIds.length < scanLimit; messageId -= 1) {
+        messageIds.push(messageId);
+    }
+    let deleted = 0;
+    for (let index = 0; index < messageIds.length; index += TELEGRAM_DELETE_BATCH_SIZE) {
+        const batch = messageIds.slice(index, index + TELEGRAM_DELETE_BATCH_SIZE);
+        try {
+            await ctx.api.deleteMessages(chatId, batch);
+            deleted += batch.length;
+        }
+        catch {
+            deleted += await deleteMessagesIndividually(ctx, chatId, batch);
+        }
+    }
+    return deleted;
+}
+async function deleteMessagesIndividually(ctx, chatId, messageIds) {
+    let deleted = 0;
+    for (const messageId of messageIds) {
+        try {
+            await ctx.api.deleteMessage(chatId, messageId);
+            deleted += 1;
+        }
+        catch {
+            // Old, already deleted, or unauthorized messages are skipped.
+        }
+    }
+    return deleted;
+}