@grinev/opencode-telegram-bot 0.3.0 → 0.5.0

package/dist/bot/middleware/interaction-guard.js

@@ -0,0 +1,80 @@
+import { resolveInteractionGuardDecision } from "../../interaction/guard.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+function getInteractionBlockedMessage(reason, interactionKind) {
+    if (interactionKind === "permission") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("permission.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("permission.blocked.expected_reply");
+        }
+    }
+    if (interactionKind === "inline") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("inline.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("inline.blocked.expected_choice");
+        }
+    }
+    if (interactionKind === "question") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("question.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("question.blocked.expected_answer");
+        }
+    }
+    if (interactionKind === "rename") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("rename.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("rename.blocked.expected_name");
+        }
+    }
+    switch (reason) {
+        case "expired":
+            return t("interaction.blocked.expired");
+        case "expected_callback":
+            return t("interaction.blocked.expected_callback");
+        case "expected_command":
+            return t("interaction.blocked.expected_command");
+        case "command_not_allowed":
+            return t("interaction.blocked.command_not_allowed");
+        case "expected_text":
+        default:
+            return t("interaction.blocked.expected_text");
+    }
+}
+export async function interactionGuardMiddleware(ctx, next) {
+    const decision = resolveInteractionGuardDecision(ctx);
+    if (decision.allow) {
+        await next();
+        return;
+    }
+    const message = getInteractionBlockedMessage(decision.reason, decision.state?.kind);
+    logger.debug(`[InteractionGuard] Blocked input: interactionKind=${decision.state?.kind || "none"}, inputType=${decision.inputType}, reason=${decision.reason || "unknown"}, command=${decision.command || "-"}`);
+    if (ctx.callbackQuery) {
+        await ctx.answerCallbackQuery({ text: message }).catch(() => { });
+        return;
+    }
+    if (ctx.chat) {
+        await ctx.reply(message).catch((err) => {
+            logger.error("[InteractionGuard] Failed to send blocked input message:", err);
+        });
+    }
+}

package/dist/bot/middleware/unknown-command.js

@@ -0,0 +1,22 @@
+import { extractCommandName, isKnownCommand } from "../utils/commands.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+export async function unknownCommandMiddleware(ctx, next) {
+    const text = ctx.message?.text;
+    if (!text) {
+        await next();
+        return;
+    }
+    const commandName = extractCommandName(text);
+    if (!commandName) {
+        await next();
+        return;
+    }
+    if (isKnownCommand(commandName)) {
+        await next();
+        return;
+    }
+    const commandToken = text.trim().split(/\s+/)[0];
+    logger.debug(`[Bot] Unknown slash command received: ${commandToken}`);
+    await ctx.reply(t("bot.unknown_command", { command: commandToken }));
+}

package/dist/bot/utils/commands.js

@@ -0,0 +1,21 @@
+import { BOT_COMMANDS } from "../commands/definitions.js";
+const KNOWN_COMMANDS = new Set(["start", ...BOT_COMMANDS.map((item) => item.command)]);
+export function extractCommandName(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const token = trimmed.split(/\s+/)[0];
+    const withoutSlash = token.slice(1);
+    if (!withoutSlash) {
+        return null;
+    }
+    const withoutMention = withoutSlash.split("@")[0].toLowerCase();
+    if (!withoutMention) {
+        return null;
+    }
+    return withoutMention;
+}
+export function isKnownCommand(commandName) {
+    return KNOWN_COMMANDS.has(commandName);
+}

package/dist/i18n/en.js

@@ -16,6 +16,19 @@ export const en = {
     "error.load_variants": "❌ Failed to load variants list",
     "error.context_button": "❌ Failed to process context button",
     "error.generic": "🔴 Something went wrong.",
+    "interaction.blocked.expired": "⚠️ This interaction has expired. Please start it again.",
+    "interaction.blocked.expected_callback": "⚠️ Please use the inline buttons for this step or tap Cancel.",
+    "interaction.blocked.expected_text": "⚠️ Please send a text message for this step.",
+    "interaction.blocked.expected_command": "⚠️ Please send a command for this step.",
+    "interaction.blocked.command_not_allowed": "⚠️ This command is not available in the current step.",
+    "interaction.blocked.finish_current": "⚠️ Finish the current interaction first (answer or cancel), then open another menu.",
+    "inline.blocked.expected_choice": "⚠️ Choose an option using the inline buttons or tap Cancel.",
+    "inline.blocked.command_not_allowed": "⚠️ This command is not available while inline menu is active.",
+    "question.blocked.expected_answer": "⚠️ Answer the current question using buttons, Custom answer, or Cancel.",
+    "question.blocked.command_not_allowed": "⚠️ This command is not available until current question flow is completed.",
+    "inline.button.cancel": "❌ Cancel",
+    "inline.inactive_callback": "This menu is inactive",
+    "inline.cancelled_callback": "Cancelled",
     "common.unknown": "unknown",
     "common.unknown_error": "unknown error",
     "start.welcome": "👋 Welcome to OpenCode Telegram Bot!\n\nUse commands:\n/projects — select project\n/sessions — session list\n/new — new session\n/agent — switch mode\n/model — select model\n/status — status\n/help — help",
@@ -29,6 +42,7 @@ export const en = {
     "bot.session_reset_project_mismatch": "⚠️ Active session does not match the selected project, so it was reset. Use /sessions to pick one or /new to create a new session.",
     "bot.prompt_send_error_detailed": "🔴 Failed to send request.\n\nDetails: {details}",
     "bot.prompt_send_error": "🔴 An error occurred while sending request to OpenCode.",
+    "bot.unknown_command": "⚠️ Unknown command: {command}. Use /help to see available commands.",
     "status.header_running": "🟢 **OpenCode Server is running**",
     "status.health.healthy": "Healthy",
     "status.health.unhealthy": "Unhealthy",
@@ -111,7 +125,6 @@ export const en = {
     "variant.menu.current": "Current variant: {name}\n\nSelect variant:",
     "variant.menu.error": "🔴 Failed to get variants list",
     "context.button.confirm": "✅ Yes, compact context",
-    "context.button.cancel": "❌ Cancel",
     "context.no_active_session": "⚠️ No active session. Create a session with /new",
     "context.confirm_text": '📊 Context compaction for session "{title}"\n\nThis will reduce context usage by removing old messages from history. Current task will not be interrupted.\n\nContinue?',
     "context.callback_session_not_found": "Session not found",
@@ -119,7 +132,6 @@ export const en = {
     "context.progress": "⏳ Compacting context...",
     "context.error": "❌ Context compaction failed",
     "context.success": "✅ Context compacted successfully",
-    "context.callback_cancelled": "Cancelled",
     "permission.inactive_callback": "Permission request is inactive",
     "permission.processing_error_callback": "Processing error",
     "permission.no_active_request_callback": "Error: no active request",
@@ -127,9 +139,11 @@ export const en = {
     "permission.reply.always": "Always allowed",
     "permission.reply.reject": "Rejected",
     "permission.send_reply_error": "❌ Failed to send permission reply",
+    "permission.blocked.expected_reply": "⚠️ Please answer the permission request first using the buttons above.",
+    "permission.blocked.command_not_allowed": "⚠️ This command is not available until you answer the permission request.",
     "permission.header": "{emoji} **Permission request: {name}**\n\n",
-    "permission.button.allow": "✅ Allow",
-    "permission.button.always": "🔓 Always",
+    "permission.button.allow": "✅ Allow once",
+    "permission.button.always": "🔓 Allow always",
     "permission.button.reject": "❌ Reject",
     "permission.name.bash": "Bash",
     "permission.name.edit": "Edit",
@@ -156,6 +170,7 @@ export const en = {
     "question.button.submit": "✅ Done",
     "question.button.custom": "🔤 Custom answer",
     "question.button.cancel": "❌ Cancel",
+    "question.use_custom_button_first": '⚠️ To send text, tap "Custom answer" for the current question first.',
     "question.summary.title": "✅ Poll completed!\n\n",
     "question.summary.question": "Question {index}:\n{question}\n\n",
     "question.summary.answer": "Answer:\n{answer}\n\n",
@@ -187,6 +202,18 @@ export const en = {
     "runtime.wizard.saved": "Configuration saved:\n- {envPath}\n- {settingsPath}\n",
     "runtime.wizard.not_configured_starting": "Application is not configured yet. Starting wizard...\n",
     "runtime.wizard.tty_required": "Interactive wizard requires a TTY terminal. Run `opencode-telegram config` in an interactive shell.",
+    "rename.no_session": "⚠️ No active session. Create or select a session first.",
+    "rename.prompt": "📝 Enter new title for session:\n\nCurrent: {title}",
+    "rename.empty_title": "⚠️ Title cannot be empty.",
+    "rename.success": "✅ Session renamed to: {title}",
+    "rename.error": "🔴 Failed to rename session.",
+    "rename.cancelled": "❌ Rename cancelled.",
+    "rename.inactive_callback": "Rename request is inactive",
+    "rename.inactive": "⚠️ Rename request is not active. Run /rename again.",
+    "rename.blocked.expected_name": "⚠️ Enter a new session name as text or tap Cancel in rename message.",
+    "rename.blocked.command_not_allowed": "⚠️ This command is not available while rename is waiting for a new name.",
+    "rename.button.cancel": "❌ Cancel",
+    "cmd.description.rename": "Rename current session",
     "cli.usage": "Usage:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nNotes:\n  - No command defaults to `start`\n  - `--mode` is currently supported for `start` only",
     "cli.placeholder.status": "Command `status` is currently a placeholder. Real status checks will be added in service layer (Phase 5).",
     "cli.placeholder.stop": "Command `stop` is currently a placeholder. Real background process stop will be added in service layer (Phase 5).",

package/dist/i18n/ru.js

@@ -16,6 +16,19 @@ export const ru = {
     "error.load_variants": "❌ Ошибка при загрузке списка вариантов",
     "error.context_button": "❌ Ошибка при обработке кнопки контекста",
     "error.generic": "🔴 Произошла ошибка.",
+    "interaction.blocked.expired": "⚠️ Текущая интеракция устарела. Запустите ее снова.",
+    "interaction.blocked.expected_callback": "⚠️ Для этого шага используйте inline-кнопки или нажмите Отмена.",
+    "interaction.blocked.expected_text": "⚠️ Для этого шага отправьте текстовое сообщение.",
+    "interaction.blocked.expected_command": "⚠️ Для этого шага отправьте команду.",
+    "interaction.blocked.command_not_allowed": "⚠️ Эта команда недоступна на текущем шаге.",
+    "interaction.blocked.finish_current": "⚠️ Сначала завершите текущую интеракцию (ответьте или отмените), затем откройте другое меню.",
+    "inline.blocked.expected_choice": "⚠️ Выберите вариант через inline-кнопки или нажмите Отмена.",
+    "inline.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока активно inline-меню.",
+    "question.blocked.expected_answer": "⚠️ Ответьте на текущий вопрос кнопками, через Свой ответ, или нажмите Отмена.",
+    "question.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока не завершен текущий опрос.",
+    "inline.button.cancel": "❌ Отмена",
+    "inline.inactive_callback": "Это меню уже неактивно",
+    "inline.cancelled_callback": "Отменено",
     "common.unknown": "неизвестна",
     "common.unknown_error": "неизвестная ошибка",
     "start.welcome": "👋 Добро пожаловать в OpenCode Telegram Bot!\n\nИспользуйте команды:\n/projects — выбрать проект\n/sessions — список сессий\n/new — новая сессия\n/agent — сменить режим\n/model — выбрать модель\n/status — статус\n/help — справка",
@@ -29,6 +42,7 @@ export const ru = {
     "bot.session_reset_project_mismatch": "⚠️ Активная сессия не соответствует выбранному проекту, поэтому была сброшена. Используйте /sessions для выбора или /new для создания новой сессии.",
     "bot.prompt_send_error_detailed": "🔴 Ошибка при отправке запроса.\n\nДетали: {details}",
     "bot.prompt_send_error": "🔴 Произошла ошибка при отправке запроса в OpenCode.",
+    "bot.unknown_command": "⚠️ Неизвестная команда: {command}. Используйте /help для списка команд.",
     "status.header_running": "🟢 **OpenCode Server запущен**",
     "status.health.healthy": "Healthy",
     "status.health.unhealthy": "Unhealthy",
@@ -111,7 +125,6 @@ export const ru = {
     "variant.menu.current": "Текущий variant: {name}\n\nВыберите variant:",
     "variant.menu.error": "🔴 Не удалось получить список вариантов",
     "context.button.confirm": "✅ Да, сжать контекст",
-    "context.button.cancel": "❌ Отмена",
     "context.no_active_session": "⚠️ Нет активной сессии. Создайте сессию командой /new",
     "context.confirm_text": '📊 Сжатие контекста для сессии "{title}"\n\nЭто уменьшит использование контекста, удалив старые сообщения из истории. Текущая задача не будет прервана.\n\nПродолжить?',
     "context.callback_session_not_found": "Сессия не найдена",
@@ -119,7 +132,6 @@ export const ru = {
     "context.progress": "⏳ Сжимаю контекст...",
     "context.error": "❌ Ошибка при сжатии контекста",
     "context.success": "✅ Контекст успешно сжат",
-    "context.callback_cancelled": "Отменено",
     "permission.inactive_callback": "Запрос разрешения неактивен",
     "permission.processing_error_callback": "Ошибка при обработке",
     "permission.no_active_request_callback": "Ошибка: нет активного запроса",
@@ -127,9 +139,11 @@ export const ru = {
     "permission.reply.always": "Разрешено всегда",
     "permission.reply.reject": "Отклонено",
     "permission.send_reply_error": "❌ Не удалось отправить ответ на запрос разрешения",
+    "permission.blocked.expected_reply": "⚠️ Сначала ответьте на запрос разрешения кнопками выше.",
+    "permission.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока вы не ответите на запрос разрешения.",
     "permission.header": "{emoji} **Запрос разрешения: {name}**\n\n",
-    "permission.button.allow": "✅ Разрешить",
-    "permission.button.always": "🔓 Всегда",
+    "permission.button.allow": "✅ Разрешить один раз",
+    "permission.button.always": "🔓 Разрешить всегда",
     "permission.button.reject": "❌ Отклонить",
     "permission.name.bash": "Bash",
     "permission.name.edit": "Edit",
@@ -156,6 +170,7 @@ export const ru = {
     "question.button.submit": "✅ Готово",
     "question.button.custom": "🔤 Свой ответ",
     "question.button.cancel": "❌ Отмена",
+    "question.use_custom_button_first": '⚠️ Чтобы отправить текст, сначала нажмите кнопку "Свой ответ" для текущего вопроса.',
     "question.summary.title": "✅ Опрос завершен!\n\n",
     "question.summary.question": "Вопрос {index}:\n{question}\n\n",
     "question.summary.answer": "Ответ:\n{answer}\n\n",
@@ -187,6 +202,18 @@ export const ru = {
     "runtime.wizard.saved": "Конфигурация сохранена:\n- {envPath}\n- {settingsPath}\n",
     "runtime.wizard.not_configured_starting": "Приложение еще не сконфигурировано. Запускаю wizard...\n",
     "runtime.wizard.tty_required": "Интерактивный wizard требует TTY-терминал. Запустите `opencode-telegram config` в интерактивной оболочке.",
+    "rename.no_session": "⚠️ Нет активной сессии. Сначала создайте или выберите сессию.",
+    "rename.prompt": "📝 Введите новое название сессии:\n\nТекущее: {title}",
+    "rename.empty_title": "⚠️ Название не может быть пустым.",
+    "rename.success": "✅ Сессия переименована в: {title}",
+    "rename.error": "🔴 Не удалось переименовать сессию.",
+    "rename.cancelled": "❌ Переименование отменено.",
+    "rename.inactive_callback": "Запрос переименования неактивен",
+    "rename.inactive": "⚠️ Запрос переименования неактивен. Выполните /rename снова.",
+    "rename.blocked.expected_name": "⚠️ Введите новое название текстом или нажмите Отмена в сообщении переименования.",
+    "rename.blocked.command_not_allowed": "⚠️ Эта команда недоступна, пока ожидается новое название сессии.",
+    "rename.button.cancel": "❌ Отмена",
+    "cmd.description.rename": "Переименовать текущую сессию",
     "cli.usage": "Использование:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nЗаметки:\n  - Без команды по умолчанию используется `start`\n  - `--mode` сейчас поддерживается только для `start`",
     "cli.placeholder.status": "Команда `status` пока работает как заглушка. Реальная проверка статуса появится на этапе service-слоя (Этап 5).",
     "cli.placeholder.stop": "Команда `stop` пока работает как заглушка. Реальная остановка фонового процесса появится на этапе service-слоя (Этап 5).",

package/dist/interaction/cleanup.js

@@ -0,0 +1,24 @@
+import { permissionManager } from "../permission/manager.js";
+import { questionManager } from "../question/manager.js";
+import { renameManager } from "../rename/manager.js";
+import { interactionManager } from "./manager.js";
+import { logger } from "../utils/logger.js";
+export function clearAllInteractionState(reason) {
+    const questionActive = questionManager.isActive();
+    const permissionActive = permissionManager.isActive();
+    const renameActive = renameManager.isWaitingForName();
+    const interactionSnapshot = interactionManager.getSnapshot();
+    questionManager.clear();
+    permissionManager.clear();
+    renameManager.clear();
+    interactionManager.clear(reason);
+    const hasAnyActiveState = questionActive || permissionActive || renameActive || interactionSnapshot !== null;
+    const message = `[InteractionCleanup] Cleared state: reason=${reason}, ` +
+        `questionActive=${questionActive}, permissionActive=${permissionActive}, ` +
+        `renameActive=${renameActive}, interactionKind=${interactionSnapshot?.kind || "none"}`;
+    if (hasAnyActiveState) {
+        logger.info(message);
+        return;
+    }
+    logger.debug(message);
+}

package/dist/interaction/guard.js

@@ -0,0 +1,87 @@
+import { interactionManager } from "./manager.js";
+function normalizeIncomingCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const token = trimmed.split(/\s+/)[0];
+    const withoutMention = token.split("@")[0].toLowerCase();
+    if (withoutMention.length <= 1) {
+        return null;
+    }
+    return withoutMention;
+}
+function classifyIncomingInput(ctx) {
+    if (ctx.callbackQuery?.data) {
+        return { inputType: "callback" };
+    }
+    const text = ctx.message?.text;
+    if (typeof text === "string") {
+        const command = normalizeIncomingCommand(text);
+        if (command) {
+            return { inputType: "command", command };
+        }
+        return { inputType: "text" };
+    }
+    return { inputType: "other" };
+}
+function getExpectedInputBlockReason(expectedInput) {
+    switch (expectedInput) {
+        case "callback":
+            return "expected_callback";
+        case "command":
+            return "expected_command";
+        case "text":
+        case "mixed":
+            return "expected_text";
+    }
+}
+function createAllowDecision(inputType, state, command) {
+    return {
+        allow: true,
+        inputType,
+        state,
+        command,
+    };
+}
+function createBlockDecision(inputType, state, reason, command) {
+    return {
+        allow: false,
+        inputType,
+        state,
+        reason,
+        command,
+    };
+}
+function isAllowedRenameCancelCallback(ctx, state) {
+    return (state.kind === "rename" &&
+        state.expectedInput === "text" &&
+        ctx.callbackQuery?.data === "rename:cancel");
+}
+export function resolveInteractionGuardDecision(ctx) {
+    const state = interactionManager.getSnapshot();
+    const { inputType, command } = classifyIncomingInput(ctx);
+    if (!state) {
+        return createAllowDecision(inputType, null, command);
+    }
+    if (interactionManager.isExpired()) {
+        interactionManager.clear("expired");
+        return createBlockDecision(inputType, state, "expired", command);
+    }
+    if (inputType === "command") {
+        if (command && state.allowedCommands.includes(command)) {
+            return createAllowDecision(inputType, state, command);
+        }
+        return createBlockDecision(inputType, state, "command_not_allowed", command);
+    }
+    if (state.expectedInput === "mixed") {
+        return createAllowDecision(inputType, state, command);
+    }
+    if (inputType === "callback" && isAllowedRenameCancelCallback(ctx, state)) {
+        return createAllowDecision(inputType, state, command);
+    }
+    if (state.expectedInput === inputType) {
+        return createAllowDecision(inputType, state, command);
+    }
+    return createBlockDecision(inputType, state, getExpectedInputBlockReason(state.expectedInput), command);
+}

package/dist/interaction/manager.js

@@ -0,0 +1,106 @@
+import { logger } from "../utils/logger.js";
+export const DEFAULT_ALLOWED_INTERACTION_COMMANDS = ["/help", "/status", "/stop"];
+function normalizeCommand(command) {
+    const trimmed = command.trim().toLowerCase();
+    if (!trimmed) {
+        return null;
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const withoutMention = withSlash.split("@")[0];
+    if (withoutMention.length <= 1) {
+        return null;
+    }
+    return withoutMention;
+}
+function normalizeAllowedCommands(commands) {
+    if (commands === undefined) {
+        return [...DEFAULT_ALLOWED_INTERACTION_COMMANDS];
+    }
+    const normalized = new Set();
+    for (const command of commands) {
+        const value = normalizeCommand(command);
+        if (value) {
+            normalized.add(value);
+        }
+    }
+    return Array.from(normalized);
+}
+function cloneState(state) {
+    return {
+        ...state,
+        allowedCommands: [...state.allowedCommands],
+        metadata: { ...state.metadata },
+    };
+}
+class InteractionManager {
+    state = null;
+    start(options) {
+        const now = Date.now();
+        let expiresAt = null;
+        if (this.state) {
+            this.clear("state_replaced");
+        }
+        if (typeof options.expiresInMs === "number") {
+            expiresAt = now + options.expiresInMs;
+        }
+        const nextState = {
+            kind: options.kind,
+            expectedInput: options.expectedInput,
+            allowedCommands: normalizeAllowedCommands(options.allowedCommands),
+            metadata: options.metadata ? { ...options.metadata } : {},
+            createdAt: now,
+            expiresAt,
+        };
+        this.state = nextState;
+        logger.info(`[InteractionManager] Started interaction: kind=${nextState.kind}, expectedInput=${nextState.expectedInput}, allowedCommands=${nextState.allowedCommands.join(",") || "none"}`);
+        return cloneState(nextState);
+    }
+    get() {
+        if (!this.state) {
+            return null;
+        }
+        return cloneState(this.state);
+    }
+    getSnapshot() {
+        return this.get();
+    }
+    isActive() {
+        return this.state !== null;
+    }
+    isExpired(referenceTimeMs = Date.now()) {
+        if (!this.state || this.state.expiresAt === null) {
+            return false;
+        }
+        return referenceTimeMs >= this.state.expiresAt;
+    }
+    transition(options) {
+        if (!this.state) {
+            return null;
+        }
+        const now = Date.now();
+        this.state = {
+            ...this.state,
+            kind: options.kind ?? this.state.kind,
+            expectedInput: options.expectedInput ?? this.state.expectedInput,
+            allowedCommands: options.allowedCommands !== undefined
+                ? normalizeAllowedCommands(options.allowedCommands)
+                : [...this.state.allowedCommands],
+            metadata: options.metadata ? { ...options.metadata } : { ...this.state.metadata },
+            expiresAt: options.expiresInMs === undefined
+                ? this.state.expiresAt
+                : options.expiresInMs === null
+                    ? null
+                    : now + options.expiresInMs,
+        };
+        logger.debug(`[InteractionManager] Transitioned interaction: kind=${this.state.kind}, expectedInput=${this.state.expectedInput}, allowedCommands=${this.state.allowedCommands.join(",") || "none"}`);
+        return cloneState(this.state);
+    }
+    clear(reason = "manual") {
+        if (!this.state) {
+            return;
+        }
+        logger.info(`[InteractionManager] Cleared interaction: reason=${reason}, kind=${this.state.kind}, expectedInput=${this.state.expectedInput}`);
+        this.state = null;
+    }
+}
+export const interactionManager = new InteractionManager();

package/dist/interaction/types.js

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

package/dist/permission/manager.js

@@ -51,6 +51,12 @@ class PermissionManager {
     setMessageId(messageId) {
         this.state.messageId = messageId;
     }
+    /**
+     * Check if callback message ID belongs to active permission request
+     */
+    isActiveMessage(messageId) {
+        return (this.state.isActive && this.state.messageId !== null && messageId === this.state.messageId);
+    }
     /**
      * Get Telegram message ID
      */

package/dist/question/manager.js

@@ -5,6 +5,8 @@ class QuestionManager {
         currentIndex: 0,
         selectedOptions: new Map(),
         customAnswers: new Map(),
+        customInputQuestionIndex: null,
+        activeMessageId: null,
         messageIds: [],
         isActive: false,
         requestID: null,
@@ -22,6 +24,8 @@ class QuestionManager {
             currentIndex: 0,
             selectedOptions: new Map(),
             customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
             messageIds: [],
             isActive: true,
             requestID,
@@ -87,6 +91,8 @@ class QuestionManager {
     }
     nextQuestion() {
         this.state.currentIndex++;
+        this.state.customInputQuestionIndex = null;
+        this.state.activeMessageId = null;
         logger.debug(`[QuestionManager] Moving to next question: ${this.state.currentIndex}/${this.state.questions.length}`);
     }
     hasNextQuestion() {
@@ -101,6 +107,29 @@ class QuestionManager {
     addMessageId(messageId) {
         this.state.messageIds.push(messageId);
     }
+    setActiveMessageId(messageId) {
+        this.state.activeMessageId = messageId;
+    }
+    getActiveMessageId() {
+        return this.state.activeMessageId;
+    }
+    isActiveMessage(messageId) {
+        return (this.state.isActive &&
+            this.state.activeMessageId !== null &&
+            messageId === this.state.activeMessageId);
+    }
+    startCustomInput(questionIndex) {
+        if (!this.state.isActive || !this.state.questions[questionIndex]) {
+            return;
+        }
+        this.state.customInputQuestionIndex = questionIndex;
+    }
+    clearCustomInput() {
+        this.state.customInputQuestionIndex = null;
+    }
+    isWaitingForCustomInput(questionIndex) {
+        return this.state.customInputQuestionIndex === questionIndex;
+    }
     getMessageIds() {
         return [...this.state.messageIds];
     }
@@ -111,6 +140,8 @@ class QuestionManager {
     cancel() {
         logger.info("[QuestionManager] Poll cancelled");
         this.state.isActive = false;
+        this.state.customInputQuestionIndex = null;
+        this.state.activeMessageId = null;
     }
     clear() {
         this.state = {
@@ -118,6 +149,8 @@ class QuestionManager {
             currentIndex: 0,
             selectedOptions: new Map(),
             customAnswers: new Map(),
+            customInputQuestionIndex: null,
+            activeMessageId: null,
             messageIds: [],
             isActive: false,
             requestID: null,

package/dist/rename/manager.js

@@ -0,0 +1,53 @@
+import { logger } from "../utils/logger.js";
+class RenameManager {
+    state = {
+        isWaiting: false,
+        sessionId: null,
+        sessionDirectory: null,
+        currentTitle: null,
+        messageId: null,
+    };
+    startWaiting(sessionId, directory, currentTitle) {
+        logger.info(`[RenameManager] Starting rename flow for session: ${sessionId}`);
+        this.state = {
+            isWaiting: true,
+            sessionId,
+            sessionDirectory: directory,
+            currentTitle,
+            messageId: null,
+        };
+    }
+    setMessageId(messageId) {
+        this.state.messageId = messageId;
+    }
+    getMessageId() {
+        return this.state.messageId;
+    }
+    isActiveMessage(messageId) {
+        return (this.state.isWaiting && this.state.messageId !== null && this.state.messageId === messageId);
+    }
+    isWaitingForName() {
+        return this.state.isWaiting;
+    }
+    getSessionInfo() {
+        if (!this.state.isWaiting || !this.state.sessionId) {
+            return null;
+        }
+        return {
+            sessionId: this.state.sessionId,
+            directory: this.state.sessionDirectory,
+            currentTitle: this.state.currentTitle,
+        };
+    }
+    clear() {
+        logger.debug("[RenameManager] Clearing rename state");
+        this.state = {
+            isWaiting: false,
+            sessionId: null,
+            sessionDirectory: null,
+            currentTitle: null,
+            messageId: null,
+        };
+    }
+}
+export const renameManager = new RenameManager();