zardbot-telegram 1.0.0

package/.env.example

@@ -0,0 +1,116 @@
+# Telegram Bot Token (from @BotFather)
+TELEGRAM_BOT_TOKEN=
+
+# Allowed Telegram User ID (from @userinfobot)
+TELEGRAM_ALLOWED_USER_ID=
+
+# Telegram Proxy URL (optional)
+# Supports socks5://, socks4://, http://, https:// protocols
+# Examples:
+#   TELEGRAM_PROXY_URL=socks5://proxy.example.com:1080
+#   TELEGRAM_PROXY_URL=socks5://user:password@proxy.example.com:1080
+#   TELEGRAM_PROXY_URL=http://proxy.example.com:8080
+# TELEGRAM_PROXY_URL=
+
+# OpenCode API URL (optional, default: http://localhost:4096)
+# OPENCODE_API_URL=http://localhost:4096
+
+# OpenCode Server Authentication (optional)
+# OPENCODE_SERVER_USERNAME=opencode
+# OPENCODE_SERVER_PASSWORD=
+
+# OpenCode Model Configuration (REQUIRED)
+# You must specify a default model provider and model ID
+# Examples:
+#   Anthropic Claude 3.5 Sonnet: OPENCODE_MODEL_PROVIDER=anthropic, OPENCODE_MODEL_ID=claude-3-5-sonnet-20241022
+#   OpenAI GPT-4 Turbo: OPENCODE_MODEL_PROVIDER=openai, OPENCODE_MODEL_ID=gpt-4-turbo
+#   Groq Mixtral: OPENCODE_MODEL_PROVIDER=groq, OPENCODE_MODEL_ID=mixtral-8x7b-32768
+OPENCODE_MODEL_PROVIDER=opencode
+OPENCODE_MODEL_ID=big-pickle
+
+# Server Configuration (optional)
+# Logging level: debug, info, warn, error (default: info)
+# Use "debug" to see detailed diagnostic logs including all bot events
+# LOG_LEVEL=info
+
+# Bot Configuration (optional)
+# Maximum number of sessions shown in /sessions (default: 10)
+# SESSIONS_LIST_LIMIT=10
+
+# Maximum number of projects shown in /projects (default: 10)
+# PROJECTS_LIST_LIMIT=10
+
+# Maximum number of commands shown in /commands (default: 10)
+# COMMANDS_LIST_LIMIT=10
+
+# Maximum number of scheduled tasks allowed at once (default: 10)
+# TASK_LIMIT=10
+
+# Stream update throttle in milliseconds for assistant/tool message edits (default: 500)
+# Higher value = fewer Telegram edit requests, lower value = more real-time updates
+# RESPONSE_STREAM_THROTTLE_MS=500
+
+# Bot locale: supported locale code (default: en)
+# Supported locales: en, de, es, fr, ru, zh
+# BOT_LOCALE=en
+
+# Hide thinking indicator messages (default: false)
+# HIDE_THINKING_MESSAGES=false
+
+# Hide tool call service messages (default: false)
+# HIDE_TOOL_CALL_MESSAGES=false
+
+# Assistant message formatting mode (default: markdown)
+# markdown = convert assistant replies to Telegram MarkdownV2
+# raw = show assistant replies as plain text
+# MESSAGE_FORMAT_MODE=markdown
+
+# Code File Settings (optional)
+# Maximum file size in KB to send as document (default: 100)
+# CODE_FILE_MAX_SIZE_KB=100
+
+# Speech-to-Text / Voice Recognition (optional)
+# Enable voice message transcription by setting a Whisper-compatible API URL.
+# Works with OpenAI, Groq, whisper.cpp, or any Whisper-compatible endpoint.
+# If STT_API_URL is not set, voice messages will get a "not configured" reply.
+#
+# For local whisper.cpp server:
+#   STT_API_URL=http://localhost:8080
+#   STT_API_KEY= (leave empty for local servers)
+#
+# For OpenAI:
+#   STT_API_URL=https://api.openai.com/v1
+#   STT_API_KEY=sk-your-api-key
+#   STT_MODEL=whisper-1
+#
+# For Groq:
+#   STT_API_URL=https://api.groq.com/openai/v1
+#   STT_API_KEY=gsk-your-api-key
+#   STT_MODEL=whisper-large-v3-turbo
+# STT_API_URL=
+# STT_API_KEY=
+# STT_MODEL=whisper-large-v3-turbo
+# STT_LANGUAGE=
+
+# Text-to-Speech (optional)
+# Enable voice responses by setting up a TTS server.
+# Compatible with pocket-tts-server (recommended) or any OpenAI-compatible TTS API.
+#
+# Setup pocket-tts-server: https://github.com/ai-joe-git/pocket-tts-server
+# 82 celebrity voice clones included, local TTS, zero cloud dependency.
+#
+# For local pocket-tts-server:
+#   TTS_API_URL=http://localhost:8000
+#   TTS_DEFAULT_VOICE=david-attenborough-original
+#
+# For OpenAI:
+#   TTS_API_URL=https://api.openai.com/v1
+#   TTS_DEFAULT_VOICE=alloy
+#   TTS_MODEL=tts-1
+#   (requires TTS_API_KEY via OpenAI API key header)
+#
+# If TTS_API_URL is not set, the bot will only send text responses.
+# TTS_API_URL=
+# TTS_DEFAULT_VOICE=david-attenborough-original
+# TTS_MODEL=tts-1
+# TTS_SPEED=1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruslan Grinev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# ZardBot Telegram
+
+[![npm version](https://img.shields.io/npm/v/zardbot-telegram)](https://www.npmjs.com/package/zardbot-telegram)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
+
+ZardBot Telegram is a Telegram client for [OpenCode](https://opencode.ai) with **Text-to-Speech (TTS)** and **Speech-to-Text (STT)** support.
+
+Run AI coding tasks, monitor progress, switch models, and manage sessions from your phone -- with voice input and voice responses!
+
+**Voice Features:**
+- 🎤 **Speech-to-Text (STT)** -- Send voice messages, transcribe via whisper.cpp
+- 🔊 **Text-to-Speech (TTS)** -- Agent responses read aloud with celebrity voices
+
+**Credits:** Forked from [opencode-telegram-bot](https://github.com/grinev/opencode-telegram-bot) by Ruslan Grinev, enhanced with TTS/STT support.
+
+---
+
+## Features
+
+All features from the original OpenCode Telegram Bot, plus:
+
+- **Voice input (STT)** -- Send voice/audio messages, transcribe them via Whisper-compatible API
+- **Voice output (TTS)** -- Agent responses spoken aloud with 82+ celebrity voices
+- **Voice selection** -- `/voice` command to choose from available voices
+- **Local TTS** -- Works with [pocket-tts-server](https://github.com/ai-joe-git/pocket-tts-server) for zero-cloud voice
+
+### Core Features (from original)
+
+- **Remote coding** -- send prompts to OpenCode from anywhere, receive results with code files
+- **Session management** -- create new sessions or continue existing ones
+- **Live status** -- pinned message with project, model, context usage, subagent activity
+- **Model switching** -- pick models from favorites and recent history
+- **Agent modes** -- switch between Plan and Build modes
+- **Subagent activity** -- watch live subagent progress in chat
+- **Custom Commands** -- run OpenCode custom commands from inline menu
+- **Interactive Q&A** -- answer agent questions and approve permissions via buttons
+- **File attachments** -- send images, PDFs, and text-based files to OpenCode
+- **Scheduled tasks** -- schedule prompts to run later or on recurring intervals
+- **Context control** -- compact context when it gets too large
+- **Security** -- strict user ID whitelist
+- **Localization** -- UI in English, Deutsch, Espanol, Francais, Russkii, Zhongwen
+
+---
+
+## Prerequisites
+
+- **Node.js 20+** -- [download](https://nodejs.org)
+- **OpenCode** -- install from [opencode.ai](https://opencode.ai) or [GitHub](https://github.com/sst/opencode)
+- **Telegram Bot** -- create one via [@BotFather](https://t.me/BotFather)
+
+### Optional (for voice features)
+
+- **pocket-tts-server** -- Local TTS with 82+ celebrity voices: [GitHub](https://github.com/ai-joe-git/pocket-tts-server)
+- **whisper.cpp** -- Local STT: [GitHub](https://github.com/ggerganov/whisper.cpp)
+
+---
+
+## Quick Start
+
+### 1. Create a Telegram Bot
+
+1. Open [@BotFather](https://t.me/BotFather) and send `/newbot`
+2. Follow prompts to choose name and username
+3. Copy the **bot token**
+
+Get your **Telegram User ID** from [@userinfobot](https://t.me/userinfobot).
+
+### 2. Start OpenCode Server
+
+```bash
+opencode serve
+```
+
+The bot connects to `http://localhost:4096` by default.
+
+### 3. Install & Run
+
+```bash
+npx zardbot-telegram
+```
+
+An interactive wizard will guide you through configuration.
+
+#### Alternative: Global Install
+
+```bash
+npm install -g zardbot-telegram
+zardbot-telegram start
+```
+
+To reconfigure at any time:
+
+```bash
+zardbot-telegram config
+```
+
+The setup wizard will guide you through configuration.
+
+---
+
+## Bot Commands
+
+| Command | Description |
+|---------|-------------|
+| `/status` | Server health, project, session, model info |
+| `/new` | Create a new session |
+| `/abort` | Abort current task |
+| `/sessions` | Browse and switch sessions |
+| `/projects` | Switch between projects |
+| `/rename` | Rename current session |
+| `/voice` | Select TTS voice (when TTS configured) |
+| `/commands` | Run custom commands |
+| `/task` | Create scheduled task |
+| `/tasklist` | Manage scheduled tasks |
+| `/opencode_start` | Start OpenCode server remotely |
+| `/opencode_stop` | Stop OpenCode server remotely |
+| `/help` | Show available commands |
+
+---
+
+## Configuration
+
+Config stored in `.env`:
+
+- **macOS:** `~/Library/Application Support/zardbot-telegram/.env`
+- **Windows:** `%APPDATA%\zardbot-telegram\.env`
+- **Linux:** `~/.config/zardbot-telegram/.env`
+
+### Environment Variables
+
+| Variable | Description | Required | Default |
+|----------|-------------|:--------:|---------|
+| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather | Yes | -- |
+| `TELEGRAM_ALLOWED_USER_ID` | Your Telegram user ID | Yes | -- |
+| `TELEGRAM_PROXY_URL` | Proxy for Telegram API | No | -- |
+| `OPENCODE_API_URL` | OpenCode server URL | No | `http://localhost:4096` |
+| `OPENCODE_SERVER_USERNAME` | Server auth username | No | `opencode` |
+| `OPENCODE_SERVER_PASSWORD` | Server auth password | No | -- |
+| `OPENCODE_MODEL_PROVIDER` | Default model provider | Yes | `opencode` |
+| `OPENCODE_MODEL_ID` | Default model ID | Yes | `big-pickle` |
+| `BOT_LOCALE` | UI language (`en`, `de`, `es`, `fr`, `ru`, `zh`) | No | `en` |
+| `LOG_LEVEL` | Log level (`debug`, `info`, `warn`, `error`) | No | `info` |
+
+### Speech-to-Text (STT)
+
+| Variable | Description | Required | Default |
+|----------|-------------|:--------:|---------|
+| `STT_API_URL` | Whisper-compatible API URL | No | -- |
+| `STT_API_KEY` | API key for STT provider | No | -- |
+| `STT_MODEL` | STT model name | No | `whisper-large-v3-turbo` |
+| `STT_LANGUAGE` | Language hint | No | -- |
+
+#### STT Providers
+
+**Local whisper.cpp:**
+```env
+STT_API_URL=http://localhost:8080
+STT_API_KEY=
+```
+
+**OpenAI:**
+```env
+STT_API_URL=https://api.openai.com/v1
+STT_API_KEY=sk-your-api-key
+STT_MODEL=whisper-1
+```
+
+**Groq:**
+```env
+STT_API_URL=https://api.groq.com/openai/v1
+STT_API_KEY=gsk-your-api-key
+STT_MODEL=whisper-large-v3-turbo
+```
+
+### Text-to-Speech (TTS)
+
+| Variable | Description | Required | Default |
+|----------|-------------|:--------:|---------|
+| `TTS_API_URL` | TTS server URL | No | -- |
+| `TTS_DEFAULT_VOICE` | Default voice ID | No | `david-attenborough-original` |
+| `TTS_MODEL` | TTS model name | No | `tts-1` |
+| `TTS_SPEED` | Speech speed multiplier | No | `1.0` |
+
+#### TTS Setup (pocket-tts-server)
+
+```env
+TTS_API_URL=http://localhost:8000
+TTS_DEFAULT_VOICE=david-attenborough-original
+```
+
+Setup [pocket-tts-server](https://github.com/ai-joe-git/pocket-tts-server):
+- 82+ celebrity voice clones
+- Local processing (no cloud)
+- No API costs
+
+**Available Voices:**
+- `david-attenborough-original`
+- `morgan-freeman-original`
+- `jarvis-iron-man`
+- `margot-robie`
+- `chris-evans`
+- And many more...
+
+Use `/voice` in the bot to select from available voices.
+
+---
+
+## Development
+
+### Running from Source
+
+```bash
+git clone https://github.com/ai-joe-git/zardbot-telegram.git
+cd zardbot-telegram
+npm install
+cp .env.example .env
+# Edit .env with your configuration
+npm run dev
+```
+
+### Scripts
+
+| Script | Description |
+|--------|-------------|
+| `npm run dev` | Build and start |
+| `npm run build` | Compile TypeScript |
+| `npm start` | Run compiled code |
+| `npm run lint` | ESLint check |
+| `npm run format` | Format with Prettier |
+| `npm test` | Run tests |
+
+---
+
+## Security
+
+Strict **user ID whitelist**. Only `TELEGRAM_ALLOWED_USER_ID` can interact with the bot.
+
+---
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+## Acknowledgments
+
+- **Ruslan Grinev** -- Original [opencode-telegram-bot](https://github.com/grinev/opencode-telegram-bot)
+- **OpenCode Team** -- [opencode.ai](https://opencode.ai)

package/dist/agent/manager.js

@@ -0,0 +1,88 @@
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentProject } from "../settings/manager.js";
+import { getCurrentSession } from "../session/manager.js";
+import { getCurrentAgent, setCurrentAgent } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Get list of available agents from OpenCode API
+ * @returns Array of available agents (filtered by mode and hidden flag)
+ */
+export async function getAvailableAgents() {
+    try {
+        const project = getCurrentProject();
+        const { data: agents, error } = await opencodeClient.app.agents(project ? { directory: project.worktree } : undefined);
+        if (error) {
+            logger.error("[AgentManager] Failed to fetch agents:", error);
+            return [];
+        }
+        if (!agents) {
+            return [];
+        }
+        // Filter out hidden agents and subagents (only show primary and all)
+        const filtered = agents.filter((agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"));
+        logger.debug(`[AgentManager] Fetched ${filtered.length} available agents`);
+        return filtered;
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching agents:", err);
+        return [];
+    }
+}
+const DEFAULT_AGENT = "build";
+/**
+ * Get current agent from last session message or settings.
+ * Falls back to "build" if nothing is stored.
+ * @returns Current agent name
+ */
+export async function fetchCurrentAgent() {
+    const storedAgent = getCurrentAgent();
+    const session = getCurrentSession();
+    const project = getCurrentProject();
+    if (!session || !project) {
+        // No active session, return stored agent from settings
+        return storedAgent ?? DEFAULT_AGENT;
+    }
+    try {
+        const { data: messages, error } = await opencodeClient.session.messages({
+            sessionID: session.id,
+            directory: project.worktree,
+            limit: 1,
+        });
+        if (error || !messages || messages.length === 0) {
+            logger.debug("[AgentManager] No messages found, using stored agent");
+            return storedAgent ?? DEFAULT_AGENT;
+        }
+        const lastAgent = messages[0].info.agent;
+        logger.debug(`[AgentManager] Current agent from session: ${lastAgent}`);
+        // If user explicitly selected an agent in bot settings, prefer it.
+        // Session messages may contain stale agent until next prompt is sent.
+        if (storedAgent && lastAgent !== storedAgent) {
+            logger.debug(`[AgentManager] Using stored agent "${storedAgent}" instead of session agent "${lastAgent}"`);
+            return storedAgent;
+        }
+        // No stored agent yet: sync from session history
+        if (lastAgent && lastAgent !== storedAgent) {
+            setCurrentAgent(lastAgent);
+        }
+        return lastAgent || storedAgent || DEFAULT_AGENT;
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching current agent:", err);
+        return storedAgent ?? DEFAULT_AGENT;
+    }
+}
+/**
+ * Select agent and persist to settings
+ * @param agentName Name of the agent to select
+ */
+export function selectAgent(agentName) {
+    logger.info(`[AgentManager] Selected agent: ${agentName}`);
+    setCurrentAgent(agentName);
+}
+/**
+ * Get stored agent from settings (synchronous)
+ * @returns Current agent name or default "build"
+ */
+export function getStoredAgent() {
+    return getCurrentAgent() ?? "build";
+}

package/dist/agent/types.js

@@ -0,0 +1,26 @@
+/**
+ * Agent emoji mapping for visual distinction
+ */
+export const AGENT_EMOJI = {
+    plan: "📋",
+    build: "🛠️",
+    general: "💬",
+    explore: "🔍",
+    title: "📝",
+    summary: "📄",
+    compaction: "📦",
+};
+/**
+ * Get emoji for agent (fallback to 🤖 if not found)
+ */
+export function getAgentEmoji(agentName) {
+    return AGENT_EMOJI[agentName] ?? "🤖";
+}
+/**
+ * Get display name for agent (with emoji)
+ */
+export function getAgentDisplayName(agentName) {
+    const emoji = getAgentEmoji(agentName);
+    const capitalizedName = agentName.charAt(0).toUpperCase() + agentName.slice(1);
+    return `${emoji} ${capitalizedName} Mode`;
+}

package/dist/app/start-bot-app.js

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import { createBot } from "../bot/index.js";
+import { config } from "../config.js";
+import { loadSettings } from "../settings/manager.js";
+import { processManager } from "../process/manager.js";
+import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
+import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
+import { reconcileStoredModelSelection } from "../model/manager.js";
+import { getRuntimeMode } from "../runtime/mode.js";
+import { getRuntimePaths } from "../runtime/paths.js";
+import { logger } from "../utils/logger.js";
+async function getBotVersion() {
+    try {
+        const packageJsonPath = new URL("../../package.json", import.meta.url);
+        const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        return packageJson.version ?? "unknown";
+    }
+    catch (error) {
+        logger.warn("[App] Failed to read bot version", error);
+        return "unknown";
+    }
+}
+export async function startBotApp() {
+    const mode = getRuntimeMode();
+    const runtimePaths = getRuntimePaths();
+    const version = await getBotVersion();
+    logger.info(`Starting OpenCode Telegram Bot v${version}...`);
+    logger.info(`Config loaded from ${runtimePaths.envFilePath}`);
+    logger.info(`Allowed User ID: ${config.telegram.allowedUserId}`);
+    logger.debug(`[Runtime] Application start mode: ${mode}`);
+    await loadSettings();
+    await processManager.initialize();
+    await reconcileStoredModelSelection();
+    await warmupSessionDirectoryCache();
+    const bot = createBot();
+    await scheduledTaskRuntime.initialize(bot);
+    const webhookInfo = await bot.api.getWebhookInfo();
+    if (webhookInfo.url) {
+        logger.info(`[Bot] Webhook detected: ${webhookInfo.url}, removing...`);
+        await bot.api.deleteWebhook();
+        logger.info("[Bot] Webhook removed, switching to long polling");
+    }
+    await bot.start({
+        onStart: (botInfo) => {
+            logger.info(`Bot @${botInfo.username} started!`);
+        },
+    });
+}

package/dist/bot/commands/abort.js

@@ -0,0 +1,121 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { stopEventListening } from "../../opencode/events.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function abortLocalStreaming() {
+    stopEventListening();
+    summaryAggregator.clear();
+    clearAllInteractionState("abort_command");
+}
+async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {
+    const startedAt = Date.now();
+    const pollIntervalMs = 500;
+    while (Date.now() - startedAt < maxWaitMs) {
+        try {
+            const { data, error } = await opencodeClient.session.status({ directory });
+            if (error || !data) {
+                break;
+            }
+            const sessionStatus = data[sessionId];
+            if (!sessionStatus) {
+                return "not-found";
+            }
+            if (sessionStatus.type === "idle" || sessionStatus.type === "error") {
+                return "idle";
+            }
+            if (sessionStatus.type !== "busy") {
+                return "not-found";
+            }
+            await sleep(pollIntervalMs);
+        }
+        catch (error) {
+            logger.warn("[Abort] Failed to poll session status:", error);
+            break;
+        }
+    }
+    return "busy";
+}
+export async function abortCurrentOperation(ctx, options = {}) {
+    const notifyUser = options.notifyUser ?? true;
+    try {
+        abortLocalStreaming();
+        const currentSession = getCurrentSession();
+        if (!currentSession) {
+            if (notifyUser) {
+                await ctx.reply(t("stop.no_active_session"));
+            }
+            return;
+        }
+        let waitingMessageId = null;
+        let chatId = null;
+        if (notifyUser) {
+            const waitingMessage = await ctx.reply(t("stop.in_progress"));
+            waitingMessageId = waitingMessage.message_id;
+            chatId = ctx.chat?.id ?? null;
+            if (!chatId) {
+                logger.warn("[Abort] Chat context is missing while aborting active session");
+                return;
+            }
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+        try {
+            const { data: abortResult, error: abortError } = await opencodeClient.session.abort({
+                sessionID: currentSession.id,
+                directory: currentSession.directory,
+            }, { signal: controller.signal });
+            clearTimeout(timeoutId);
+            if (abortError) {
+                logger.warn("[Abort] Abort request failed:", abortError);
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_unconfirmed"));
+                }
+                return;
+            }
+            if (abortResult !== true) {
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_maybe_finished"));
+                }
+                return;
+            }
+            const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
+            if (finalStatus === "idle" || finalStatus === "not-found") {
+                foregroundSessionState.markIdle(currentSession.id);
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.success"));
+                }
+            }
+            else {
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_still_busy"));
+                }
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_timeout"));
+                }
+            }
+            else {
+                logger.error("[Abort] Error while aborting session:", error);
+                if (notifyUser && chatId !== null && waitingMessageId !== null) {
+                    await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.warn_local_only"));
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error("[Abort] Unexpected error:", error);
+        await ctx.reply(t("stop.error"));
+    }
+}
+export async function abortCommand(ctx) {
+    await abortCurrentOperation(ctx);
+}