codex-telegram 0.5.0__tar.gz → 0.5.2__tar.gz

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-telegram
-Version: 0.5.0
+Version: 0.5.2
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License
@@ -292,6 +292,34 @@ python -m venv .venv && source .venv/bin/activate
 pip install codex-telegram
 ```
 
+### Update
+
+The CLI checks for updates automatically on startup. When a newer version is available on PyPI, you'll see:
+
+```text
+✨ Update available! 0.5.1 -> 0.5.2
+
+  Release notes: https://github.com/heungtae/codex-telegram/releases/latest
+
+  1. Update now and exit (runs `pip install -U codex-telegram`)
+  2. Skip this run
+  3. Skip this version
+
+  Choose [1/2/3] (default: 2):
+```
+
+You can also update manually:
+
+```bash
+pip install -U codex-telegram
+```
+
+Or with system packages flag:
+
+```bash
+pip install -U codex-telegram --break-system-packages
+```
+
 ### 2. Configure
 
 Create `~/.config/codex-telegram/conf.toml`:

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/README.md

@@ -67,6 +67,34 @@ python -m venv .venv && source .venv/bin/activate
 pip install codex-telegram
 ```
 
+### Update
+
+The CLI checks for updates automatically on startup. When a newer version is available on PyPI, you'll see:
+
+```text
+✨ Update available! 0.5.1 -> 0.5.2
+
+  Release notes: https://github.com/heungtae/codex-telegram/releases/latest
+
+  1. Update now and exit (runs `pip install -U codex-telegram`)
+  2. Skip this run
+  3. Skip this version
+
+  Choose [1/2/3] (default: 2):
+```
+
+You can also update manually:
+
+```bash
+pip install -U codex-telegram
+```
+
+Or with system packages flag:
+
+```bash
+pip install -U codex-telegram --break-system-packages
+```
+
 ### 2. Configure
 
 Create `~/.config/codex-telegram/conf.toml`:

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/app_runtime/bootstrap.py

@@ -56,6 +56,7 @@ async def post_init(
     match_approval_policy: Callable[..., Any],
     to_thread: Callable[..., Awaitable[Any]],
 ) -> None:
+    state.telegram_app = app
     state.codex_client = await setup_codex_fn()
     state.command_router = command_router_factory(state.codex_client)
     state.approval_guardian = approval_guardian_factory()
@@ -95,6 +96,7 @@ async def post_shutdown(
     *,
     state_module=state,
 ) -> None:
+    state_module.telegram_app = None
     if state_module.codex_client:
         await state_module.codex_client.stop()
         state_module.codex_client = None

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/bot/callbacks.py

@@ -14,6 +14,10 @@ from models import state
 from models.user import user_manager
 from codex.commands import CommandResult
 from web.runtime import event_hub
+from web.telegram_thread_selection import (
+    format_telegram_active_thread_changed_message,
+    preview_from_read_text,
+)
 
 logger = logging.getLogger("codex-telegram.bot")
 GUARDIAN_WEB_ONLY_TEXT = "Guardian settings and rules can be edited in Web UI only."
@@ -227,6 +231,12 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             if command == "start":
                 logger.info("Executing callback action user_id=%s data=%s", user_id, data)
                 result = await run_callback_command("/start", user_id)
+                logger.info(
+                    "Telegram callback /start result user_id=%s kind=%s thread_id=%s",
+                    user_id,
+                    result.kind,
+                    result.meta.get("thread_id"),
+                )
                 await context.bot.send_message(chat_id=chat_id, text=result.text, reply_markup=_main_menu_markup(user_id))
             elif command == "menu":
                 logger.info("Executing callback action user_id=%s data=%s", user_id, data)
@@ -400,7 +410,24 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             thread_id = data[7:]
             logger.info("Executing callback action user_id=%s data=%s", user_id, data)
             result = await state.command_router.route("/resume", [thread_id], user_id)
-            await edit_with_log(query, context, result.text, user_id, reply_markup=_main_menu_markup(user_id))
+            if result.kind == "error":
+                await edit_with_log(
+                    query,
+                    context,
+                    result.text,
+                    user_id,
+                    reply_markup=_main_menu_markup(user_id),
+                )
+                return
+            resolved_thread_id = result.meta.get("thread_id") or thread_id
+            read_result = await state.command_router.route("/read", [resolved_thread_id], user_id)
+            preview = preview_from_read_text(resolved_thread_id, read_result.text)
+            message = format_telegram_active_thread_changed_message(
+                preview,
+                project_key=user_manager.get_thread_project(resolved_thread_id),
+                resume_status="ok",
+            )
+            await edit_with_log(query, context, message, user_id, reply_markup=_main_menu_markup(user_id))
         
         elif data.startswith("fork:"):
             thread_id = data[5:]

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/bot/handlers.py

@@ -21,6 +21,7 @@ from bot.features_ui import features_keyboard, features_panel_text
 from models import state
 from utils.single_instance import find_local_conflict_candidates
 from utils.local_command import run_bang_command
+from web.telegram_sync import bind_telegram_thread_to_active_web
 
 logger = logging.getLogger("codex-telegram.bot")
 _last_conflict_log_at = 0.0
@@ -182,12 +183,15 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
         )
         return
 
-    if state_user.active_turn_id:
+    active_thread_running_turn_id = state_user.get_turn_for_thread(state_user.active_thread_id)
+    if not active_thread_running_turn_id and state_user.active_turn_id and not state_user.active_turn_id_by_thread:
+        active_thread_running_turn_id = state_user.active_turn_id
+    if active_thread_running_turn_id:
         await send_reply(
             update,
             (
                 "A turn is already running.\n"
-                f"turnId: {state_user.active_turn_id}\n"
+                f"turnId: {active_thread_running_turn_id}\n"
                 "Use /interrupt (or the Interrupt button) to stop it first."
             ),
             user_id,
@@ -205,6 +209,12 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             "threadId": state_user.active_thread_id,
             "input": [{"type": "text", "text": text}],
         }
+        bound_user_ids = await bind_telegram_thread_to_active_web(
+            user_id,
+            state_user.active_thread_id,
+            project_key=user_manager.get_thread_project(state_user.active_thread_id),
+            notify_web=False,
+        )
         collaboration_mode = await _require_turn_collaboration_mode(state_user)
         params["collaborationMode"] = collaboration_mode
         logger.info(
@@ -220,7 +230,11 @@ async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
         turn = result.get("turn", {})
         turn_id = turn.get("id", "unknown")
         if isinstance(turn_id, str) and turn_id and turn_id != "unknown":
-            state_user.set_turn(turn_id)
+            state_user.set_turn(turn_id, state_user.active_thread_id)
+            user_manager.bind_turn(user_id, turn_id, state_user.active_thread_id)
+            for bound_user_id in bound_user_ids:
+                if bound_user_id != user_id:
+                    user_manager.bind_turn_subscriber(bound_user_id, turn_id, state_user.active_thread_id)
 
         if state_user.selected_project_path:
             await send_reply(update, f"Turn started: {turn_id}\nWorkspace: {state_user.selected_project_path}", user_id)

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex/command_router/projects.py

@@ -210,6 +210,15 @@ class ProjectCommands:
             if isinstance(new_thread_id, str) and new_thread_id:
                 user_manager.set_active_thread(user_id, new_thread_id, project_key=selected["key"])
                 state.clear_turn()
+                if user_id > 0:
+                    from web.telegram_sync import bind_telegram_thread_to_active_web
+
+                    await bind_telegram_thread_to_active_web(
+                        user_id,
+                        new_thread_id,
+                        project_key=selected["key"],
+                        notify_web=True,
+                    )
             else:
                 user_manager.clear_active_thread(user_id)
                 thread_start_note = "\nProject switched, but failed to create a new thread. Run /start."

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex/command_router/threads.py

@@ -126,6 +126,15 @@ class ThreadCommands:
 
         if thread_id:
             user_manager.set_active_thread(user_id, thread_id, project_key=(project or {}).get("key"))
+            if user_id > 0:
+                from web.telegram_sync import bind_telegram_thread_to_active_web
+
+                await bind_telegram_thread_to_active_web(
+                    user_id,
+                    thread_id,
+                    project_key=(project or {}).get("key"),
+                    notify_web=True,
+                )
 
         if project:
             return text_result(
@@ -149,6 +158,15 @@ class ThreadCommands:
 
         await self.ctx.codex.call("thread/resume", {"threadId": thread_id})
         user_manager.set_active_thread(user_id, thread_id)
+        if user_id > 0:
+            from web.telegram_sync import bind_telegram_thread_to_active_web
+
+            await bind_telegram_thread_to_active_web(
+                user_id,
+                thread_id,
+                project_key=user_manager.get_thread_project(thread_id),
+                notify_web=True,
+            )
         return text_result(f"Thread resumed: {thread_id}", thread_id=thread_id)
 
     async def fork(self, args: list[str], user_id: int) -> CommandResult:

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex/event_forwarding.py

@@ -977,10 +977,16 @@ def truncate_telegram_text(text: str, footer: str) -> str:
     return text[:head_len] + suffix + footer
 
 
+def telegram_turn_footer(turn_id: str | None) -> str:
+    if isinstance(turn_id, str) and turn_id:
+        return f"\n\nturnId: {turn_id}"
+    return ""
+
+
 async def send_telegram_message(app, user_id: int, text: str, turn_id: str | None) -> None:
     if user_id <= 0 or app is None or not text.strip():
         return
-    footer = f"\n\nturnId: {turn_id or 'unknown'}"
+    footer = telegram_turn_footer(turn_id)
     try:
         await app.bot.send_message(
             chat_id=user_id,
@@ -1020,7 +1026,7 @@ async def send_telegram_file_change(app, user_id: int, payload: dict[str, Any])
     try:
         last_index = len(lines) - 1
         for index, line in enumerate(lines):
-            footer = f"\n\nturnId: {turn_id or 'unknown'}" if index == last_index else ""
+            footer = telegram_turn_footer(turn_id) if index == last_index else ""
             await app.bot.send_message(chat_id=user_id, text=truncate_telegram_text(line, footer))
             if index < last_index:
                 await asyncio.sleep(FILE_CHANGE_LINE_DELAY_SECONDS)
@@ -1034,12 +1040,60 @@ async def send_telegram_plan(app, user_id: int, payload: dict[str, Any]) -> None
         await send_telegram_message(app, user_id, f"Plan proposal\n\n{plan_text}", payload.get("turn_id"))
 
 
+def filter_telegram_targets_to_active_thread(
+    method: str,
+    target_user_ids: set[int],
+    thread_id: str | None,
+    turn_id: str | None,
+    params: dict | None,
+) -> set[int]:
+    if not target_user_ids:
+        return set()
+    payload_thread = (params or {}).get("thread")
+    parent_thread_id = (
+        payload_thread.get("forkedFromId")
+        if isinstance(payload_thread, dict) and isinstance(payload_thread.get("forkedFromId"), str)
+        else None
+    )
+    filtered: set[int] = set()
+    for user_id in target_user_ids:
+        if user_id <= 0:
+            filtered.add(user_id)
+            continue
+        active_thread_id = user_manager.get(user_id).active_thread_id
+        if (
+            isinstance(thread_id, str)
+            and thread_id
+            and (active_thread_id == thread_id or active_thread_id == parent_thread_id)
+        ):
+            filtered.add(user_id)
+            continue
+        if not thread_id and method in {"turn/completed", "turn/failed", "turn/cancelled"} and active_thread_id:
+            filtered.add(user_id)
+            continue
+        logger.info(
+            "Telegram forwarding skipped method=%s thread_id=%s turn_id=%s telegram_user_id=%s active_thread_id=%s reason=active_thread_mismatch",
+            method,
+            thread_id,
+            turn_id,
+            user_id,
+            active_thread_id,
+        )
+    return filtered
+
+
 def build_event_forwarder(app, config: ForwardingConfig):
     async def forward_event(method: str, params: dict | None):
         thread_id = extract_thread_id(method, params)
         turn_id = extract_turn_id(method, params)
         if thread_id is None and turn_id:
             thread_id = user_manager.get_turn_thread(turn_id)
+        if not turn_id and thread_id:
+            for user_id in user_manager.find_user_ids_by_thread(thread_id):
+                inferred_turn_id = user_manager.get(user_id).get_turn_for_thread(thread_id)
+                if inferred_turn_id:
+                    turn_id = inferred_turn_id
+                    break
         target_user_ids = set()
         if turn_id:
             target_user_ids.update(user_manager.find_user_ids_by_turn(turn_id))
@@ -1050,6 +1104,7 @@ def build_event_forwarder(app, config: ForwardingConfig):
             fallback_owner = user_manager.find_single_active_turn_owner()
             if fallback_owner is not None:
                 target_user_ids.add(fallback_owner)
+        target_user_ids = filter_telegram_targets_to_active_thread(method, target_user_ids, thread_id, turn_id, params)
 
         if method == "turn/started" and turn_id and target_user_ids:
             actual_mode = normalize_mode_kind((params or {}).get("collaboration_mode_kind") or (params or {}).get("collaborationModeKind"))
@@ -1076,7 +1131,7 @@ def build_event_forwarder(app, config: ForwardingConfig):
                         try:
                             await app.bot.send_message(
                                 chat_id=uid,
-                                text=truncate_telegram_text(message, f"\n\nturnId: {turn_id or 'unknown'}"),
+                                text=truncate_telegram_text(message, telegram_turn_footer(turn_id)),
                             )
                         except Exception:
                             logger.exception("Failed to forward app-server error to Telegram")
@@ -1235,12 +1290,20 @@ def build_event_forwarder(app, config: ForwardingConfig):
         if event_level(method, params) < config.threshold:
             return
         telegram_user_ids = [uid for uid in target_user_ids if uid > 0]
+        logger.info(
+            "Telegram forwarding targets method=%s thread_id=%s turn_id=%s target_user_ids=%s telegram_user_ids=%s",
+            method,
+            thread_id,
+            turn_id,
+            sorted(target_user_ids),
+            sorted(telegram_user_ids),
+        )
         if not telegram_user_ids or app is None:
             return
         message = format_event(method, params, config.rules)
         if message is None or not message.strip():
             return
-        footer = f"\n\nturnId: {turn_id or 'unknown'}"
+        footer = telegram_turn_footer(turn_id)
         for user_id in telegram_user_ids:
             logger.info(
                 "Forwarding app-server event to Telegram user_id=%s method=%s message=%s",

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex_telegram/__init__.py

@@ -1,3 +1,3 @@
 """codex-telegram package."""
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex_telegram/cli.py

@@ -1,7 +1,10 @@
 import argparse
+import json
 import logging
 import os
 import sys
+import urllib.error
+import urllib.request
 from importlib.util import module_from_spec, spec_from_file_location
 from pathlib import Path
 from types import ModuleType
@@ -13,6 +16,44 @@ def _get_version() -> str:
     return __version__
 
 
+def _check_for_update(current_version: str) -> str | None:
+    """Check PyPI for the latest version. Returns latest version if newer, else None."""
+    url = "https://pypi.org/pypi/codex-telegram/json"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "codex-telegram"})
+        with urllib.request.urlopen(req, timeout=3) as resp:
+            data = json.load(resp)
+            latest = data["info"]["version"]
+            if _version_gt(latest, current_version):
+                return latest
+    except (urllib.error.URLError, json.JSONDecodeError, KeyError, TimeoutError):
+        pass
+    return None
+
+
+def _version_gt(v1: str, v2: str) -> bool:
+    """Compare version strings (simple tuple comparison)."""
+    def parse(v: str):
+        return tuple(int(x) for x in v.split(".") if x.isdigit())
+    return parse(v1) > parse(v2)
+
+
+def _prompt_update(latest: str) -> bool:
+    """Prompt user to update. Returns True if user chooses to update."""
+    print(f"\n✨ Update available! {_get_version()} -> {latest}")
+    print("  Release notes: https://github.com/heungtae/codex-telegram/releases/latest")
+    print()
+    print("  1. Update now and exit (runs `pip install -U codex-telegram`)")
+    print("  2. Skip this run")
+    print("  3. Skip this version")
+    print()
+    try:
+        choice = input("  Choose [1/2/3] (default: 2): ").strip() or "2"
+    except (EOFError, KeyboardInterrupt):
+        return False
+    return choice == "1"
+
+
 def _load_root_main_module() -> ModuleType:
     root_main = Path(__file__).resolve().parent.parent / "main.py"
     spec = spec_from_file_location("codex_telegram_root_main", root_main)
@@ -24,6 +65,15 @@ def _load_root_main_module() -> ModuleType:
 
 
 def main() -> int:
+    # Check for updates (skip if --version or --validate-config or --debug)
+    if "--version" not in sys.argv and "--validate-config" not in sys.argv and "--debug" not in sys.argv:
+        current = _get_version()
+        latest = _check_for_update(current)
+        if latest and _prompt_update(latest):
+            print("Running: pip install -U codex-telegram")
+            os.execvpe(sys.executable, [sys.executable, "-m", "pip", "install", "-U", "codex-telegram"], os.environ)
+            return 0
+
     parser = argparse.ArgumentParser(
         prog="codex-telegram",
         description="Codex Telegram Bot - Bridges Codex App Server with Telegram and Web UI.",

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex_telegram.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-telegram
-Version: 0.5.0
+Version: 0.5.2
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License
@@ -292,6 +292,34 @@ python -m venv .venv && source .venv/bin/activate
 pip install codex-telegram
 ```
 
+### Update
+
+The CLI checks for updates automatically on startup. When a newer version is available on PyPI, you'll see:
+
+```text
+✨ Update available! 0.5.1 -> 0.5.2
+
+  Release notes: https://github.com/heungtae/codex-telegram/releases/latest
+
+  1. Update now and exit (runs `pip install -U codex-telegram`)
+  2. Skip this run
+  3. Skip this version
+
+  Choose [1/2/3] (default: 2):
+```
+
+You can also update manually:
+
+```bash
+pip install -U codex-telegram
+```
+
+Or with system packages flag:
+
+```bash
+pip install -U codex-telegram --break-system-packages
+```
+
 ### 2. Configure
 
 Create `~/.config/codex-telegram/conf.toml`:

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/codex_telegram.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ codex_telegram.egg-info/requires.txt
 codex_telegram.egg-info/top_level.txt
 models/__init__.py
 models/state.py
+models/telegram_bridge.py
 models/thread.py
 models/user.py
 tests/test_approval_guardian.py
@@ -82,11 +83,14 @@ web/dependencies.py
 web/routes.py
 web/runtime.py
 web/server.py
+web/telegram_sync.py
+web/telegram_thread_selection.py
 web/thread_history.py
 web/workspace.py
+web/static/dist/favicon.ico
 web/static/dist/index.html
 web/static/dist/assets/codex-telegram-icon-black.svg
 web/static/dist/assets/codex-telegram-icon-ivory.svg
 web/static/dist/assets/codex-telegram-login-image.png
-web/static/dist/assets/index-CAl6dA4Q.js
-web/static/dist/assets/index-C_g51sA5.css
+web/static/dist/assets/index-DIOICBNe.js
+web/static/dist/assets/index-DW1AcoLg.css

{codex_telegram-0.5.0 → codex_telegram-0.5.2}/models/state.py

@@ -7,5 +7,6 @@ from codex.approval_guardian import ApprovalGuardianService
 codex_client: Any | None = None
 command_router: CommandRouter | None = None
 approval_guardian: ApprovalGuardianService | None = None
+telegram_app: Any | None = None
 codex_ready = asyncio.Event()
 update_notified: bool = False

codex_telegram-0.5.2/models/telegram_bridge.py

@@ -0,0 +1,77 @@
+from utils.config import get
+
+from .user import user_manager
+
+
+class TelegramBridgeConfigError(ValueError):
+    pass
+
+
+def single_allowed_telegram_user_id() -> int | None:
+    allowed_ids = get("users.allowed_ids", [])
+    if not isinstance(allowed_ids, list) or len(allowed_ids) != 1:
+        return None
+    try:
+        user_id = int(allowed_ids[0])
+    except (TypeError, ValueError):
+        return None
+    if user_id <= 0:
+        return None
+    return user_id
+
+
+def require_single_allowed_telegram_user_id() -> int:
+    allowed_ids = get("users.allowed_ids", [])
+    if not isinstance(allowed_ids, list) or len(allowed_ids) != 1:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires exactly one Telegram user in users.allowed_ids."
+        )
+    try:
+        user_id = int(allowed_ids[0])
+    except (TypeError, ValueError) as exc:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires users.allowed_ids to contain one numeric Telegram user id."
+        ) from exc
+    if user_id <= 0:
+        raise TelegramBridgeConfigError(
+            "Open in Telegram requires a positive Telegram user id in users.allowed_ids."
+        )
+    return user_id
+
+
+def bind_thread_counterparts(
+    user_id: int,
+    thread_id: str | None,
+    *,
+    project_key: str | None = None,
+    web_user_ids: list[int] | tuple[int, ...] | set[int] | None = None,
+) -> set[int]:
+    if not isinstance(thread_id, str) or not thread_id:
+        return set()
+
+    user_manager.bind_thread_subscriber(user_id, thread_id)
+    if isinstance(project_key, str) and project_key:
+        user_manager.bind_thread_project(thread_id, project_key)
+
+    bound_user_ids = {user_id}
+    telegram_user_id = single_allowed_telegram_user_id()
+    if telegram_user_id is None:
+        return bound_user_ids
+
+    if user_id > 0:
+        if user_id != telegram_user_id:
+            return bound_user_ids
+        user_manager.keep_user_thread_subscription_only(user_id, thread_id)
+        for web_user_id in web_user_ids or ():
+            if isinstance(web_user_id, int) and web_user_id < 0:
+                user_manager.bind_thread_subscriber(web_user_id, thread_id)
+                bound_user_ids.add(web_user_id)
+        return bound_user_ids
+
+    if user_id < 0:
+        telegram_state = user_manager.get(telegram_user_id)
+        if telegram_state.active_thread_id == thread_id:
+            user_manager.keep_user_thread_subscription_only(telegram_user_id, thread_id)
+            bound_user_ids.add(telegram_user_id)
+
+    return bound_user_ids