telegram-opencode-bridge-bot 0.1.0__tar.gz → 0.1.2__tar.gz

{telegram_opencode_bridge_bot-0.1.0/telegram_opencode_bridge_bot.egg-info → telegram_opencode_bridge_bot-0.1.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.0
+Version: 0.1.2
 Summary: A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine
-Author-email: MaheshNagabhairava <your@email.com>
+Author-email: MaheshNagabhairava <maheshnagabhirava12345@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/MaheshNagabhairava/telegram-opencode-bridge-bot
 Keywords: telegram,bot,opencode,ai,coding,bridge
@@ -52,25 +52,15 @@ cd telegram-opencode-bot
 pip install -r requirements.txt
 ```
 
-### 2. Start OpenCode Server
-
-In a separate terminal:
-
-```bash
-opencode serve --port 4096 --hostname 127.0.0.1
-```
-
-This starts the OpenCode HTTP API on `localhost:4096`.
-
-### 3. Run the Bot
+### 2. Run the Bot
 
 ```bash
 python bot.py
-python bot.py --env (if u want to setup ur configuration later)
+python bot.py --env (use --env flag if u want to re-configure later anytime)
 ```
 > **💡 Tip:** Don't know your Telegram user ID? Start the bot with `AUTHORIZED_USERS=0` temporarily, send `/id` to the bot, then update the `.env` with your real ID.
 
-### 4. Chat!
+### 3. Chat!
 
 Open Telegram, find your bot, and start asking! 🎉
 

{telegram_opencode_bridge_bot-0.1.0 → telegram_opencode_bridge_bot-0.1.2}/README.md

@@ -1,139 +1,129 @@
-# 🤖 Telegram → OpenCode Bridge Bot
-
-A lightweight Python bot that bridges your Telegram messages directly to [OpenCode](https://opencode.ai) — an AI coding agent running on your machine. Think of it as having Claude/GPT-powered coding assistance right in your pocket via Telegram.
-
-## ✨ Features
-
-- **Direct OpenCode integration** — routes your messages to OpenCode's HTTP API
-- **Persistent sessions** — conversations maintain context across messages
-- **Session management** — create, switch, list, and share sessions
-- **Model switching** — change AI models on the fly (`/model`)
-- **Plan/Build modes** — toggle between read-only analysis and full execution
-- **Smart formatting** — code blocks with syntax highlighting in Telegram
-- **Auto message splitting** — handles responses longer than Telegram's 4096 char limit
-- **Security** — whitelist-based access control + rate limiting
-- **Workspace Switching** — Switching from one workspace to another
-
-## 📋 Prerequisites
-
-1. **Python 3.10+**
-2. **OpenCode CLI** — install via:
-   ```bash
-   npm install -g opencode-ai
-   # or
-   curl -fsSL https://opencode.ai/install | bash
-   ```
-3. **Telegram Bot Token** — get one from [@BotFather](https://t.me/BotFather)
-4. **Your Telegram User ID** — send `/id` to the bot after setup, or use [@userinfobot](https://t.me/userinfobot)
-
-## 🚀 Quick Start
-
-### 1. Clone & Install
-
-```bash
-cd telegram-opencode-bot
-pip install -r requirements.txt
-```
-
-### 2. Start OpenCode Server
-
-In a separate terminal:
-
-```bash
-opencode serve --port 4096 --hostname 127.0.0.1
-```
-
-This starts the OpenCode HTTP API on `localhost:4096`.
-
-### 3. Run the Bot
-
-```bash
-python bot.py
-python bot.py --env (if u want to setup ur configuration later)
-```
-> **💡 Tip:** Don't know your Telegram user ID? Start the bot with `AUTHORIZED_USERS=0` temporarily, send `/id` to the bot, then update the `.env` with your real ID.
-
-### 4. Chat!
-
-Open Telegram, find your bot, and start asking! 🎉
-
-## 📱 Commands
-
-| Command | Description |
-|---------|-------------|
-| `/start` | Welcome message & connection check |
-| `/help` | Show all commands |
-| `/new` | Start a fresh conversation |
-| `/sessions` | List your recent sessions |
-| `/switch <id>` | Switch to a different session |
-| `/model <name>` | Change AI model(ex: /model opencode/deepseek-v4-flash-free) |
-| `/mode <plan\|build>` | Toggle plan/build mode |
-| `/share` | Share current session (public URL) |
-| `/status` | Check connection & session details |
-| `/id` | Show your Telegram user ID |
-| `/stop` | Abort active model processing |
-| `/models` | List all available models |
-| `/project` | To view the current workspace, sub folder workspaces and to change the workspace (ex: /project 2)|
-| `/project depth <1to5>` | Depth level recursive check for subfolders (ex: if u give depth 2, only 2 sub folders it will show from root) |
-| `/enable` | To enable the streaming |
-| `/disable` | To disable the streaming |
-
-## 🏗️ Architecture
-
-```
-Telegram User
-    │
-    ▼
-Telegram Bot (Python)
-    │
-    ├──► OpenCode HTTP API (localhost:4096)  ← primary
-            │
-            ├──► LLM Provider (Claude/GPT/Gemini)
-            └──► Local Filesystem & Shell
-```
-
-## ⚙️ Configuration
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather | **Required** |
-| `AUTHORIZED_USERS` | Comma-separated Telegram user IDs | **Required** |
-| `OPENCODE_SERVER_URL` | OpenCode HTTP API URL | `http://localhost:4096` |
-| `OPENCODE_SERVER_USERNAME` | OpenCode auth username | *(empty)* |
-| `OPENCODE_SERVER_PASSWORD` | OpenCode auth password | *(empty)* |
-| `OPENCODE_MODEL` | Default AI model | `anthropic/claude-sonnet-4` |
-| `OPENCODE_WORK_DIR` | Working directory for OpenCode | `.` |
-| `MAX_MESSAGE_LENGTH` | Max Telegram message length | `4000` |
-| `RESPONSE_TIMEOUT` | Max wait for response (seconds) | `0` |
-| `DB_PATH` | SQLite database path | `sessions.db` |
-
-## 🔒 Security
-
-- **User whitelist** — only Telegram user IDs in `AUTHORIZED_USERS` can use the bot
-- **Rate limiting** — 20 requests per minute per user (configurable)
-- **No public exposure** — designed to run on your local machine
-
-> ⚠️ **Warning:** This bot executes AI-driven code on your machine. Only authorize trusted users.
-
-## 📁 Project Structure
-
-```
-telegram-opencode-bot/
-├── bot.py                  # Main entry point
-├── config.py               # Environment configuration
-├── handlers/
-│   ├── commands.py         # Slash command handlers
-│   └── messages.py         # Text message → OpenCode bridge
-├── opencode/
-│   ├── client.py           # OpenCode HTTP API client
-│   
-├── sessions/
-│   └── manager.py          # Per-user session tracking (SQLite)
-├── utils/
-│   ├── formatting.py       # Telegram message formatting
-│   └── security.py         # Auth, rate limiting, sanitization
-├── .env.example            # Environment template
-├── requirements.txt        # Python dependencies
-└── README.md               # This file
-```
-
+# 🤖 Telegram → OpenCode Bridge Bot
+
+A lightweight Python bot that bridges your Telegram messages directly to [OpenCode](https://opencode.ai) — an AI coding agent running on your machine. Think of it as having Claude/GPT-powered coding assistance right in your pocket via Telegram.
+
+## ✨ Features
+
+- **Direct OpenCode integration** — routes your messages to OpenCode's HTTP API
+- **Persistent sessions** — conversations maintain context across messages
+- **Session management** — create, switch, list, and share sessions
+- **Model switching** — change AI models on the fly (`/model`)
+- **Plan/Build modes** — toggle between read-only analysis and full execution
+- **Smart formatting** — code blocks with syntax highlighting in Telegram
+- **Auto message splitting** — handles responses longer than Telegram's 4096 char limit
+- **Security** — whitelist-based access control + rate limiting
+- **Workspace Switching** — Switching from one workspace to another
+
+## 📋 Prerequisites
+
+1. **Python 3.10+**
+2. **OpenCode CLI** — install via:
+   ```bash
+   npm install -g opencode-ai
+   # or
+   curl -fsSL https://opencode.ai/install | bash
+   ```
+3. **Telegram Bot Token** — get one from [@BotFather](https://t.me/BotFather)
+4. **Your Telegram User ID** — send `/id` to the bot after setup, or use [@userinfobot](https://t.me/userinfobot)
+
+## 🚀 Quick Start
+
+### 1. Clone & Install
+
+```bash
+cd telegram-opencode-bot
+pip install -r requirements.txt
+```
+
+### 2. Run the Bot
+
+```bash
+python bot.py
+python bot.py --env (use --env flag if u want to re-configure later anytime)
+```
+> **💡 Tip:** Don't know your Telegram user ID? Start the bot with `AUTHORIZED_USERS=0` temporarily, send `/id` to the bot, then update the `.env` with your real ID.
+
+### 3. Chat!
+
+Open Telegram, find your bot, and start asking! 🎉
+
+## 📱 Commands
+
+| Command | Description |
+|---------|-------------|
+| `/start` | Welcome message & connection check |
+| `/help` | Show all commands |
+| `/new` | Start a fresh conversation |
+| `/sessions` | List your recent sessions |
+| `/switch <id>` | Switch to a different session |
+| `/model <name>` | Change AI model(ex: /model opencode/deepseek-v4-flash-free) |
+| `/mode <plan\|build>` | Toggle plan/build mode |
+| `/share` | Share current session (public URL) |
+| `/status` | Check connection & session details |
+| `/id` | Show your Telegram user ID |
+| `/stop` | Abort active model processing |
+| `/models` | List all available models |
+| `/project` | To view the current workspace, sub folder workspaces and to change the workspace (ex: /project 2)|
+| `/project depth <1to5>` | Depth level recursive check for subfolders (ex: if u give depth 2, only 2 sub folders it will show from root) |
+| `/enable` | To enable the streaming |
+| `/disable` | To disable the streaming |
+
+## 🏗️ Architecture
+
+```
+Telegram User
+    │
+    ▼
+Telegram Bot (Python)
+    │
+    ├──► OpenCode HTTP API (localhost:4096)  ← primary
+            │
+            ├──► LLM Provider (Claude/GPT/Gemini)
+            └──► Local Filesystem & Shell
+```
+
+## ⚙️ Configuration
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather | **Required** |
+| `AUTHORIZED_USERS` | Comma-separated Telegram user IDs | **Required** |
+| `OPENCODE_SERVER_URL` | OpenCode HTTP API URL | `http://localhost:4096` |
+| `OPENCODE_SERVER_USERNAME` | OpenCode auth username | *(empty)* |
+| `OPENCODE_SERVER_PASSWORD` | OpenCode auth password | *(empty)* |
+| `OPENCODE_MODEL` | Default AI model | `anthropic/claude-sonnet-4` |
+| `OPENCODE_WORK_DIR` | Working directory for OpenCode | `.` |
+| `MAX_MESSAGE_LENGTH` | Max Telegram message length | `4000` |
+| `RESPONSE_TIMEOUT` | Max wait for response (seconds) | `0` |
+| `DB_PATH` | SQLite database path | `sessions.db` |
+
+## 🔒 Security
+
+- **User whitelist** — only Telegram user IDs in `AUTHORIZED_USERS` can use the bot
+- **Rate limiting** — 20 requests per minute per user (configurable)
+- **No public exposure** — designed to run on your local machine
+
+> ⚠️ **Warning:** This bot executes AI-driven code on your machine. Only authorize trusted users.
+
+## 📁 Project Structure
+
+```
+telegram-opencode-bot/
+├── bot.py                  # Main entry point
+├── config.py               # Environment configuration
+├── handlers/
+│   ├── commands.py         # Slash command handlers
+│   └── messages.py         # Text message → OpenCode bridge
+├── opencode/
+│   ├── client.py           # OpenCode HTTP API client
+│   
+├── sessions/
+│   └── manager.py          # Per-user session tracking (SQLite)
+├── utils/
+│   ├── formatting.py       # Telegram message formatting
+│   └── security.py         # Auth, rate limiting, sanitization
+├── .env.example            # Environment template
+├── requirements.txt        # Python dependencies
+└── README.md               # This file
+```
+

telegram_opencode_bridge_bot-0.1.2/bot.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+"""
+Telegram → OpenCode Bridge Bot
+
+Main entry point. Wires together all components:
+- Telegram bot (python-telegram-bot)
+- OpenCode HTTP client + subprocess fallback
+- Session manager (SQLite-backed)
+- Security (auth whitelist + rate limiting)
+
+Usage:
+    1. Copy .env.example → .env and fill in your values
+    2. Start OpenCode server:  opencode serve
+    3. Run the bot:  python bot.py
+"""
+
+import asyncio
+import logging
+import sys
+import os
+
+from telegram import Update
+from telegram.ext import (
+    ApplicationBuilder,
+    CommandHandler,
+    MessageHandler,
+    filters,
+    ContextTypes,
+)
+from utils.formatting import format_error
+
+from config import config
+from opencode.client import OpenCodeClient
+from sessions.manager import SessionManager
+from utils.security import UserAuthorizer, RateLimiter, authorized
+from handlers.commands import (
+    start_command,
+    help_command,
+    new_command,
+    sessions_command,
+    switch_command,
+    model_command,
+    mode_command,
+    share_command,
+    status_command,
+    id_command,
+    models_command,
+    stop_command,
+    project_command,
+    enable_command,
+    disable_command,
+    set_bot_commands,
+)
+from handlers.messages import handle_message
+
+# ── Logging Setup ──────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[logging.StreamHandler(sys.stderr)],
+)
+logger = logging.getLogger("opencode-telegram-bot")
+
+
+# ── Wrap handlers with auth decorator ──────────────────────
+
+def build_authorized_handlers(authorizer: UserAuthorizer, rate_limiter: RateLimiter):
+    """Wrap all handlers with authorization and rate limiting."""
+
+    @authorized(authorizer, rate_limiter)
+    async def _start(update, context):
+        await start_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _help(update, context):
+        await help_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _new(update, context):
+        await new_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _sessions(update, context):
+        await sessions_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _switch(update, context):
+        await switch_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _model(update, context):
+        await model_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _mode(update, context):
+        await mode_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _share(update, context):
+        await share_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _status(update, context):
+        await status_command(update, context)
+
+    @authorized(authorizer)
+    async def _id(update, context):
+        await id_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _models(update, context):
+        await models_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _stop(update, context):
+        await stop_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _project(update, context):
+        await project_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _enable(update, context):
+        await enable_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _disable(update, context):
+        await disable_command(update, context)
+
+    @authorized(authorizer, rate_limiter)
+    async def _message(update, context):
+        await handle_message(update, context)
+
+    return {
+        "start": _start,
+        "help": _help,
+        "new": _new,
+        "sessions": _sessions,
+        "switch": _switch,
+        "model": _model,
+        "models": _models,
+        "stop": _stop,
+        "project": _project,
+        "enable": _enable,
+        "disable": _disable,
+        "mode": _mode,
+        "share": _share,
+        "status": _status,
+        "id": _id,
+        "message": _message,
+    }
+
+
+async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Log the error and send a Telegram message to notify the user."""
+    # Log the error with traceback
+    logger.error("Exception while handling an update:", exc_info=context.error)
+
+    # Notify the user if the update is a Telegram Update with a message
+    if isinstance(update, Update) and update.effective_message:
+        try:
+            error_message = f"An unexpected error occurred: {context.error}"
+            # Reply to the user with the formatted error
+            await update.effective_message.reply_text(
+                format_error(error_message),
+                parse_mode="HTML"
+            )
+        except Exception as e:
+            logger.error(f"Failed to send error notification message: {e}")
+
+
+async def post_init(application) -> None:
+    """Run after the bot application is initialized."""
+    # Register bot commands in Telegram's menu
+    await set_bot_commands(application)
+
+    # Initialize session manager
+    session_mgr = application.bot_data["session_manager"]
+    await session_mgr.initialize()
+
+    logger.info("🤖 Bot is ready! (OpenCode serve will start lazily on the first message)")
+
+
+async def post_shutdown(application) -> None:
+    """Clean up resources on shutdown."""
+    logger.info("Shutting down...")
+
+    # Stop the background opencode server process if running
+    try:
+        from opencode.server import stop_server
+        await stop_server()
+    except Exception as e:
+        logger.warning(f"Failed to stop background OpenCode server: {e}")
+
+    # Close session manager DB
+    session_mgr = application.bot_data.get("session_manager")
+    if session_mgr:
+        await session_mgr.close()
+
+    # Close HTTP client
+    oc_client = application.bot_data.get("opencode_client")
+    if oc_client:
+        await oc_client.close()
+
+    logger.info("Goodbye!")
+
+
+def run_firstrun_setup():
+    """Interactively prompts the user for configuration values and writes them to .env."""
+    print("=" * 60)
+    print("🚀 OpenCode Telegram Bot — Interactive First-Run Setup")
+    print("=" * 60)
+    print("This utility will help you configure your .env file.\n")
+    
+    # 1. Read existing .env values if they exist, to provide defaults
+    current_values = {}
+    if os.path.exists(".env"):
+        try:
+            with open(".env", "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        k, v = line.split("=", 1)
+                        # Strip quotes if present
+                        v = v.strip().strip("'\"")
+                        current_values[k.strip()] = v
+        except Exception:
+            pass
+
+    # Helper function to ask with default
+    def ask(key, prompt_text, default_val=""):
+        default = current_values.get(key, default_val)
+        default_display = f" [{default}]" if default else ""
+        
+        try:
+            val = input(f"{prompt_text}{default_display}: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\nSetup aborted.")
+            sys.exit(1)
+            
+        if not val:
+            return default
+        return val
+
+    # 2. Gather inputs
+    token = ask(
+        "TELEGRAM_BOT_TOKEN", 
+        "1. Enter your TELEGRAM_BOT_TOKEN (from @BotFather)"
+    )
+    while not token:
+        print("❌ TELEGRAM_BOT_TOKEN is required to run the bot!")
+        token = ask("TELEGRAM_BOT_TOKEN", "1. Enter your TELEGRAM_BOT_TOKEN")
+
+    users = ask(
+        "AUTHORIZED_USERS", 
+        "2. Enter AUTHORIZED_USERS (comma-separated Telegram User IDs, e.g. 846469353)"
+    )
+    while not users:
+        print("❌ AUTHORIZED_USERS is required to restrict access to the bot!")
+        users = ask("AUTHORIZED_USERS", "2. Enter AUTHORIZED_USERS")
+
+    server_url = ask(
+        "OPENCODE_SERVER_URL", 
+        "3. Enter OPENCODE_SERVER_URL", 
+        "http://localhost:4096"
+    )
+    
+    username = ask(
+        "OPENCODE_SERVER_USERNAME", 
+        "4. Enter OPENCODE_SERVER_USERNAME (leave blank if no authentication)"
+    )
+    
+    password = ask(
+        "OPENCODE_SERVER_PASSWORD", 
+        "5. Enter OPENCODE_SERVER_PASSWORD (leave blank if no authentication)"
+    )
+    
+    model = ask(
+        "OPENCODE_MODEL", 
+        "6. Enter OPENCODE_MODEL", 
+        "opencode/deepseek-v4-flash-free"
+    )
+    
+    work_dir = ask(
+        "OPENCODE_WORK_DIR", 
+        "7. Enter OPENCODE_WORK_DIR (full path to your parent workspace)", 
+        os.path.abspath(".")
+    )
+
+    # 3. Format and write .env
+    env_content = f"""# Telegram Bot Configuration
+TELEGRAM_BOT_TOKEN={token}
+AUTHORIZED_USERS={users}
+
+# OpenCode Configuration
+OPENCODE_SERVER_URL={server_url}
+OPENCODE_SERVER_USERNAME={username}
+OPENCODE_SERVER_PASSWORD={password}
+OPENCODE_MODEL={model}
+OPENCODE_WORK_DIR="{work_dir}"
+
+# Limits
+MAX_MESSAGE_LENGTH=4000
+RESPONSE_TIMEOUT=0  # Set to 0 to disable request timeouts entirely
+
+# Database
+DB_PATH=sessions.db
+"""
+
+    try:
+        with open(".env", "w", encoding="utf-8") as f:
+            f.write(env_content)
+        print("\n✅ Success! Configuration written to .env file.")
+        print("=" * 60)
+        print("You can now start the bot using:")
+        print("  python bot.py")
+        print("=" * 60 + "\n")
+    except Exception as e:
+        print(f"\n❌ Error writing to .env file: {e}")
+
+
+def main():
+    """Build and run the Telegram bot."""
+
+    # If --env CLI flag is passed, or if .env does not exist, run setup
+    if "--env" in sys.argv:
+        run_firstrun_setup()
+        sys.exit(0)
+
+    if not os.path.exists(".env"):
+        print("⚠️ .env file not found!")
+        try:
+            choice = input("Would you like to run the interactive setup now? (y/n): ").strip().lower()
+            if choice in ("y", "yes"):
+                run_firstrun_setup()
+                print("\nSetup complete! Starting the bot...")
+            else:
+                print("Please copy .env.example to .env and configure it before starting.")
+                sys.exit(1)
+        except (KeyboardInterrupt, EOFError):
+            print("\nSetup cancelled.")
+            sys.exit(1)
+
+    # ── Validate config ───────────────────────────────────
+    try:
+        config.validate()
+    except ValueError as e:
+        logger.error(f"Configuration error: {e}")
+        logger.error("Copy .env.example → .env and fill in your values.")
+        sys.exit(1)
+
+    logger.info("=" * 50)
+    logger.info("  OpenCode Telegram Bot")
+    logger.info("=" * 50)
+    logger.info(f"  OpenCode Server: {config.opencode_server_url}")
+    logger.info(f"  Default Model:   {config.opencode_model}")
+    logger.info(f"  Work Directory:  {config.opencode_work_dir}")
+    logger.info(f"  Authorized Users: {len(config.authorized_users)}")
+    logger.info("=" * 50)
+
+    # ── Initialize components ─────────────────────────────
+    authorizer = UserAuthorizer(config.authorized_users)
+    rate_limiter = RateLimiter(max_requests=20, window_seconds=60)
+
+    oc_client = OpenCodeClient(
+        server_url=config.opencode_server_url,
+        username=config.opencode_server_username,
+        password=config.opencode_server_password,
+        timeout=config.response_timeout,
+    )
+
+    session_mgr = SessionManager(db_path=config.db_path)
+
+    # ── Build Telegram application ────────────────────────
+    application = (
+        ApplicationBuilder()
+        .token(config.telegram_bot_token)
+        .post_init(post_init)
+        .post_shutdown(post_shutdown)
+        .build()
+    )
+
+    # ── Register global error handler ─────────────────────
+    application.add_error_handler(error_handler)
+
+    # Store components in bot_data for access in handlers
+    application.bot_data["config"] = config
+    application.bot_data["opencode_client"] = oc_client
+    application.bot_data["session_manager"] = session_mgr
+    application.bot_data["server_started"] = False
+
+    # ── Build auth-wrapped handlers ───────────────────────
+    handlers = build_authorized_handlers(authorizer, rate_limiter)
+
+    # ── Register command handlers ─────────────────────────
+    application.add_handler(CommandHandler("start", handlers["start"], block=False))
+    application.add_handler(CommandHandler("help", handlers["help"], block=False))
+    application.add_handler(CommandHandler("new", handlers["new"], block=False))
+    application.add_handler(CommandHandler("sessions", handlers["sessions"], block=False))
+    application.add_handler(CommandHandler("switch", handlers["switch"], block=False))
+    application.add_handler(CommandHandler("model", handlers["model"], block=False))
+    application.add_handler(CommandHandler("models", handlers["models"], block=False))
+    application.add_handler(CommandHandler("stop", handlers["stop"], block=False))
+    application.add_handler(CommandHandler("project", handlers["project"], block=False))
+    application.add_handler(CommandHandler("enable", handlers["enable"], block=False))
+    application.add_handler(CommandHandler("disable", handlers["disable"], block=False))
+    application.add_handler(CommandHandler("mode", handlers["mode"], block=False))
+    application.add_handler(CommandHandler("share", handlers["share"], block=False))
+    application.add_handler(CommandHandler("status", handlers["status"], block=False))
+    application.add_handler(CommandHandler("id", handlers["id"], block=False))
+
+    # ── Register message handler (catches all text) ───────
+    application.add_handler(
+        MessageHandler(
+            filters.TEXT & ~filters.COMMAND,
+            handlers["message"],
+            block=False,
+        )
+    )
+
+    # ── Start polling ─────────────────────────────────────
+    logger.info("Starting bot with long polling...")
+    application.run_polling(
+        drop_pending_updates=True,
+        allowed_updates=["message"],
+    )
+
+
+if __name__ == "__main__":
+    main()

telegram_opencode_bridge_bot-0.1.2/config.py

@@ -0,0 +1,92 @@
+"""
+Configuration module for the Telegram-OpenCode bot.
+
+Loads settings from environment variables (with .env file support)
+and exposes them via a validated dataclass singleton.
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import List
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Config:
+    """Application configuration loaded from environment variables.
+
+    Attributes:
+        telegram_bot_token: Bot token obtained from @BotFather.
+        authorized_users: List of Telegram user IDs permitted to interact with the bot.
+        opencode_server_url: Base URL of the OpenCode HTTP server.
+        opencode_server_username: Optional username for OpenCode server authentication.
+        opencode_server_password: Optional password for OpenCode server authentication.
+        opencode_model: LLM model identifier used by OpenCode.
+        opencode_work_dir: Working directory OpenCode operates in.
+        max_message_length: Maximum characters per Telegram message chunk.
+        response_timeout: Seconds to wait for an OpenCode response before timing out.
+        db_path: File path for the SQLite session database.
+    """
+
+    # Telegram
+    telegram_bot_token: str = field(
+        default_factory=lambda: os.getenv('TELEGRAM_BOT_TOKEN', '')
+    )
+    authorized_users: List[int] = field(
+        default_factory=lambda: [
+            int(uid.strip())
+            for uid in os.getenv('AUTHORIZED_USERS', '').split(',')
+            if uid.strip().isdigit()
+        ]
+    )
+
+    # OpenCode
+    opencode_server_url: str = field(
+        default_factory=lambda: os.getenv('OPENCODE_SERVER_URL', 'http://localhost:4444')
+    )
+    opencode_server_username: str = field(
+        default_factory=lambda: os.getenv('OPENCODE_SERVER_USERNAME', '')
+    )
+    opencode_server_password: str = field(
+        default_factory=lambda: os.getenv('OPENCODE_SERVER_PASSWORD', '')
+    )
+    opencode_model: str = field(
+        default_factory=lambda: os.getenv('OPENCODE_MODEL', 'OpenCode Zen/DeepSeek V4 Flash Free')
+    )
+    opencode_work_dir: str = field(
+        default_factory=lambda: os.getenv('OPENCODE_WORK_DIR', '.')
+    )
+    project_scan_depth: int = field(
+        default_factory=lambda: int(os.getenv('PROJECT_SCAN_DEPTH', '2'))
+    )
+
+    # Limits
+    max_message_length: int = field(
+        default_factory=lambda: int(os.getenv('MAX_MESSAGE_LENGTH', '4000'))
+    )
+    response_timeout: int = field(
+        default_factory=lambda: int(os.getenv('RESPONSE_TIMEOUT', '300'))
+    )
+
+    # Database
+    db_path: str = field(
+        default_factory=lambda: os.getenv('DB_PATH', 'sessions.db')
+    )
+
+    def validate(self) -> None:
+        """Validate that all required configuration values are present.
+
+        Raises:
+            ValueError: If a required configuration value is missing.
+        """
+        if not self.telegram_bot_token:
+            raise ValueError('TELEGRAM_BOT_TOKEN is required')
+        if not self.authorized_users:
+            raise ValueError(
+                'AUTHORIZED_USERS is required (comma-separated Telegram user IDs)'
+            )
+
+
+config = Config()

telegram_opencode_bridge_bot-0.1.2/list_session_models.py

@@ -0,0 +1,44 @@
+import asyncio
+import aiohttp
+import json
+
+async def main():
+    url = "http://localhost:4444"
+    async with aiohttp.ClientSession() as session:
+        # Create a session
+        async with session.post(f"{url}/session") as resp:
+            create_json = await resp.json()
+            session_id = create_json.get("id") or create_json.get("session_id")
+            
+        print(f"Created session ID: {session_id}")
+        
+        # Query GET /session/:id/models
+        models_url = f"{url}/session/{session_id}/models"
+        print(f"Querying {models_url}...")
+        async with session.get(models_url) as resp:
+            print(f"Status: {resp.status}")
+            data = await resp.json()
+            
+            # Print complete JSON to see all configured models
+            print("\n--- All Configured Models on OpenCode Serve ---")
+            print(json.dumps(data, indent=2))
+            
+            # Search for DeepSeek or Zen
+            print("\n--- Searching for 'deepseek' or 'zen' ---")
+            found = False
+            data_str = json.dumps(data)
+            if "deepseek" in data_str.lower() or "zen" in data_str.lower():
+                print("MATCH FOUND!")
+                # Let's inspect the exact provider and model IDs
+                if isinstance(data, dict):
+                    # Usually returned as { "models": { ... }, "providers": [ ... ] } or similar
+                    for k, v in data.items():
+                        if "deepseek" in k.lower() or "zen" in k.lower() or "deepseek" in json.dumps(v).lower() or "zen" in json.dumps(v).lower():
+                            print(f"\nKey: {k}")
+                            print(json.dumps(v, indent=2)[:1000])
+                            found = True
+            if not found:
+                print("No matches found for DeepSeek or Zen.")
+
+if __name__ == "__main__":
+    asyncio.run(main())

{telegram_opencode_bridge_bot-0.1.0 → telegram_opencode_bridge_bot-0.1.2}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "telegram-opencode-bridge-bot"
-version = "0.1.0"
+version = "0.1.2"
 description = "A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
 authors = [
-  { name = "MaheshNagabhairava", email = "your@email.com" }
+  { name = "MaheshNagabhairava", email = "maheshnagabhirava12345@gmail.com" }
 ]
 keywords = ["telegram", "bot", "opencode", "ai", "coding", "bridge"]
 classifiers = [
@@ -32,4 +32,7 @@ Homepage = "https://github.com/MaheshNagabhairava/telegram-opencode-bridge-bot"
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["handlers*", "opencode*", "sessions*", "utils*"]
+include = ["handlers*", "opencode*", "sessions*", "utils*"]
+
+[tool.setuptools]
+py-modules = ["bot", "config", "list_session_models"]

{telegram_opencode_bridge_bot-0.1.0 → telegram_opencode_bridge_bot-0.1.2/telegram_opencode_bridge_bot.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.0
+Version: 0.1.2
 Summary: A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine
-Author-email: MaheshNagabhairava <your@email.com>
+Author-email: MaheshNagabhairava <maheshnagabhirava12345@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/MaheshNagabhairava/telegram-opencode-bridge-bot
 Keywords: telegram,bot,opencode,ai,coding,bridge
@@ -52,25 +52,15 @@ cd telegram-opencode-bot
 pip install -r requirements.txt
 ```
 
-### 2. Start OpenCode Server
-
-In a separate terminal:
-
-```bash
-opencode serve --port 4096 --hostname 127.0.0.1
-```
-
-This starts the OpenCode HTTP API on `localhost:4096`.
-
-### 3. Run the Bot
+### 2. Run the Bot
 
 ```bash
 python bot.py
-python bot.py --env (if u want to setup ur configuration later)
+python bot.py --env (use --env flag if u want to re-configure later anytime)
 ```
 > **💡 Tip:** Don't know your Telegram user ID? Start the bot with `AUTHORIZED_USERS=0` temporarily, send `/id` to the bot, then update the `.env` with your real ID.
 
-### 4. Chat!
+### 3. Chat!
 
 Open Telegram, find your bot, and start asking! 🎉
 

{telegram_opencode_bridge_bot-0.1.0 → telegram_opencode_bridge_bot-0.1.2}/telegram_opencode_bridge_bot.egg-info/SOURCES.txt

@@ -1,6 +1,9 @@
 .env.example
 MANIFEST.in
 README.md
+bot.py
+config.py
+list_session_models.py
 pyproject.toml
 requirements.txt
 handlers/__init__.py

{telegram_opencode_bridge_bot-0.1.0 → telegram_opencode_bridge_bot-0.1.2}/telegram_opencode_bridge_bot.egg-info/top_level.txt

@@ -1,4 +1,7 @@
+bot
+config
 handlers
+list_session_models
 opencode
 sessions
 utils