telegram-opencode-bridge-bot 0.1.8__tar.gz → 0.1.9__tar.gz

{telegram_opencode_bridge_bot-0.1.8/telegram_opencode_bridge_bot.egg-info → telegram_opencode_bridge_bot-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.8
+Version: 0.1.9
 Summary: A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine
 Author-email: MaheshNagabhairava <maheshnagabhirava12345@gmail.com>
 License-Expression: MIT
@@ -58,7 +58,7 @@ A premium, feature-rich Python bot that bridges your Telegram client directly to
 ### Option A: Standard PyPI Installation
 Install and run the bot wrapper directly from the terminal:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.8
+pip install telegram-opencode-bridge-bot==0.1.9
 telegram-opencode-bot
 ```
 > **💡 Tip:** Use the `--env` flag anytime to reconfigure your variables:
@@ -106,7 +106,7 @@ telegram-opencode-bot
 | **`/enable`** | — | Enables real-time streaming of tool calls, shell executions, and file edits. |
 | **`/disable`** | — | Disables streaming; the bot will only report the final LLM response. |
 | **`/share`** | — | Fetches a public, shareable web preview URL of the active conversation. |
-
+| **`/update`** | — | Update to a new available version. |
 ---
 
 ## ⚙️ Configuration Variables

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/README.md

@@ -41,7 +41,7 @@ A premium, feature-rich Python bot that bridges your Telegram client directly to
 ### Option A: Standard PyPI Installation
 Install and run the bot wrapper directly from the terminal:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.8
+pip install telegram-opencode-bridge-bot==0.1.9
 telegram-opencode-bot
 ```
 > **💡 Tip:** Use the `--env` flag anytime to reconfigure your variables:
@@ -89,7 +89,7 @@ telegram-opencode-bot
 | **`/enable`** | — | Enables real-time streaming of tool calls, shell executions, and file edits. |
 | **`/disable`** | — | Disables streaming; the bot will only report the final LLM response. |
 | **`/share`** | — | Fetches a public, shareable web preview URL of the active conversation. |
-
+| **`/update`** | — | Update to a new available version. |
 ---
 
 ## ⚙️ Configuration Variables

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/bot.py

@@ -60,6 +60,7 @@ from handlers.commands import (
     enable_command,
     disable_command,
     history_command,
+    update_command,
     set_bot_commands,
     callback_handler,
 )
@@ -211,6 +212,10 @@ def build_authorized_handlers(authorizer: UserAuthorizer, rate_limiter: RateLimi
     async def _history(update, context):
         await history_command(update, context)
 
+    @authorized(authorizer, rate_limiter)
+    async def _update(update, context):
+        await update_command(update, context)
+
     @authorized(authorizer)
     async def _callback(update, context):
         await callback_handler(update, context)
@@ -237,6 +242,7 @@ def build_authorized_handlers(authorizer: UserAuthorizer, rate_limiter: RateLimi
         "enable": _enable,
         "disable": _disable,
         "history": _history,
+        "update": _update,
         "plan": _plan,
         "build": _build,
         "mode": _mode,
@@ -550,6 +556,7 @@ def main():
     application.add_handler(CommandHandler("enable", handlers["enable"], block=False))
     application.add_handler(CommandHandler("disable", handlers["disable"], block=False))
     application.add_handler(CommandHandler("history", handlers["history"], block=False))
+    application.add_handler(CommandHandler("update", handlers["update"], block=False))
     application.add_handler(CommandHandler("mode", handlers["mode"], block=False))
     application.add_handler(CommandHandler("plan", handlers["plan"], block=False))
     application.add_handler(CommandHandler("build", handlers["build"], block=False))

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/handlers/commands.py

@@ -69,7 +69,8 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
         "/build — Switch to build mode (read, write, execute)\n"
         "/share — Share current session (get public URL)\n"
         "/status — Show bot & connection status\n"
-        "/id — Show your Telegram user ID\n\n"
+        "/id — Show your Telegram user ID\n"
+        "/update — Check and install updates\n\n"
         "<b>💡 Tips:</b>\n"
         "• Just type normally to chat with OpenCode\n"
         "• Use <code>@filename</code> in prompts to reference files\n"
@@ -1158,6 +1159,127 @@ async def history_command(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             await asyncio.sleep(0.5)
 
 
+# ──────────────────────────────────────────────
+# Command: /update
+# ──────────────────────────────────────────────
+async def update_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Check for and apply bot updates, then restart the process in-place."""
+    import asyncio
+    import os
+    import sys
+    import html
+    from utils.formatting import format_error
+
+    user_id = update.effective_user.id
+    
+    # 1. Send initial status message
+    status_msg = await update.message.reply_text(
+        "⏳ <b>Checking for bot updates...</b>",
+        parse_mode="HTML"
+    )
+
+    async def update_status(text: str):
+        try:
+            await status_msg.edit_text(text, parse_mode="HTML")
+        except Exception:
+            await update.message.reply_text(text, parse_mode="HTML")
+
+    is_git = os.path.exists(".git")
+    
+    def run_cmd_sync(command: str) -> tuple[int, str, str]:
+        """Helper to run a shell command synchronously."""
+        import subprocess
+        proc = subprocess.run(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+
+    async def run_cmd(command: str) -> tuple[int, str, str]:
+        """Helper to run a shell command in a background thread."""
+        return await asyncio.to_thread(run_cmd_sync, command)
+
+    if is_git:
+        await update_status("🔍 <b>Detected Git installation. Fetching remote changes...</b>")
+        
+        # 1. Git fetch
+        code, stdout, stderr = await run_cmd("git fetch origin")
+        if code != 0:
+            await update_status(
+                f"❌ <b>Git fetch failed:</b>\n"
+                f"<pre>{html.escape(stderr or stdout)}</pre>"
+            )
+            return
+
+        # 2. Check diff
+        code_local, local_hash, _ = await run_cmd("git rev-parse HEAD")
+        code_remote, remote_hash, _ = await run_cmd("git rev-parse @{u}")
+        
+        if code_local != 0 or code_remote != 0:
+            await update_status("❌ <b>Failed to resolve Git commit hashes.</b>")
+            return
+
+        if local_hash == remote_hash:
+            await update_status(
+                f"✨ <b>Your bot is already up to date!</b>\n"
+                f"Commit: <code>{local_hash[:8]}</code>"
+            )
+            return
+
+        await update_status("🔄 <b>New updates found. Pulling latest code changes...</b>")
+        
+        # 3. Git pull
+        code_pull, pull_stdout, pull_stderr = await run_cmd("git pull")
+        if code_pull != 0:
+            await update_status(
+                f"❌ <b>Git pull failed:</b>\n"
+                f"<pre>{html.escape(pull_stderr or pull_stdout)}</pre>"
+            )
+            return
+
+        # 4. Pip install requirements if updated
+        if os.path.exists("requirements.txt"):
+            await update_status("📦 <b>Updating dependencies from requirements.txt...</b>")
+            await run_cmd(f"{sys.executable} -m pip install -r requirements.txt")
+
+    else:
+        # Pip package installation
+        await update_status("🔍 <b>Detected Pip installation. Checking PyPI for updates...</b>")
+        
+        # Run pip install --upgrade
+        code, stdout, stderr = await run_cmd(f"{sys.executable} -m pip install --upgrade telegram-opencode-bridge-bot")
+        if code != 0:
+            await update_status(
+                f"❌ <b>Pip upgrade failed:</b>\n"
+                f"<pre>{html.escape(stderr or stdout)}</pre>"
+            )
+            return
+
+        # Check if it was already up to date
+        if "Requirement already satisfied" in stdout and "Successfully installed" not in stdout:
+            await update_status("✨ <b>Your bot is already up to date!</b>")
+            return
+
+    # Trigger restart
+    await update_status("✅ <b>Update complete! Restarting bot in-place...</b>")
+    
+    # Wait 1 second to let Telegram send the message completely
+    await asyncio.sleep(1)
+    
+    # Close any running connections or servers nicely
+    try:
+        from opencode.server import stop_server
+        await stop_server()
+    except Exception:
+        pass
+
+    # Exec process replacement
+    os.execv(sys.executable, [sys.executable] + sys.argv)
+
+
 # ──────────────────────────────────────────────
 # Register bot commands for Telegram menu
 # ──────────────────────────────────────────────
@@ -1183,6 +1305,7 @@ async def set_bot_commands(app) -> None:
         BotCommand("share", "Share current session"),
         BotCommand("status", "Bot & connection status"),
         BotCommand("id", "Show your Telegram user ID"),
+        BotCommand("update", "Check and install updates"),
     ]
     await app.bot.set_my_commands(commands)
     

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/handlers/messages.py

@@ -450,7 +450,9 @@ async def _listen_and_stream_events(
     is_streaming: bool,
     status_msg_holder = None
 ):
-    """Listens to global OpenCode events via SSE and handles tool progress/permission requests."""
+    """Listens to global OpenCode events via SSE and handles tool progress/permission requests.
+    Includes an automatic reconnect loop with exponential back-off to prevent getting stuck.
+    """
     import aiohttp
     import json
     import html
@@ -483,261 +485,273 @@ async def _listen_and_stream_events(
             except Exception as e:
                 logger.debug(f"Failed to update status message: {e}")
 
-    async with aiohttp.ClientSession(read_bufsize=100 * 1024 * 1024) as sse_session:
+    retry_delay = 1.0
+    while True:
         try:
-            async with sse_session.get(url, headers={"Accept": "text/event-stream"}) as resp:
-                async for line in resp.content:
-                    line_str = line.decode('utf-8').strip()
-                    if not line_str or not line_str.startswith("data:"):
-                        continue
+            async with aiohttp.ClientSession(read_bufsize=100 * 1024 * 1024) as sse_session:
+                async with sse_session.get(url, headers={"Accept": "text/event-stream"}) as resp:
+                    # Connection successful, reset retry delay
+                    retry_delay = 1.0
                     
-                    data_content = line_str[5:].strip()
-                    try:
-                        event_obj = json.loads(data_content)
-                        payload = event_obj.get("payload", {})
-                        if not isinstance(payload, dict):
-                            continue
-                        
-                        properties = payload.get("properties", {})
-                        if not isinstance(properties, dict):
+                    async for line in resp.content:
+                        line_str = line.decode('utf-8').strip()
+                        if not line_str or not line_str.startswith("data:"):
                             continue
                         
-                        event_session_id = (
-                            properties.get("sessionID")
-                            or properties.get("sessionId")
-                            or properties.get("session_id")
-                            or payload.get("sessionID")
-                            or payload.get("sessionId")
-                            or payload.get("session_id")
-                            or ""
-                        )
-                        if event_session_id != session_id:
-                            continue
-
-                        event_type = payload.get("type", "")
-
-                        # A. Handle Intermediate Assistant Message Completion (Real-time Streaming)
-                        if event_type == "message.updated":
-                            info = properties.get("info", {})
-                            msg_id = info.get("id")
-                            role = info.get("role")
-                            completed = info.get("time", {}).get("completed")
+                        data_content = line_str[5:].strip()
+                        try:
+                            event_obj = json.loads(data_content)
+                            payload = event_obj.get("payload", {})
+                            if not isinstance(payload, dict):
+                                continue
                             
-                            if role == "assistant" and completed:
-                                sent_message_ids = context.user_data.setdefault("sent_message_ids", set())
-                                if msg_id not in sent_message_ids:
-                                    sent_message_ids.add(msg_id)
-                                    try:
-                                        oc_client = context.bot_data["opencode_client"]
-                                        messages = await oc_client.list_messages(session_id)
-                                        target_msg = next((m for m in messages if m.get("info", {}).get("id") == msg_id), None)
-                                        if target_msg:
-                                            parts = target_msg.get("parts", [])
-                                            content_text = ""
-                                            if isinstance(parts, list):
-                                                text_parts = [
-                                                    p.get("text", "")
-                                                    for p in parts
-                                                    if isinstance(p, dict) and p.get("type") == "text"
-                                                ]
-                                                content_text = "".join(text_parts)
-                                            
-                                            if content_text.strip():
-                                                # Delete the old status message at the top
-                                                if status_msg_holder and status_msg_holder[0]:
-                                                    try:
-                                                        await status_msg_holder[0].delete()
-                                                    except Exception:
-                                                        pass
-                                                    status_msg_holder[0] = None
-
-                                                from utils.formatting import format_opencode_response, split_message
-                                                formatted = format_opencode_response(content_text)
-                                                chunks = split_message(formatted, context.bot_data["config"].max_message_length)
-                                                for i, chunk in enumerate(chunks):
-                                                    await update.message.reply_text(
-                                                        chunk,
-                                                        parse_mode="HTML",
-                                                        disable_web_page_preview=True,
-                                                    )
-                                                    if i < len(chunks) - 1:
-                                                        await asyncio.sleep(0.5)
-
-                                                # Recreate the status indicator at the very bottom
-                                                if status_msg_holder:
-                                                    try:
-                                                        status_msg_holder[0] = await update.message.reply_text(
-                                                            last_status_text[0],
-                                                            parse_mode="HTML"
-                                                        )
-                                                        last_update_time[0] = time.time()
-                                                    except Exception as e:
-                                                        logger.warning(f"Failed to recreate status message at bottom: {e}")
-                                    except Exception as e:
-                                        logger.warning(f"Failed to stream intermediate message {msg_id}: {e}")
-
-                        # B. Handle Permission Requested Popup (Always Enabled)
-                        elif event_type == "permission.asked":
-                            perm_id = properties.get("id") or properties.get("permissionID") or payload.get("id")
-                            perm_type = properties.get("permission") or properties.get("type") or "execute"
-                            patterns = properties.get("patterns", [])
-
-                            if not perm_id:
-                                logger.warning("Received permission.asked event but no permission ID was found.")
+                            properties = payload.get("properties", {})
+                            if not isinstance(properties, dict):
                                 continue
-
-                            # Register pending permission in-memory lookup to avoid Telegram 64-char callback limit
-                            if "pending_permissions" not in context.bot_data:
-                                context.bot_data["pending_permissions"] = {}
-
-                            short_key = uuid.uuid4().hex[:8]
-                            context.bot_data["pending_permissions"][short_key] = {
-                                "session_id": session_id,
-                                "permission_id": perm_id
-                            }
-
-                            patterns_text = ""
-                            if patterns:
-                                pat_list = "\n".join([f"• <code>{html.escape(str(p))}</code>" for p in patterns])
-                                patterns_text = f"\n<b>Target Resource(s):</b>\n{pat_list}"
-
-                            tool_name = ""
-                            tool_info = properties.get("tool", {})
-                            if isinstance(tool_info, dict):
-                                tool_name = tool_info.get("name", "")
-                            if not tool_name:
-                                tool_name = perm_type
-
-                            msg = (
-                                f"🛡️ <b>OpenCode Permission Requested</b>\n\n"
-                                f"The agent is asking for confirmation to use the tool <code>{html.escape(tool_name)}</code>.\n"
-                                f"{patterns_text}\n\n"
-                                f"Do you want to allow this operation?"
+                            
+                            event_session_id = (
+                                properties.get("sessionID")
+                                or properties.get("sessionId")
+                                or properties.get("session_id")
+                                or payload.get("sessionID")
+                                or payload.get("sessionId")
+                                or payload.get("session_id")
+                                or ""
                             )
+                            if event_session_id != session_id:
+                                continue
+
+                            event_type = payload.get("type", "")
+
+                            # A. Handle Intermediate Assistant Message Completion (Real-time Streaming)
+                            if event_type == "message.updated":
+                                info = properties.get("info", {})
+                                msg_id = info.get("id")
+                                role = info.get("role")
+                                completed = info.get("time", {}).get("completed")
+                                
+                                if role == "assistant" and completed:
+                                    sent_message_ids = context.user_data.setdefault("sent_message_ids", set())
+                                    if msg_id not in sent_message_ids:
+                                        sent_message_ids.add(msg_id)
+                                        try:
+                                            oc_client = context.bot_data["opencode_client"]
+                                            messages = await oc_client.list_messages(session_id)
+                                            target_msg = next((m for m in messages if m.get("info", {}).get("id") == msg_id), None)
+                                            if target_msg:
+                                                parts = target_msg.get("parts", [])
+                                                content_text = ""
+                                                if isinstance(parts, list):
+                                                    text_parts = [
+                                                        p.get("text", "")
+                                                        for p in parts
+                                                        if isinstance(p, dict) and p.get("type") == "text"
+                                                    ]
+                                                    content_text = "".join(text_parts)
+                                                
+                                                if content_text.strip():
+                                                    # Delete the old status message at the top
+                                                    if status_msg_holder and status_msg_holder[0]:
+                                                        try:
+                                                            await status_msg_holder[0].delete()
+                                                        except Exception:
+                                                            pass
+                                                        status_msg_holder[0] = None
+
+                                                    from utils.formatting import format_opencode_response, split_message
+                                                    formatted = format_opencode_response(content_text)
+                                                    chunks = split_message(formatted, context.bot_data["config"].max_message_length)
+                                                    for i, chunk in enumerate(chunks):
+                                                        await update.message.reply_text(
+                                                            chunk,
+                                                            parse_mode="HTML",
+                                                            disable_web_page_preview=True,
+                                                        )
+                                                        if i < len(chunks) - 1:
+                                                            await asyncio.sleep(0.5)
+
+                                                    # Recreate the status indicator at the very bottom
+                                                    if status_msg_holder:
+                                                        try:
+                                                            status_msg_holder[0] = await update.message.reply_text(
+                                                                last_status_text[0],
+                                                                parse_mode="HTML"
+                                                            )
+                                                            last_update_time[0] = time.time()
+                                                        except Exception as e:
+                                                            logger.warning(f"Failed to recreate status message at bottom: {e}")
+                                        except Exception as e:
+                                            logger.warning(f"Failed to stream intermediate message {msg_id}: {e}")
+
+                            # B. Handle Permission Requested Popup (Always Enabled)
+                            elif event_type == "permission.asked":
+                                perm_id = properties.get("id") or properties.get("permissionID") or payload.get("id")
+                                perm_type = properties.get("permission") or properties.get("type") or "execute"
+                                patterns = properties.get("patterns", [])
+
+                                if not perm_id:
+                                    logger.warning("Received permission.asked event but no permission ID was found.")
+                                    continue
 
-                            keyboard = [
-                                [
-                                    InlineKeyboardButton("✅ Yes, Allow", callback_data=f"perm:allow:{short_key}"),
-                                    InlineKeyboardButton("❌ No, Deny", callback_data=f"perm:deny:{short_key}")
+                                # Register pending permission in-memory lookup to avoid Telegram 64-char callback limit
+                                if "pending_permissions" not in context.bot_data:
+                                    context.bot_data["pending_permissions"] = {}
+
+                                short_key = uuid.uuid4().hex[:8]
+                                context.bot_data["pending_permissions"][short_key] = {
+                                    "session_id": session_id,
+                                    "permission_id": perm_id
+                                }
+
+                                patterns_text = ""
+                                if patterns:
+                                    pat_list = "\n".join([f"• <code>{html.escape(str(p))}</code>" for p in patterns])
+                                    patterns_text = f"\n<b>Target Resource(s):</b>\n{pat_list}"
+
+                                tool_name = ""
+                                tool_info = properties.get("tool", {})
+                                if isinstance(tool_info, dict):
+                                    tool_name = tool_info.get("name", "")
+                                if not tool_name:
+                                    tool_name = perm_type
+
+                                msg = (
+                                    f"🛡️ <b>OpenCode Permission Requested</b>\n\n"
+                                    f"The agent is asking for confirmation to use the tool <code>{html.escape(tool_name)}</code>.\n"
+                                    f"{patterns_text}\n\n"
+                                    f"Do you want to allow this operation?"
+                                )
+
+                                keyboard = [
+                                    [
+                                        InlineKeyboardButton("✅ Yes, Allow", callback_data=f"perm:allow:{short_key}"),
+                                        InlineKeyboardButton("❌ No, Deny", callback_data=f"perm:deny:{short_key}")
+                                    ]
                                 ]
-                            ]
 
-                            await update.message.reply_text(
-                                msg,
-                                parse_mode="HTML",
-                                reply_markup=InlineKeyboardMarkup(keyboard)
-                            )
+                                await update.message.reply_text(
+                                    msg,
+                                    parse_mode="HTML",
+                                    reply_markup=InlineKeyboardMarkup(keyboard)
+                                )
 
-                        # B. Handle Tool Execution Progress
-                        elif event_type == "message.part.updated":
-                            part = properties.get("part", {})
-                            if not isinstance(part, dict):
-                                continue
-                            
-                            part_type = part.get("type", "")
-                            if part_type == "tool":
-                                tool_name = part.get("tool", "unknown")
-                                call_id = part.get("callID", "unknown")
-                                state = part.get("state", {})
-                                if not isinstance(state, dict):
+                            # B. Handle Tool Execution Progress
+                            elif event_type == "message.part.updated":
+                                part = properties.get("part", {})
+                                if not isinstance(part, dict):
                                     continue
                                 
-                                status = state.get("status", "")
-                                input_data = state.get("input", {})
-                                output_data = state.get("output", "")
-                                metadata = state.get("metadata", {})
-                                if not isinstance(metadata, dict):
-                                    metadata = {}
-
-                                # ── 1. Update In-Place Status Message (Always Active) ──
-                                if status in ("pending", "running") and status_msg_holder and status_msg_holder[0]:
-                                    status_text = ""
-                                    if tool_name == "bash":
-                                        cmd = input_data.get("command") or input_data.get("content") or ""
-                                        cmd_truncated = truncate(cmd, 60)
-                                        status_text = f"💻 <b>Running shell command...</b>\n<code>{html.escape(cmd_truncated)}</code>"
-                                    elif tool_name in ("edit", "write", "save"):
-                                        path = input_data.get("path") or input_data.get("target") or input_data.get("filepath") or ""
-                                        path_truncated = truncate(os.path.basename(path) if path else "", 60)
-                                        status_text = f"📝 <b>Modifying file...</b>\n<code>{html.escape(path_truncated)}</code>"
-                                    elif tool_name in ("read", "view", "show"):
-                                        path = input_data.get("path") or input_data.get("target") or input_data.get("filepath") or ""
-                                        path_truncated = truncate(os.path.basename(path) if path else "", 60)
-                                        status_text = f"🔍 <b>Reading file...</b>\n<code>{html.escape(path_truncated)}</code>"
-                                    elif tool_name in ("webfetch", "websearch", "search"):
-                                        query = input_data.get("query") or input_data.get("url") or ""
-                                        query_truncated = truncate(query, 60)
-                                        status_text = f"🌐 <b>Searching web...</b>\n<code>{html.escape(query_truncated)}</code>"
-                                    else:
-                                        status_text = f"⚙️ <b>Executing tool <code>{html.escape(tool_name)}</code>...</b>"
+                                part_type = part.get("type", "")
+                                if part_type == "tool":
+                                    tool_name = part.get("tool", "unknown")
+                                    call_id = part.get("callID", "unknown")
+                                    state = part.get("state", {})
+                                    if not isinstance(state, dict):
+                                        continue
                                     
-                                    await update_status(status_text)
-
-                                # ── 2. Stream Full Tool Logs (Only if is_streaming is True) ──
-                                if is_streaming:
-                                    # 1. Tool Call Started / Running
-                                    if status in ("pending", "running") and call_id not in notified_calls:
-                                        notified_calls.add(call_id)
-                                        
-                                        desc = input_data.get("description", "") if isinstance(input_data, dict) else ""
-                                        desc_text = f" — <i>\"{html.escape(desc)}\"</i>" if desc else ""
-                                        
-                                        # Format arguments
-                                        arg_lines = []
-                                        if isinstance(input_data, dict):
-                                            for k, v in input_data.items():
-                                                if k not in ("description", "content"):
-                                                    arg_lines.append(f"<b>{html.escape(str(k))}:</b> {html.escape(truncate(str(v)))}")
-                                        args_text = "\n".join(arg_lines)
+                                    status = state.get("status", "")
+                                    input_data = state.get("input", {})
+                                    output_data = state.get("output", "")
+                                    metadata = state.get("metadata", {})
+                                    if not isinstance(metadata, dict):
+                                        metadata = {}
+
+                                    # ── 1. Update In-Place Status Message (Always Active) ──
+                                    if status in ("pending", "running") and status_msg_holder and status_msg_holder[0]:
+                                        status_text = ""
+                                        if tool_name == "bash":
+                                            cmd = input_data.get("command") or input_data.get("content") or ""
+                                            cmd_truncated = truncate(cmd, 60)
+                                            status_text = f"💻 <b>Running shell command...</b>\n<code>{html.escape(cmd_truncated)}</code>"
+                                        elif tool_name in ("edit", "write", "save"):
+                                            path = input_data.get("path") or input_data.get("target") or input_data.get("filepath") or ""
+                                            path_truncated = truncate(os.path.basename(path) if path else "", 60)
+                                            status_text = f"📝 <b>Modifying file...</b>\n<code>{html.escape(path_truncated)}</code>"
+                                        elif tool_name in ("read", "view", "show"):
+                                            path = input_data.get("path") or input_data.get("target") or input_data.get("filepath") or ""
+                                            path_truncated = truncate(os.path.basename(path) if path else "", 60)
+                                            status_text = f"🔍 <b>Reading file...</b>\n<code>{html.escape(path_truncated)}</code>"
+                                        elif tool_name in ("webfetch", "websearch", "search"):
+                                            query = input_data.get("query") or input_data.get("url") or ""
+                                            query_truncated = truncate(query, 60)
+                                            status_text = f"🌐 <b>Searching web...</b>\n<code>{html.escape(query_truncated)}</code>"
+                                        else:
+                                            status_text = f"⚙️ <b>Executing tool <code>{html.escape(tool_name)}</code>...</b>"
                                         
-                                        msg = (
-                                            f"🛠️ <b>Calling Tool <code>{html.escape(tool_name)}</code></b>{desc_text}\n"
-                                        )
-                                        if args_text:
-                                            msg += f"{args_text}\n"
-                                            
-                                        await update.message.reply_text(msg, parse_mode="HTML")
+                                        await update_status(status_text)
 
-                                    # 2. Tool Completed
-                                    elif status == "completed" and call_id not in completed_calls:
-                                        completed_calls.add(call_id)
-                                        
-                                        exit_code = metadata.get("exit", 0)
-                                        output_cleaned = truncate(str(output_data))
-                                        
-                                        msg = (
-                                            f"✅ <b>Tool <code>{html.escape(tool_name)}</code> Completed</b> (Exit <code>{exit_code}</code>)\n"
-                                        )
-                                        if output_cleaned.strip():
-                                            msg += f"<pre>{html.escape(output_cleaned)}</pre>"
-                                        else:
-                                            msg += f"<i>(No output returned)</i>"
+                                    # ── 2. Stream Full Tool Logs (Only if is_streaming is True) ──
+                                    if is_streaming:
+                                        # 1. Tool Call Started / Running
+                                        if status in ("pending", "running") and call_id not in notified_calls:
+                                            notified_calls.add(call_id)
                                             
-                                        await update.message.reply_text(msg, parse_mode="HTML")
-
-                                    # 3. Tool Failed
-                                    elif status in ("failed", "error") and call_id not in completed_calls:
-                                        completed_calls.add(call_id)
-                                        
-                                        output_cleaned = truncate(str(output_data))
-                                        
-                                        msg = (
-                                            f"❌ <b>Tool <code>{html.escape(tool_name)}</code> Failed</b>\n"
-                                        )
-                                        if output_cleaned.strip():
-                                            msg += f"<pre>{html.escape(output_cleaned)}</pre>"
-                                        else:
-                                            msg += f"<i>(No error description returned)</i>"
+                                            desc = input_data.get("description", "") if isinstance(input_data, dict) else ""
+                                            desc_text = f" — <i>\"{html.escape(desc)}\"</i>" if desc else ""
                                             
-                                        await update.message.reply_text(msg, parse_mode="HTML")
-
-                    except Exception as e:
-                        logger.debug(f"Error parsing SSE event in listener: {e}")
+                                            # Format arguments
+                                            arg_lines = []
+                                            if isinstance(input_data, dict):
+                                                for k, v in input_data.items():
+                                                    if k not in ("description", "content"):
+                                                        arg_lines.append(f"<b>{html.escape(str(k))}:</b> {html.escape(truncate(str(v)))}")
+                                            args_text = "\n".join(arg_lines)
+                                            
+                                            msg = (
+                                                f"🛠️ <b>Calling Tool <code>{html.escape(tool_name)}</code></b>{desc_text}\n"
+                                            )
+                                            if args_text:
+                                                msg += f"{args_text}\n"
+                                                
+                                            await update.message.reply_text(msg, parse_mode="HTML")
+
+                                        # 2. Tool Completed
+                                        elif status == "completed" and call_id not in completed_calls:
+                                            completed_calls.add(call_id)
+                                            
+                                            exit_code = metadata.get("exit", 0)
+                                            output_cleaned = truncate(str(output_data))
+                                            
+                                            msg = (
+                                                f"✅ <b>Tool <code>{html.escape(tool_name)}</code> Completed</b> (Exit <code>{exit_code}</code>)\n"
+                                            )
+                                            if output_cleaned.strip():
+                                                msg += f"<pre>{html.escape(output_cleaned)}</pre>"
+                                            else:
+                                                msg += f"<i>(No output returned)</i>"
+                                                
+                                            await update.message.reply_text(msg, parse_mode="HTML")
+
+                                        # 3. Tool Failed
+                                        elif status in ("failed", "error") and call_id not in completed_calls:
+                                            completed_calls.add(call_id)
+                                            
+                                            output_cleaned = truncate(str(output_data))
+                                            
+                                            msg = (
+                                                f"❌ <b>Tool <code>{html.escape(tool_name)}</code> Failed</b>\n"
+                                            )
+                                            if output_cleaned.strip():
+                                                msg += f"<pre>{html.escape(output_cleaned)}</pre>"
+                                            else:
+                                                msg += f"<i>(No error description returned)</i>"
+                                                
+                                            await update.message.reply_text(msg, parse_mode="HTML")
+
+                        except Exception as e:
+                            logger.debug(f"Error parsing SSE event in listener: {e}")
 
         except asyncio.CancelledError:
-            pass
+            logger.debug("SSE streaming task listener cancelled by parent task.")
+            break
         except Exception as e:
-            logger.warning(f"Error in SSE streaming task listener: {e}")
+            err_name = e or type(e).__name__
+            logger.warning(f"Error in SSE streaming task listener: {err_name}. Reconnecting in {retry_delay}s...")
+            try:
+                await asyncio.sleep(retry_delay)
+            except asyncio.CancelledError:
+                break
+            retry_delay = min(retry_delay * 2, 10.0)
 
 
 async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/opencode/server.py

@@ -41,45 +41,65 @@ async def restart_server(directory: str, port: int = 8080, hostname: str = "127.
     await stop_server()
     await asyncio.sleep(1)
 
-    # 2. Start a new one from the target directory
     binary = get_opencode_binary()
     cmd = [binary, "serve", "--port", str(port), "--hostname", hostname]
 
-    logger.info(f"Starting opencode serve from {directory}: {' '.join(cmd)}")
-
-    try:
-        creationflags = 0
-        if platform.system() == "Windows":
-            # CREATE_NEW_PROCESS_GROUP = 0x00000200
-            creationflags = 0x00000200
-
-        _server_process = subprocess.Popen(
-            cmd,
-            cwd=directory,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            stdin=subprocess.DEVNULL,
-            creationflags=creationflags,
-            start_new_session=(platform.system() != "Windows"),
-        )
-    except Exception as e:
-        logger.error(f"Failed to start opencode serve: {e}")
-        return False
-
-    # 3. Wait until the server is reachable (max 30s)
-    import aiohttp
-    for attempt in range(30):
-        await asyncio.sleep(1)
+    creationflags = 0
+    if platform.system() == "Windows":
+        creationflags = 0x00000200  # CREATE_NEW_PROCESS_GROUP
+
+    for run_attempt in range(1, 3):
+        logger.info(f"Starting opencode serve (attempt {run_attempt}/2) from {directory}: {' '.join(cmd)}")
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"http://{hostname}:{port}/session", timeout=aiohttp.ClientTimeout(total=2)) as resp:
-                    if resp.status < 500:
-                        logger.info(f"opencode serve is up after {attempt + 1}s (pid={_server_process.pid})")
-                        return True
-        except Exception:
-            pass
-
-    logger.error("opencode serve did not become reachable within 30s")
+            _server_process = subprocess.Popen(
+                cmd,
+                cwd=directory,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                creationflags=creationflags,
+                start_new_session=(platform.system() != "Windows"),
+            )
+        except Exception as e:
+            logger.error(f"Failed to start opencode serve on attempt {run_attempt}: {e}")
+            if run_attempt == 2:
+                return False
+            await asyncio.sleep(2)
+            continue
+
+        # 3. Wait until the server is reachable (max 15 attempts, 1s sleep + 1s timeout)
+        import aiohttp
+        for attempt in range(15):
+            # Check if the process exited prematurely
+            poll_code = _server_process.poll()
+            if poll_code is not None:
+                logger.warning(f"opencode serve process exited prematurely with code {poll_code} on attempt {run_attempt}")
+                break
+
+            await asyncio.sleep(1)
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(f"http://{hostname}:{port}/session", timeout=aiohttp.ClientTimeout(total=1)) as resp:
+                        if resp.status < 500:
+                            logger.info(f"opencode serve is up after {attempt + 1}s (pid={_server_process.pid})")
+                            return True
+            except Exception:
+                pass
+
+        # Cleanup failed process
+        if _server_process:
+            try:
+                _server_process.terminate()
+                _server_process.wait(timeout=2)
+            except Exception:
+                pass
+            _server_process = None
+
+        if run_attempt == 1:
+            logger.warning("First startup attempt failed or port was busy. Retrying in 2 seconds...")
+            await asyncio.sleep(2)
+
+    logger.error("opencode serve did not become reachable after 2 attempts")
     return False
 
 

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "telegram-opencode-bridge-bot"
-version = "0.1.8"
+version = "0.1.9"
 description = "A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine"
 readme = "README.md"
 license = "MIT"

{telegram_opencode_bridge_bot-0.1.8 → telegram_opencode_bridge_bot-0.1.9/telegram_opencode_bridge_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.8
+Version: 0.1.9
 Summary: A Telegram bot that bridges messages directly to OpenCode — an AI coding agent running on your machine
 Author-email: MaheshNagabhairava <maheshnagabhirava12345@gmail.com>
 License-Expression: MIT
@@ -58,7 +58,7 @@ A premium, feature-rich Python bot that bridges your Telegram client directly to
 ### Option A: Standard PyPI Installation
 Install and run the bot wrapper directly from the terminal:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.8
+pip install telegram-opencode-bridge-bot==0.1.9
 telegram-opencode-bot
 ```
 > **💡 Tip:** Use the `--env` flag anytime to reconfigure your variables:
@@ -106,7 +106,7 @@ telegram-opencode-bot
 | **`/enable`** | — | Enables real-time streaming of tool calls, shell executions, and file edits. |
 | **`/disable`** | — | Disables streaming; the bot will only report the final LLM response. |
 | **`/share`** | — | Fetches a public, shareable web preview URL of the active conversation. |
-
+| **`/update`** | — | Update to a new available version. |
 ---
 
 ## ⚙️ Configuration Variables