opencode-telegram-group-topics-bot 0.11.2

package/.env.example

@@ -0,0 +1,74 @@
+# 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
+
+# Bot locale: supported locale code (default: en)
+# Supported locales: en, de, es, ru, zh
+# BOT_LOCALE=en
+
+# Service message batching interval in seconds (thinking + tool calls, default: 5)
+# Recommended: keep >=2 to reduce risk of hitting Telegram rate limits (about 1 message/sec)
+# 0 = send immediately (can hit rate limits if there are many tool calls)
+# SERVICE_MESSAGES_INTERVAL_SEC=5
+
+# 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, or any Whisper-compatible endpoint.
+# If STT_API_URL is not set, voice messages will get a "not configured" reply.
+# STT_API_URL=
+# STT_API_KEY=
+# STT_MODEL=
+# STT_LANGUAGE=

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,305 @@
+# OpenCode Telegram Group Topics Bot
+
+[![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)
+
+A Telegram bot for [OpenCode](https://opencode.ai) that turns one Telegram supergroup into a multi-session mobile workspace.
+
+This project is a fork of the original single-chat bot: [grinev/opencode-telegram-bot](https://github.com/grinev/opencode-telegram-bot) by Ruslan Grinev.
+
+- Use the upstream project if you want the simpler single-chat workflow.
+- Use this fork if you want one **General** control topic plus dedicated forum topics for parallel OpenCode sessions.
+
+No open ports, no exposed web UI. The bot talks only to your local OpenCode server and the Telegram Bot API.
+
+You can run many session topics in parallel inside one group, and many groups in parallel across different projects.
+
+Platforms: macOS, Windows, Linux
+
+Languages: English (`en`), Deutsch (`de`), Espanol (`es`), Russkiy (`ru`), Jian ti Zhong wen (`zh`)
+
+Fork sync notes: [`FORK_SYNC.md`](./FORK_SYNC.md)
+
+<p align="center">
+  <img src="assets/screencast.gif" width="45%" alt="OpenCode Telegram Group Topics Bot screencast" />
+</p>
+
+## At a Glance
+
+- One Telegram group usually maps to one repo / project workspace.
+- The **General** topic is the control lane for `/projects`, `/sessions`, `/new`, and status checks.
+- Each new OpenCode session gets its own forum topic.
+- Each topic keeps its own session, model, agent, and pinned status state.
+- Multiple topics can run at the same time, and multiple groups can be active at the same time.
+- DMs are for light control/status usage, not the main multi-session workflow.
+
+## Quick Start
+
+### 1. Prerequisites
+
+- Install **Node.js 20+**
+- Install **OpenCode** from [opencode.ai](https://opencode.ai) or [GitHub](https://github.com/sst/opencode)
+- Create a Telegram bot with [@BotFather](https://t.me/BotFather)
+- Get your Telegram numeric user ID from [@userinfobot](https://t.me/userinfobot)
+
+### 2. Create and Prepare the Telegram Group
+
+1. Create a new Telegram **supergroup** for one OpenCode project/repository.
+2. Add your bot to that group.
+3. Make the bot an admin with permission to **Manage Topics**.
+4. Enable **Topics** in the group settings.
+5. In [@BotFather](https://t.me/BotFather), run `/setprivacy` for the bot and choose **Disable**.
+6. Keep the default **General** topic - that is the control lane.
+
+### 3. Start OpenCode
+
+Run OpenCode on the machine where the bot will live:
+
+```bash
+opencode serve
+```
+
+Default API URL: `http://localhost:4096`
+
+### 4. Install the Bot
+
+#### Option A: `npx`
+
+```bash
+npx opencode-telegram-group-topics-bot
+```
+
+#### Option B: Global install
+
+```bash
+npm install -g opencode-telegram-group-topics-bot
+opencode-telegram-group-topics-bot config
+opencode-telegram-group-topics-bot start
+```
+
+#### Option C: Run from source
+
+```bash
+git clone https://github.com/shanekunz/opencode-telegram-group-topics-bot.git
+cd opencode-telegram-group-topics-bot
+npm install
+npm run build
+node dist/cli.js config --mode sources
+npm run dev
+```
+
+`dist/cli.js` is the compiled CLI entrypoint produced by `npm run build`.
+
+### 5. Complete the Setup Wizard
+
+The wizard asks for:
+
+- interface language
+- Telegram bot token
+- allowed Telegram user ID
+- OpenCode API URL
+- optional OpenCode server username/password
+
+### 6. First-Time Verification
+
+1. Open a DM with your bot and run `/start`.
+2. Confirm the bot replies.
+3. Open your Telegram group and run `/start` in **General**.
+4. Run `/status` and confirm the bot can reach OpenCode.
+5. Run `/projects` in **General** and pick the repo for this group.
+6. Run `/new` in **General** to create a session topic.
+7. Open the new topic and send a prompt.
+
+If that works, your group workspace is ready.
+
+## Daily Workflow
+
+1. Start OpenCode with `opencode serve`
+2. Start the bot
+3. Open the Telegram group and go to **General**
+4. Use `/projects` to confirm the selected repo
+5. Use `/new` to create a new session topic
+6. Work inside the topic thread
+7. Use `/sessions` in **General** to revisit older session lanes
+
+## Parallel Workloads and Telegram Rate Limits
+
+- This fork is designed for parallel work: many topic threads in one group, and many groups across projects.
+- Telegram enforces message rate limits, especially when many topics are receiving updates at once.
+- The bot handles those limits gracefully and slows or staggers Telegram updates when needed.
+- Your OpenCode sessions continue running even if Telegram updates become less frequent.
+- In heavy parallel usage, expect less real-time chatter per topic, but not lost OpenCode work.
+
+## Commands
+
+| Command           | Description                                             |
+| ----------------- | ------------------------------------------------------- |
+| `/status`         | Server health, current project, session, and model info |
+| `/new`            | Create a new session topic                              |
+| `/abort`          | Abort the current task                                  |
+| `/sessions`       | Browse and switch between recent sessions               |
+| `/projects`       | Switch between OpenCode projects                        |
+| `/rename`         | Rename the current session                              |
+| `/commands`       | Browse and run custom commands                          |
+| `/opencode_start` | Start the OpenCode server remotely                      |
+| `/opencode_stop`  | Stop the OpenCode server remotely                       |
+| `/help`           | Show available commands                                 |
+
+Any normal text message in a session topic is treated as a prompt when no blocking interaction is active.
+
+## How This Fork Differs From Upstream
+
+| Topic          | Upstream                    | This fork                   |
+| -------------- | --------------------------- | --------------------------- |
+| Main UX        | One chat                    | One group with forum topics |
+| Session layout | Switch sessions in one lane | One topic per session lane  |
+| Best for       | Simplicity                  | Parallel mobile workflows   |
+| Complexity     | Lower                       | Higher                      |
+
+If you want the simpler path, use the upstream project.
+
+## Configuration
+
+### Config Location
+
+- Source mode stores config in the repository root.
+- Installed mode stores config in the platform app-data directory.
+- `OPENCODE_TELEGRAM_HOME` overrides both and forces a custom config directory.
+
+Installed-mode config paths:
+
+- macOS: `~/Library/Application Support/opencode-telegram-group-topics-bot/.env`
+- Windows: `%APPDATA%\opencode-telegram-group-topics-bot\.env`
+- Linux: `~/.config/opencode-telegram-group-topics-bot/.env`
+
+### Environment Variables
+
+| Variable                        | Description                                                                          | Required | Default                  |
+| ------------------------------- | ------------------------------------------------------------------------------------ | :------: | ------------------------ |
+| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                            |   Yes    | -                        |
+| `TELEGRAM_ALLOWED_USER_ID`      | Your numeric Telegram user ID                                                        |   Yes    | -                        |
+| `TELEGRAM_PROXY_URL`            | Proxy URL for Telegram API (SOCKS5/HTTP)                                             |    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`                    | Bot UI language (`en`, `de`, `es`, `ru`, `zh`)                                       |    No    | `en`                     |
+| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                     |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                     |    No    | `10`                     |
+| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval; keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
+| `HIDE_THINKING_MESSAGES`        | Hide `Thinking...` service messages                                                  |    No    | `false`                  |
+| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages                                                      |    No    | `false`                  |
+| `MESSAGE_FORMAT_MODE`           | Assistant reply formatting mode: `markdown` or `raw`                                 |    No    | `markdown`               |
+| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as a document                                             |    No    | `100`                    |
+| `STT_API_URL`                   | Whisper-compatible API base URL                                                      |    No    | -                        |
+| `STT_API_KEY`                   | API key for your STT provider                                                        |    No    | -                        |
+| `STT_MODEL`                     | STT model name passed to `/audio/transcriptions`                                     |    No    | `whisper-large-v3-turbo` |
+| `STT_LANGUAGE`                  | Optional language hint                                                               |    No    | -                        |
+| `LOG_LEVEL`                     | Log level (`debug`, `info`, `warn`, `error`)                                         |    No    | `info`                   |
+
+Keep your `.env` private. It contains your bot token.
+
+### Optional: Voice and Audio Transcription
+
+If `STT_API_URL` and `STT_API_KEY` are set, the bot can transcribe Telegram voice/audio messages before sending them to OpenCode.
+
+Whisper-compatible examples:
+
+- OpenAI: `https://api.openai.com/v1`
+- Groq: `https://api.groq.com/openai/v1`
+- Together: `https://api.together.xyz/v1`
+
+### Model Picker Notes
+
+- Favorites are shown before recent models
+- The current model is marked with `✅`
+- The default model from `OPENCODE_MODEL_PROVIDER` + `OPENCODE_MODEL_ID` is always included
+
+To add favorites, open the OpenCode TUI and press `Cmd+F` / `Ctrl+F` on a model.
+
+## Features
+
+- Thread-scoped OpenCode sessions inside Telegram forum topics
+- Pinned live status messages per topic
+- Model, agent, variant, and context controls from the keyboard
+- Custom OpenCode command execution
+- Interactive permission and question handling
+- Voice/audio transcription support
+- File attachments for images, PDFs, and text files
+- Strict single-user access control
+
+## Security
+
+Only the Telegram user whose ID matches `TELEGRAM_ALLOWED_USER_ID` can use the bot.
+
+Since the bot runs locally and connects to your local OpenCode server, there is no exposed public service beyond Telegram itself.
+
+## Development
+
+### Run from source
+
+```bash
+git clone https://github.com/shanekunz/opencode-telegram-group-topics-bot.git
+cd opencode-telegram-group-topics-bot
+npm install
+npm run build
+node dist/cli.js config --mode sources
+npm run dev
+```
+
+### Scripts
+
+| Script                          | Description             |
+| ------------------------------- | ----------------------- |
+| `npm run dev`                   | Build and start         |
+| `npm run build`                 | Compile TypeScript      |
+| `npm start`                     | Run compiled code       |
+| `npm run release:notes:preview` | Preview release notes   |
+| `npm run lint`                  | Run ESLint              |
+| `npm run format`                | Run Prettier            |
+| `npm test`                      | Run tests               |
+| `npm run test:coverage`         | Run tests with coverage |
+
+No watcher is used because the bot maintains persistent SSE and polling connections.
+
+## Troubleshooting
+
+**Bot does not respond**
+
+- Confirm `TELEGRAM_ALLOWED_USER_ID` matches your real Telegram user ID
+- Confirm the bot token is correct
+- Make sure you disabled privacy mode in BotFather for group usage
+
+**OpenCode server is unavailable**
+
+- Make sure `opencode serve` is running
+- Confirm `OPENCODE_API_URL` points to the correct address
+
+**Cannot create new session topics**
+
+- Confirm the group is a supergroup with Topics enabled
+- Confirm the bot is an admin with **Manage Topics** permission
+- Run `/new` from **General**, not inside an existing session topic
+
+**No models appear in the picker**
+
+- Add favorites in the OpenCode TUI
+- Confirm `OPENCODE_MODEL_PROVIDER` and `OPENCODE_MODEL_ID` are valid for your setup
+
+**Linux permission issues**
+
+- Check the CLI binary is executable: `chmod +x $(which opencode-telegram-group-topics-bot)`
+- Check the config directory is writable: `~/.config/opencode-telegram-group-topics-bot/`
+
+## Contributing
+
+Please follow [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Community
+
+Open issues in this repository for this fork. For upstream discussion, see [grinev/opencode-telegram-bot](https://github.com/grinev/opencode-telegram-bot).
+
+## License
+
+[MIT](LICENSE) © Ruslan Grinev

package/dist/agent/manager.js

@@ -0,0 +1,60 @@
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentProject, getCurrentAgent, setCurrentAgent } from "../settings/manager.js";
+import { getCurrentSession } from "../session/manager.js";
+import { logger } from "../utils/logger.js";
+const DEFAULT_AGENT = "build";
+export async function getAvailableAgents(scopeKey = "global") {
+    try {
+        const project = getCurrentProject(scopeKey);
+        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 [];
+        }
+        return agents.filter((agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"));
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching agents:", err);
+        return [];
+    }
+}
+export async function fetchCurrentAgent(scopeKey = "global") {
+    const storedAgent = getCurrentAgent(scopeKey);
+    const session = getCurrentSession(scopeKey);
+    const project = getCurrentProject(scopeKey);
+    if (!session || !project) {
+        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) {
+            return storedAgent ?? DEFAULT_AGENT;
+        }
+        const lastAgent = messages[0].info.agent;
+        if (storedAgent && lastAgent !== storedAgent) {
+            return storedAgent;
+        }
+        if (lastAgent && lastAgent !== storedAgent) {
+            setCurrentAgent(lastAgent, scopeKey);
+        }
+        return lastAgent || storedAgent || DEFAULT_AGENT;
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching current agent:", err);
+        return storedAgent ?? DEFAULT_AGENT;
+    }
+}
+export function selectAgent(agentName, scopeKey = "global") {
+    logger.info(`[AgentManager] Selected agent: ${agentName}`);
+    setCurrentAgent(agentName, scopeKey);
+}
+export function getStoredAgent(scopeKey = "global") {
+    return getCurrentAgent(scopeKey) ?? DEFAULT_AGENT;
+}

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,47 @@
+import { readFile } from "node:fs/promises";
+import { createBot } from "../bot/index.js";
+import { config } from "../config.js";
+import { reconcileStoredModelSelection } from "../model/manager.js";
+import { loadSettings } from "../settings/manager.js";
+import { processManager } from "../process/manager.js";
+import { warmupSessionDirectoryCache } from "../session/cache-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 Group Topics 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();
+    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,116 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { INTERACTION_CLEAR_REASON } from "../../interaction/constants.js";
+import { getCurrentSession } from "../../session/manager.js";
+import { TOPIC_SESSION_STATUS } from "../../settings/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { updateTopicBindingStatusBySessionId } from "../../topic/manager.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { getScopeKeyFromContext } from "../scope.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function stopLocalStreaming(scopeKey, sessionId) {
+    clearAllInteractionState(INTERACTION_CLEAR_REASON.STOP_COMMAND, scopeKey);
+    if (!sessionId) {
+        return;
+    }
+    summaryAggregator.clearSession(sessionId);
+    updateTopicBindingStatusBySessionId(sessionId, TOPIC_SESSION_STATUS.ABANDONED);
+}
+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 scopeKey = getScopeKeyFromContext(ctx);
+    const currentSession = getCurrentSession(scopeKey);
+    if (!currentSession) {
+        stopLocalStreaming(scopeKey);
+        if (options.notifyUser !== false) {
+            await ctx.reply(t("stop.no_active_session"));
+        }
+        return;
+    }
+    stopLocalStreaming(scopeKey, currentSession.id);
+    const waitingMessage = options.notifyUser === false ? null : await ctx.reply(t("stop.in_progress"));
+    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 (options.notifyUser === false) {
+            if (abortError) {
+                logger.warn("[Abort] Abort request failed during silent abort:", abortError);
+            }
+            return;
+        }
+        if (abortError) {
+            logger.warn("[Abort] Abort request failed:", abortError);
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.warn_unconfirmed"));
+            return;
+        }
+        if (abortResult !== true) {
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.warn_maybe_finished"));
+            return;
+        }
+        const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
+        if (finalStatus === "idle" || finalStatus === "not-found") {
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.success"));
+        }
+        else {
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.warn_still_busy"));
+        }
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (options.notifyUser === false) {
+            if (!(error instanceof Error && error.name === "AbortError")) {
+                logger.error("[Abort] Error while aborting session during silent abort:", error);
+            }
+            return;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.warn_timeout"));
+        }
+        else {
+            logger.error("[Abort] Error while aborting session:", error);
+            await ctx.api.editMessageText(ctx.chat.id, waitingMessage.message_id, t("stop.warn_local_only"));
+        }
+    }
+}
+export async function abortCommand(ctx) {
+    try {
+        await abortCurrentOperation(ctx);
+    }
+    catch (error) {
+        logger.error("[Abort] Unexpected error:", error);
+        await ctx.reply(t("stop.error"));
+    }
+}