telegram-opencode-bridge-bot 0.1.6__tar.gz → 0.1.7__tar.gz

{telegram_opencode_bridge_bot-0.1.6/telegram_opencode_bridge_bot.egg-info → telegram_opencode_bridge_bot-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.6
+Version: 0.1.7
 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
@@ -47,7 +47,7 @@ A lightweight Python bot that bridges your Telegram messages directly to [OpenCo
 
 ### Quick Installation:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.6
+pip install telegram-opencode-bridge-bot==0.1.7
 telegram-opencode-bot
 telegram-opencode-bot --env (use --env flag if u want to re-configure later anytime)
 ```

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/README.md

@@ -30,7 +30,7 @@ A lightweight Python bot that bridges your Telegram messages directly to [OpenCo
 
 ### Quick Installation:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.6
+pip install telegram-opencode-bridge-bot==0.1.7
 telegram-opencode-bot
 telegram-opencode-bot --env (use --env flag if u want to re-configure later anytime)
 ```

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/bot.py

@@ -19,6 +19,10 @@ import logging
 import sys
 import os
 
+# Switch to Selector Event Loop on Windows for robust signal handling and clean shutdowns
+if sys.platform == 'win32':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
 from telegram import Update
 from telegram.ext import (
     ApplicationBuilder,
@@ -67,6 +71,43 @@ logging.basicConfig(
 )
 logger = logging.getLogger("opencode-telegram-bot")
 
+_lock_file = None
+
+def acquire_bot_lock():
+    """Acquire an exclusive lock file to prevent multiple instances from running concurrently."""
+    global _lock_file
+    lock_path = os.path.join(os.path.abspath("."), "bot.lock")
+    try:
+        _lock_file = open(lock_path, "w")
+        if os.name == 'nt':
+            import msvcrt
+            try:
+                _lock_file.seek(0)
+                msvcrt.locking(_lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+                _lock_file.write(str(os.getpid()))
+                _lock_file.flush()
+            except (OSError, IOError):
+                print("\n" + "="*65)
+                print("❌ ERROR: Another instance of the Telegram bot is already running!")
+                print("Please close the other terminal or kill the stray Python process.")
+                print("="*65 + "\n")
+                sys.exit(1)
+        else:
+            import fcntl
+            try:
+                fcntl.flock(_lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                _lock_file.write(str(os.getpid()))
+                _lock_file.flush()
+            except (OSError, IOError):
+                print("\n" + "="*65)
+                print("❌ ERROR: Another instance of the Telegram bot is already running!")
+                print("Please close the other terminal or kill the stray Python process.")
+                print("="*65 + "\n")
+                sys.exit(1)
+    except Exception as e:
+        logger.warning(f"Could not acquire bot lock: {e}")
+
+
 
 class RetryingHTTPXRequest(HTTPXRequest):
     """Custom HTTPXRequest that automatically retries failed requests on connection timeouts/errors."""
@@ -198,8 +239,17 @@ def build_authorized_handlers(authorizer: UserAuthorizer, rate_limiter: RateLimi
 
 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)
+    # Suppress full traceback for common transient network / timeout errors to keep logs clean
+    from telegram.error import NetworkError, TimedOut
+    
+    err = context.error
+    err_str = str(err).lower()
+    if isinstance(err, (NetworkError, TimedOut)) or "httpx" in err_str or "httpcore" in err_str or "read error" in err_str:
+        logger.warning(f"📡 Transient Telegram network/timeout error: {err}")
+        return
+
+    # Log unexpected errors with traceback
+    logger.error("Exception while handling an update:", exc_info=err)
 
     # Notify the user if the update is a Telegram Update with a message
     if isinstance(update, Update) and update.effective_message:
@@ -233,19 +283,25 @@ async def post_shutdown(application) -> None:
     # Stop the background opencode server process if running
     try:
         from opencode.server import stop_server
-        await stop_server()
+        await asyncio.wait_for(stop_server(), timeout=8.0)
     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()
+        try:
+            await asyncio.wait_for(session_mgr.close(), timeout=3.0)
+        except Exception as e:
+            logger.warning(f"Failed to close session manager: {e}")
 
     # Close HTTP client
     oc_client = application.bot_data.get("opencode_client")
     if oc_client:
-        await oc_client.close()
+        try:
+            await asyncio.wait_for(oc_client.close(), timeout=3.0)
+        except Exception as e:
+            logger.warning(f"Failed to close HTTP client: {e}")
 
     logger.info("Goodbye!")
 
@@ -412,6 +468,9 @@ def main():
         logger.error("Copy .env.example → .env and fill in your values.")
         sys.exit(1)
 
+    # ── Acquire exclusive bot lock to prevent concurrent instances ───────
+    acquire_bot_lock()
+
     logger.info("=" * 50)
     logger.info("  OpenCode Telegram Bot")
     logger.info("=" * 50)
@@ -447,6 +506,7 @@ def main():
         ApplicationBuilder()
         .token(config.telegram_bot_token)
         .request(request)
+        .get_updates_request(request)
         .post_init(post_init)
         .post_shutdown(post_shutdown)
         .build()

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/handlers/commands.py

@@ -828,7 +828,9 @@ async def execute_project_switch(update_or_query, context: ContextTypes.DEFAULT_
             if not session_id:
                 raise ValueError("Response did not contain a session ID.")
 
-            await session_mgr.set_active_session(user_id, session_id, config.opencode_model, work_dir=target_path)
+            # Fetch user preferred model, falling back to config model
+            preferred_model = await session_mgr.get_user_preferred_model(user_id, config.opencode_model)
+            await session_mgr.set_active_session(user_id, session_id, preferred_model, work_dir=target_path)
 
             await update_status(
                 f"🔄 <b>Switched project to:</b> <code>{html.escape(target_folder)}</code>\n"

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/handlers/messages.py

@@ -146,6 +146,8 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
         parse_mode="HTML"
     )
     
+    status_msg_holder = [status_msg]
+    
     # Always spawn the SSE event stream listener so we can handle interactive permission prompts
     # (e.g. for sensitive files like .env) even if the user has disabled regular tool-call progress.
     sse_task = asyncio.create_task(
@@ -155,14 +157,24 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             session_id=session_id,
             server_url=config.opencode_server_url,
             is_streaming=bool(is_streaming == 1),
-            status_msg=status_msg
+            status_msg_holder=status_msg_holder
         )
     )
 
     typing_task = asyncio.create_task(
         _keep_typing(update, config.response_timeout)
     )
+    before_ids = set()
+    sent_message_ids = context.user_data.setdefault("sent_message_ids", set())
+    sent_message_ids.clear()
     try:
+        # Fetch message IDs before sending the prompt
+        try:
+            before_messages = await oc_client.list_messages(session_id)
+            before_ids = {m.get("info", {}).get("id") for m in before_messages if m.get("info", {}).get("id")}
+        except Exception as e:
+            logger.warning(f"Failed to fetch messages before prompt: {e}")
+
         session_info = await session_mgr.get_session_info(user_id)
         session_model = (session_info or {}).get("model", config.opencode_model) or config.opencode_model
 
@@ -276,9 +288,9 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
         if sse_task:
             sse_task.cancel()
         # Clean up by deleting the temporary live phase status message
-        if status_msg:
+        if status_msg_holder and status_msg_holder[0]:
             try:
-                await status_msg.delete()
+                await status_msg_holder[0].delete()
             except Exception:
                 pass
 
@@ -286,40 +298,78 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
     await session_mgr.increment_message_count(user_id, prompt=message_text)
 
     # ── 5. Format and send response ───────────────────────
-    if not response_text or response_text == "ABORTED":
-        # Silent return for aborted, cancelled, or empty responses
+    # Fetch messages after prompt completes to get all multi-step assistant messages
+    response_texts = []
+    try:
+        after_messages = await oc_client.list_messages(session_id)
+        new_messages = [
+            m for m in after_messages
+            if m.get("info", {}).get("id") not in before_ids 
+            and m.get("info", {}).get("id") not in sent_message_ids
+            and m.get("info", {}).get("role") == "assistant"
+        ]
+        for m in new_messages:
+            parts = m.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():
+                response_texts.append(content_text)
+    except Exception as e:
+        logger.warning(f"Failed to fetch messages after prompt: {e}")
+
+    # Fallback to standard response if no intermediate texts were retrieved
+    all_responses = response_texts if response_texts else ([response_text] if response_text else [])
+
+    if not all_responses:
+        if response_text == "ABORTED":
+            return
+        # Send a user-friendly status message to prevent getting stuck silently
+        await update.message.reply_text(
+            "ℹ️ <b>OpenCode finished execution.</b>\n<i>(No conversational text response was returned)</i>",
+            parse_mode="HTML"
+        )
         return
 
-    # Format OpenCode output for Telegram
-    formatted = format_opencode_response(response_text)
+    for resp in all_responses:
+        if not resp or resp == "ABORTED":
+            continue
 
-    # Split into chunks if too long
-    chunks = split_message(formatted, config.max_message_length)
+        # Format OpenCode output for Telegram
+        formatted = format_opencode_response(resp)
 
-    for i, chunk in enumerate(chunks):
-        try:
-            await update.message.reply_text(
-                chunk,
-                parse_mode="HTML",
-                disable_web_page_preview=True,
-            )
-        except Exception as e:
-            # If HTML parsing fails, try sending as plain text
-            logger.warning(f"HTML parse failed for chunk {i+1}, falling back to plain text: {e}")
+        # Split into chunks if too long
+        chunks = split_message(formatted, config.max_message_length)
+
+        for i, chunk in enumerate(chunks):
             try:
-                # Strip HTML tags for plain text fallback
-                import re
-                plain = re.sub(r'<[^>]+>', '', chunk)
                 await update.message.reply_text(
-                    plain,
+                    chunk,
+                    parse_mode="HTML",
                     disable_web_page_preview=True,
                 )
-            except Exception as e2:
-                logger.error(f"Failed to send chunk {i+1} even as plain text: {e2}")
+            except Exception as e:
+                # If HTML parsing fails, try sending as plain text
+                logger.warning(f"HTML parse failed for chunk {i+1}, falling back to plain text: {e}")
+                try:
+                    # Strip HTML tags for plain text fallback
+                    import re
+                    plain = re.sub(r'<[^>]+>', '', chunk)
+                    await update.message.reply_text(
+                        plain,
+                        disable_web_page_preview=True,
+                    )
+                except Exception as e2:
+                    logger.error(f"Failed to send chunk {i+1} even as plain text: {e2}")
 
-        # Small delay between chunks to respect rate limits
-        if i < len(chunks) - 1:
-            await asyncio.sleep(0.5)
+            # Small delay between chunks to respect rate limits
+            if i < len(chunks) - 1:
+                await asyncio.sleep(0.5)
 
 
 async def _create_session(oc_client, user_id, session_mgr, config):
@@ -339,7 +389,10 @@ async def _create_session(oc_client, user_id, session_mgr, config):
     if not session_id:
         raise ValueError(f"OpenCode server response did not contain a session ID: {result}")
 
-    await session_mgr.set_active_session(user_id, session_id, config.opencode_model, work_dir=work_dir)
+    # Fetch user preferred model, falling back to config model
+    preferred_model = await session_mgr.get_user_preferred_model(user_id, config.opencode_model)
+
+    await session_mgr.set_active_session(user_id, session_id, preferred_model, work_dir=work_dir)
     return session_id
 
 
@@ -382,7 +435,7 @@ async def _listen_and_stream_events(
     session_id: str,
     server_url: str,
     is_streaming: bool,
-    status_msg = None
+    status_msg_holder = None
 ):
     """Listens to global OpenCode events via SSE and handles tool progress/permission requests."""
     import aiohttp
@@ -396,6 +449,7 @@ async def _listen_and_stream_events(
     notified_calls = set()
     completed_calls = set()
     last_update_time = [0.0]
+    last_status_text = ["🧠 <b>Thinking...</b>\n<i>Analyzing request and preparing a plan...</i>"]
 
     def truncate(text, max_len=500):
         if not text:
@@ -407,10 +461,11 @@ async def _listen_and_stream_events(
 
     async def update_status(text: str):
         now = time.time()
+        last_status_text[0] = text
         # Throttling to respect Telegram API rate limits (minimum 1.5 seconds between message edits)
-        if status_msg and (now - last_update_time[0] >= 1.5):
+        if status_msg_holder and status_msg_holder[0] and (now - last_update_time[0] >= 1.5):
             try:
-                await status_msg.edit_text(text, parse_mode="HTML")
+                await status_msg_holder[0].edit_text(text, parse_mode="HTML")
                 last_update_time[0] = now
             except Exception as e:
                 logger.debug(f"Failed to update status message: {e}")
@@ -434,14 +489,82 @@ async def _listen_and_stream_events(
                         if not isinstance(properties, dict):
                             continue
                         
-                        event_session_id = properties.get("sessionID", "")
+                        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 Permission Requested Popup (Always Enabled)
-                        if event_type == "permission.asked":
+                        # 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", [])
@@ -514,7 +637,7 @@ async def _listen_and_stream_events(
                                     metadata = {}
 
                                 # ── 1. Update In-Place Status Message (Always Active) ──
-                                if status in ("pending", "running") and status_msg:
+                                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 ""
@@ -734,6 +857,8 @@ async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             "🧠 <b>Thinking...</b>\n<i>Analyzing request and preparing a plan...</i>",
             parse_mode="HTML"
         )
+        
+        status_msg_holder = [status_msg]
 
         sse_task = asyncio.create_task(
             _listen_and_stream_events(
@@ -742,7 +867,7 @@ async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
                 session_id=session_id,
                 server_url=config.opencode_server_url,
                 is_streaming=bool(is_streaming == 1),
-                status_msg=status_msg
+                status_msg_holder=status_msg_holder
             )
         )
 
@@ -750,10 +875,20 @@ async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             _keep_typing(update, config.response_timeout)
         )
 
+        before_ids = set()
+        sent_message_ids = context.user_data.setdefault("sent_message_ids", set())
+        sent_message_ids.clear()
         try:
             session_info = await session_mgr.get_session_info(user_id)
             session_model = (session_info or {}).get("model", config.opencode_model) or config.opencode_model
 
+            # Fetch message IDs before sending the prompt
+            try:
+                before_messages = await oc_client.list_messages(session_id)
+                before_ids = {m.get("info", {}).get("id") for m in before_messages if m.get("info", {}).get("id")}
+            except Exception as e:
+                logger.warning(f"Failed to fetch messages before document prompt: {e}")
+
             response_text = await _send_to_opencode(
                 oc_client=oc_client,
                 session_id=session_id,
@@ -765,9 +900,54 @@ async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             await session_mgr.increment_message_count(user_id, prompt=caption)
 
             # Send response back to user
-            if response_text and response_text != "ABORTED":
-                formatted = format_opencode_response(response_text)
+            # Fetch messages after prompt completes to get all multi-step assistant messages
+            response_texts = []
+            try:
+                after_messages = await oc_client.list_messages(session_id)
+                new_messages = [
+                    m for m in after_messages
+                    if m.get("info", {}).get("id") not in before_ids 
+                    and m.get("info", {}).get("id") not in sent_message_ids
+                    and m.get("info", {}).get("role") == "assistant"
+                ]
+                for m in new_messages:
+                    parts = m.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():
+                        response_texts.append(content_text)
+            except Exception as e:
+                logger.warning(f"Failed to fetch messages after document prompt: {e}")
+
+            # Fallback to standard response if no intermediate texts were retrieved
+            all_responses = response_texts if response_texts else ([response_text] if response_text else [])
+
+            if not all_responses:
+                if response_text == "ABORTED":
+                    return
+                # Send a user-friendly status message to prevent getting stuck silently
+                await update.message.reply_text(
+                    "ℹ️ <b>OpenCode finished execution.</b>\n<i>(No conversational text response was returned)</i>",
+                    parse_mode="HTML"
+                )
+                return
+
+            for resp in all_responses:
+                if not resp or resp == "ABORTED":
+                    continue
+
+                # Format OpenCode output for Telegram
+                formatted = format_opencode_response(resp)
+
+                # Split into chunks if too long
                 chunks = split_message(formatted, config.max_message_length)
+
                 for i, chunk in enumerate(chunks):
                     try:
                         await update.message.reply_text(
@@ -796,9 +976,9 @@ async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
                 typing_task.cancel()
             if sse_task:
                 sse_task.cancel()
-            if status_msg:
+            if status_msg_holder and status_msg_holder[0]:
                 try:
-                    await status_msg.delete()
+                    await status_msg_holder[0].delete()
                 except Exception:
                     pass
 

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/opencode/client.py

@@ -274,6 +274,20 @@ class OpenCodeClient:
             return result.get("sessions", result.get("data", []))
         return []
 
+    async def list_messages(self, session_id: str) -> List[Dict[str, Any]]:
+        """List all messages in an OpenCode session.
+
+        Parameters:
+            session_id: The session identifier.
+
+        Returns:
+            A list of message dictionaries.
+        """
+        result = await self._request("GET", f"/session/{session_id}/message")
+        if isinstance(result, list):
+            return result
+        return []
+
     async def create_session(self, directory: Optional[str] = None) -> Dict[str, Any]:
         """Create a new OpenCode session.
 

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/opencode/server.py

@@ -103,34 +103,37 @@ async def stop_server() -> None:
     # Also kill any stray opencode serve processes on our port
     if platform.system() == "Windows":
         try:
-            # Query netstat to find process ID listening on the port
-            cmd = f'netstat -ano | findstr LISTENING | findstr :{_server_port}'
-            proc = await asyncio.create_subprocess_shell(
-                cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.DEVNULL
+            # Query netstat to find process ID listening on the port synchronously
+            proc = subprocess.run(
+                f'netstat -ano | findstr LISTENING | findstr :{_server_port}',
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                timeout=5
             )
-            stdout, _ = await proc.communicate()
-            lines = stdout.decode().strip().split('\n')
+            stdout = proc.stdout
+            lines = stdout.strip().split('\n')
             for line in lines:
                 parts = line.strip().split()
                 if len(parts) >= 5:
                     pid = parts[-1]
                     if pid.isdigit() and int(pid) > 0:
-                        os.system(f"taskkill /F /T /PID {pid}")
+                        subprocess.run(f"taskkill /F /T /PID {pid}", shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5)
                         logger.info(f"Killed stray Windows PID={pid} on port {_server_port}")
         except Exception as e:
             logger.warning(f"Failed to kill stray Windows process: {e}")
     else:
-        # Unix lsof implementation
+        # Unix lsof implementation synchronously
         try:
-            proc = await asyncio.create_subprocess_exec(
-                "lsof", "-ti", f":{_server_port}", "-sTCP:LISTEN",
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.DEVNULL,
+            proc = subprocess.run(
+                ["lsof", "-ti", f":{_server_port}", "-sTCP:LISTEN"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                timeout=5
             )
-            stdout, _ = await proc.communicate()
-            pids = stdout.decode().strip().split()
+            pids = proc.stdout.strip().split()
             for pid in pids:
                 if pid.isdigit():
                     try:

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "telegram-opencode-bridge-bot"
-version = "0.1.6"
+version = "0.1.7"
 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.6 → telegram_opencode_bridge_bot-0.1.7}/sessions/manager.py

@@ -65,6 +65,11 @@ class SessionManager:
             await self._db.execute("ALTER TABLE user_settings ADD COLUMN streaming INTEGER DEFAULT 0")
         except aiosqlite.OperationalError:
             pass
+
+        try:
+            await self._db.execute("ALTER TABLE user_settings ADD COLUMN model TEXT DEFAULT ''")
+        except aiosqlite.OperationalError:
+            pass
             
         await self._db.execute("""  
             CREATE INDEX IF NOT EXISTS idx_user_active 
@@ -174,7 +179,11 @@ class SessionManager:
             await self._db.commit()
     
     async def set_model(self, user_id: int, model: str) -> None:
-        """Set the model for a user's active session."""
+        """Set the model for a user's active session and also save as preferred settings."""
+        # 1. Save in user_settings
+        await self.set_user_preferred_model(user_id, model)
+        
+        # 2. Update active session if exists
         if user_id in self._active_sessions:
             self._active_sessions[user_id]["model"] = model
             await self._db.execute(
@@ -182,6 +191,27 @@ class SessionManager:
                 (model, user_id)
             )
             await self._db.commit()
+
+    async def get_user_preferred_model(self, user_id: int, default_model: str) -> str:
+        """Get the preferred model for a specific user, falling back to default."""
+        async with self._db.execute(
+            "SELECT model FROM user_settings WHERE user_id = ?",
+            (user_id,)
+        ) as cursor:
+            row = await cursor.fetchone()
+            if row and row[0]:
+                return row[0]
+        return default_model
+
+    async def set_user_preferred_model(self, user_id: int, model: str) -> None:
+        """Save or update the preferred model for a user in their settings."""
+        await self._db.execute(
+            "INSERT INTO user_settings (user_id, work_dir, model) VALUES (?, '', ?) "
+            "ON CONFLICT(user_id) DO UPDATE SET model = excluded.model",
+            (user_id, model)
+        )
+        await self._db.commit()
+        logger.info(f"Set preferred model for user {user_id}: {model}")
     
     async def clear_session(self, user_id: int) -> None:
         """Deactivate the current session for a user (they'll get a new one on next message)."""

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7/telegram_opencode_bridge_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-opencode-bridge-bot
-Version: 0.1.6
+Version: 0.1.7
 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
@@ -47,7 +47,7 @@ A lightweight Python bot that bridges your Telegram messages directly to [OpenCo
 
 ### Quick Installation:
 ```bash
-pip install telegram-opencode-bridge-bot==0.1.6
+pip install telegram-opencode-bridge-bot==0.1.7
 telegram-opencode-bot
 telegram-opencode-bot --env (use --env flag if u want to re-configure later anytime)
 ```

{telegram_opencode_bridge_bot-0.1.6 → telegram_opencode_bridge_bot-0.1.7}/utils/formatting.py

@@ -35,7 +35,9 @@ def format_opencode_response(text: str) -> str:
                 formatted_parts.append(f'<pre>{escaped}</pre>')
         else:
             # Regular text — convert markdown to HTML
-            formatted_parts.append(_markdown_to_html(content))
+            html_converted = _markdown_to_html(content)
+            # Parse and convert markdown tables inside the HTML-converted text
+            formatted_parts.append(_convert_markdown_tables(html_converted))
     
     return "\n".join(formatted_parts)
 
@@ -98,6 +100,154 @@ def _markdown_to_html(text: str) -> str:
     return text
 
 
+def _convert_markdown_tables(text: str) -> str:
+    """Detect and convert Markdown tables to Telegram-friendly HTML cards or lists."""
+    lines = text.split("\n")
+    processed_lines = []
+    
+    in_table = False
+    table_headers = []
+    table_rows = []
+    
+    def flush_table():
+        nonlocal in_table, table_headers, table_rows
+        if not table_headers:
+            in_table = False
+            table_rows = []
+            return []
+        
+        formatted_table = []
+        num_cols = len(table_headers)
+        
+        if num_cols == 2:
+            # 2 Columns (Checklist / Key-Value Card)
+            header_left = table_headers[0].strip()
+            header_right = table_headers[1].strip()
+            
+            # Strip tags for clean header title
+            h_left_raw = re.sub(r'<[^>]+>', '', header_left).strip()
+            formatted_table.append(f"<b>📋 {h_left_raw}</b>\n")
+            
+            for row in table_rows:
+                if len(row) >= 2:
+                    key = row[0].strip()
+                    val = row[1].strip()
+                    
+                    # Strip any redundant bold tags from key for clean styling
+                    clean_key = key
+                    if clean_key.startswith("<b>") and clean_key.endswith("</b>"):
+                        clean_key = clean_key[3:-4]
+                        
+                    formatted_table.append(f"• <b>{clean_key}:</b> {val}")
+            formatted_table.append("") # Empty line after table
+            
+        else:
+            # 3+ Columns (API Card Layout)
+            method_idx = -1
+            path_idx = -1
+            other_idxs = []
+            
+            for idx, h in enumerate(table_headers):
+                h_clean = h.strip().lower()
+                h_raw = re.sub(r'<[^>]+>', '', h_clean)
+                if "method" in h_raw:
+                    method_idx = idx
+                elif "path" in h_raw or "endpoint" in h_raw:
+                    path_idx = idx
+                else:
+                    other_idxs.append(idx)
+            
+            for row in table_rows:
+                method_val = row[method_idx].strip() if method_idx >= 0 and method_idx < len(row) else ""
+                path_val = row[path_idx].strip() if path_idx >= 0 and path_idx < len(row) else ""
+                
+                # Clean method and path from any HTML tags
+                method_raw = re.sub(r'<[^>]+>', '', method_val).upper().strip()
+                path_raw = re.sub(r'<[^>]+>', '', path_val).strip()
+                
+                # Format method badge with colored emojis
+                method_html = ""
+                if method_raw:
+                    emoji = "⚪"
+                    if "GET" in method_raw and "POST" in method_raw:
+                        emoji = "🟢/🔵"
+                    elif "GET" in method_raw:
+                        emoji = "🟢"
+                    elif "POST" in method_raw:
+                        emoji = "🔵"
+                    elif "PUT" in method_raw:
+                        emoji = "🟡"
+                    elif "DELETE" in method_raw:
+                        emoji = "🔴"
+                    elif "PATCH" in method_raw:
+                        emoji = "🟣"
+                    
+                    method_html = f"{emoji} <b>{method_raw}</b>"
+                
+                # Format path in monospaced code blocks
+                path_html = ""
+                if path_raw:
+                    path_html = f" <code>{path_raw}</code>"
+                
+                card_title = f"{method_html}{path_html}".strip()
+                if card_title:
+                    formatted_table.append(card_title)
+                
+                # Add other columns as key-value bullets under this card
+                for idx in other_idxs:
+                    if idx < len(row):
+                        col_name = table_headers[idx].strip()
+                        col_val = row[idx].strip()
+                        
+                        col_name_raw = re.sub(r'<[^>]+>', '', col_name).strip()
+                        
+                        if col_val:
+                            formatted_table.append(f"• <b>{col_name_raw}:</b> {col_val}")
+                
+                formatted_table.append("") # Empty line between cards
+                
+        # Reset state
+        in_table = False
+        table_headers = []
+        table_rows = []
+        
+        return formatted_table
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        line_stripped = line.strip()
+        
+        if line_stripped.startswith("|"):
+            cells = [c.strip() for c in line_stripped.split("|")[1:-1]]
+            
+            is_separator = False
+            if cells:
+                is_separator = all(re.match(r'^:?-+:?$', c) for c in cells)
+                
+            if is_separator:
+                i += 1
+                continue
+                
+            if not in_table:
+                in_table = True
+                table_headers = cells
+            else:
+                table_rows.append(cells)
+        else:
+            if in_table:
+                processed_lines.extend(flush_table())
+            processed_lines.append(line)
+            
+        i += 1
+        
+    if in_table:
+        processed_lines.extend(flush_table())
+        
+    return "\n".join(processed_lines)
+
+
+
 def split_message(text: str, max_length: int = DEFAULT_MAX_LENGTH) -> List[str]:
     """Split a long message into chunks that fit Telegram's limit.