codex-telegram 0.4.14__tar.gz → 0.4.16__tar.gz

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex-telegram
-Version: 0.4.14
+Version: 0.4.16
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/app_runtime/bootstrap.py

@@ -84,7 +84,7 @@ async def post_init(
             get_config_value("updates.pypi_check_verify_ssl", True),
             default=True,
         )
-        if update_check_enabled:
+        if update_check_enabled and app is not None:
             logger.info("Checking PyPI for codex-telegram updates...")
             asyncio.create_task(_check_update(verify_ssl=update_check_verify_ssl))
         state.update_notified = True

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/bot/callbacks.py

@@ -13,6 +13,7 @@ from bot.features_ui import features_keyboard, features_panel_text
 from models import state
 from models.user import user_manager
 from codex.commands import CommandResult
+from web.runtime import event_hub
 
 logger = logging.getLogger("codex-telegram.bot")
 GUARDIAN_WEB_ONLY_TEXT = "Guardian settings and rules can be edited in Web UI only."
@@ -352,7 +353,19 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
                         user_id,
                     )
                 else:
-                    accepted = state.codex_client.submit_approval_decision(request_id, choice)
+                    pending = await event_hub.list_approvals(user_id)
+                    thread_id = None
+                    for item in pending:
+                        if isinstance(item, dict) and item.get("id") == request_id:
+                            thread = item.get("thread_id")
+                            if isinstance(thread, str) and thread:
+                                thread_id = thread
+                            break
+                    accepted = state.codex_client.submit_approval_decision(
+                        request_id,
+                        choice,
+                        thread_id=thread_id,
+                    )
                     if not accepted:
                         await edit_with_log(
                             query,

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/codex/__init__.py

@@ -1,10 +1,12 @@
 from .client import CodexClient, CodexError
+from .client_pool import CodexClientManager
 from .protocol import Protocol, JSONRPCRequest, JSONRPCResponse, JSONRPCNotification
 from .events import EventHandler, create_event_handler
 from .commands import CommandRouter
 
 __all__ = [
     "CodexClient",
+    "CodexClientManager",
     "CodexError", 
     "Protocol",
     "JSONRPCRequest",

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/codex/approval_flow.py

@@ -143,7 +143,11 @@ def build_approval_request_handler(
                             ),
                         )
                 else:
-                    accepted = state.codex_client.submit_approval_decision(req_id, policy_match.action)
+                    accepted = state.codex_client.submit_approval_decision(
+                        req_id,
+                        policy_match.action,
+                        thread_id if isinstance(thread_id, str) else None,
+                    )
                     if accepted:
                         if user_id > 0 and app is not None:
                             await app.bot.send_message(
@@ -206,7 +210,11 @@ def build_approval_request_handler(
                         guardian_message(guardian_decision),
                     )
                     if guardian_decision.choice in {"approve", "session"}:
-                        accepted = state.codex_client.submit_approval_decision(req_id, guardian_decision.choice)
+                        accepted = state.codex_client.submit_approval_decision(
+                            req_id,
+                            guardian_decision.choice,
+                            thread_id if isinstance(thread_id, str) else None,
+                        )
                         if accepted:
                             if user_id > 0 and app is not None:
                                 await app.bot.send_message(chat_id=user_id, text=guardian_message(guardian_decision))
@@ -244,7 +252,11 @@ def build_approval_request_handler(
                         f"Reason: {guardian_error or 'unknown'}",
                     )
                     if config.failure_policy in {"approve", "session", "deny"}:
-                        accepted = state.codex_client.submit_approval_decision(req_id, config.failure_policy)
+                        accepted = state.codex_client.submit_approval_decision(
+                            req_id,
+                            config.failure_policy,
+                            thread_id if isinstance(thread_id, str) else None,
+                        )
                         if accepted:
                             if user_id > 0 and app is not None:
                                 await app.bot.send_message(
@@ -300,7 +312,11 @@ def build_approval_request_handler(
             previous_id = previous.get("id")
             if not isinstance(previous_id, int) or previous_id == req_id:
                 continue
-            closed = state.codex_client.submit_approval_decision(previous_id, "deny")
+            closed = state.codex_client.submit_approval_decision(
+                previous_id,
+                "deny",
+                previous.get("thread_id") if isinstance(previous.get("thread_id"), str) else None,
+            )
             logger.info(
                 "Superseding approval request user_id=%s previous_request_id=%s new_request_id=%s closed=%s",
                 user_id,

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/codex/client.py

@@ -23,6 +23,7 @@ class CodexClient:
         self._proc: asyncio.subprocess.Process | None = None
         self._reader_task: asyncio.Task | None = None
         self._stderr_task: asyncio.Task | None = None
+        self._call_lock = asyncio.Lock()
         self._pending: dict[int, asyncio.Future[JSONRPCResponse]] = {}
         self._pending_approvals: dict[int, _ApprovalWaiter] = {}
         self._event_handlers: dict[str, list[Callable]] = {}
@@ -95,19 +96,21 @@ class CodexClient:
         return result
     
     async def call(self, method: str, params: dict[str, Any] | None = None) -> Any:
-        request = self.protocol.create_request(method, {} if params is None else params)
-        req_id = request.id
-        if req_id is None:
-            raise ValueError("Request ID is None")
-        future: asyncio.Future[JSONRPCResponse] = asyncio.Future()
-        self._pending[req_id] = future
-        
-        self._write(request)
-        
-        response = await future
-        if response.error:
-            raise CodexError(response.error["code"], response.error["message"])
-        return response.result
+        async with self._call_lock:
+            request = self.protocol.create_request(method, {} if params is None else params)
+            req_id = request.id
+            if req_id is None:
+                raise ValueError("Request ID is None")
+            loop = asyncio.get_running_loop()
+            future: asyncio.Future[JSONRPCResponse] = loop.create_future()
+            self._pending[req_id] = future
+
+            self._write(request)
+
+            response = await future
+            if response.error:
+                raise CodexError(response.error["code"], response.error["message"])
+            return response.result
     
     def on(self, method: str, handler: Callable):
         if method not in self._event_handlers:
@@ -120,7 +123,7 @@ class CodexClient:
     def on_approval_request(self, handler: Callable):
         self._approval_handlers.append(handler)
 
-    def submit_approval_decision(self, request_id: int, decision: str) -> bool:
+    def submit_approval_decision(self, request_id: int, decision: str, thread_id: str | None = None) -> bool:
         waiter = self._pending_approvals.get(request_id)
         if waiter is None or waiter.future.done():
             return False

codex-telegram-0.4.16/codex/client_pool.py

@@ -0,0 +1,224 @@
+import asyncio
+import logging
+import threading
+from dataclasses import dataclass, field
+from inspect import isawaitable
+from typing import Any, Callable
+
+from .client import CodexClient
+
+
+logger = logging.getLogger("codex-telegram.codex")
+
+
+@dataclass(slots=True)
+class _ManagedClient:
+    client: CodexClient
+    thread_ids: set[str] = field(default_factory=set)
+    kind: str = "thread"
+
+
+class CodexClientManager:
+    def __init__(self):
+        self._client_info: dict[str, Any] | None = None
+        self._control: _ManagedClient | None = None
+        self._thread_clients: dict[str, _ManagedClient] = {}
+        self._approval_request_clients: dict[int, _ManagedClient] = {}
+        self._any_event_handlers: list[Callable] = []
+        self._event_handlers: dict[str, list[Callable]] = {}
+        self._approval_handlers: list[Callable] = []
+        self._lock = threading.RLock()
+
+    async def start(self):
+        if self._control is not None:
+            return
+        self._control = await self._create_started_client(kind="control")
+        logger.info("Codex control client started")
+
+    async def initialize(self, client_info: dict[str, Any]):
+        self._client_info = dict(client_info)
+        if self._control is None:
+            await self.start()
+        if self._control is None:
+            raise RuntimeError("Codex control client failed to start")
+        await self._control.client.initialize(client_info)
+        logger.info("Initialized Codex control client")
+
+    async def stop(self):
+        with self._lock:
+            thread_clients = list(self._thread_clients.items())
+            control = self._control
+            self._thread_clients.clear()
+            self._approval_request_clients.clear()
+            self._control = None
+
+        for thread_id, handle in thread_clients:
+            try:
+                await handle.client.stop()
+            except Exception:
+                logger.exception("Failed to stop Codex thread client thread_id=%s", thread_id)
+
+        if control is not None:
+            try:
+                await control.client.stop()
+            except Exception:
+                logger.exception("Failed to stop Codex control client")
+
+    def on(self, method: str, handler: Callable):
+        with self._lock:
+            self._event_handlers.setdefault(method, []).append(handler)
+            for handle in self._thread_clients.values():
+                handle.client.on(method, handler)
+            if self._control is not None:
+                self._control.client.on(method, handler)
+
+    def on_any(self, handler: Callable):
+        with self._lock:
+            self._any_event_handlers.append(handler)
+
+    def on_approval_request(self, handler: Callable):
+        with self._lock:
+            self._approval_handlers.append(handler)
+
+    def submit_approval_decision(self, request_id: int, decision: str, thread_id: str | None = None) -> bool:
+        handle = self._resolve_approval_handle(request_id, thread_id)
+        if handle is None:
+            return False
+        return handle.client.submit_approval_decision(request_id, decision, thread_id=thread_id)
+
+    async def call(self, method: str, params: dict[str, Any] | None = None) -> Any:
+        normalized_params = {} if params is None else params
+        thread_id = self._extract_thread_id(normalized_params)
+        if method == "thread/start":
+            handle = await self._create_managed_client(kind="thread")
+            try:
+                result = await handle.client.call(method, normalized_params)
+                started_thread_id = self._extract_thread_id_from_result(result)
+                if not started_thread_id:
+                    raise RuntimeError("Codex thread/start did not return a thread id")
+                self._bind_thread_handle(started_thread_id, handle)
+                return result
+            except Exception:
+                await handle.client.stop()
+                raise
+        if thread_id is not None:
+            handle, is_new = await self._resolve_thread_handle(thread_id)
+            try:
+                result = await handle.client.call(method, normalized_params)
+                self._bind_thread_handle(thread_id, handle)
+                return result
+            except Exception:
+                if is_new:
+                    self._unbind_thread_handle(thread_id, handle)
+                    await handle.client.stop()
+                raise
+        control = await self._ensure_control_client()
+        return await control.client.call(method, normalized_params)
+
+    async def _ensure_control_client(self) -> _ManagedClient:
+        if self._control is not None:
+            return self._control
+        await self.start()
+        if self._control is None:
+            raise RuntimeError("Codex control client is unavailable")
+        return self._control
+
+    async def _resolve_thread_handle(self, thread_id: str) -> tuple[_ManagedClient, bool]:
+        with self._lock:
+            handle = self._thread_clients.get(thread_id)
+        if handle is not None:
+            return handle, False
+        handle = await self._create_managed_client(kind="thread")
+        self._bind_thread_handle(thread_id, handle)
+        return handle, True
+
+    def _bind_thread_handle(self, thread_id: str, handle: _ManagedClient) -> None:
+        with self._lock:
+            self._thread_clients[thread_id] = handle
+            handle.thread_ids.add(thread_id)
+
+    def _unbind_thread_handle(self, thread_id: str, handle: _ManagedClient) -> None:
+        with self._lock:
+            current = self._thread_clients.get(thread_id)
+            if current is handle:
+                self._thread_clients.pop(thread_id, None)
+            handle.thread_ids.discard(thread_id)
+
+    def _resolve_approval_handle(self, request_id: int, thread_id: str | None = None) -> _ManagedClient | None:
+        with self._lock:
+            if isinstance(thread_id, str) and thread_id:
+                handle = self._thread_clients.get(thread_id)
+                if handle is not None:
+                    return handle
+            return self._approval_request_clients.get(request_id)
+
+    def _extract_thread_id(self, params: dict[str, Any]) -> str | None:
+        for key in ("threadId", "conversationId"):
+            value = params.get(key)
+            if isinstance(value, str) and value:
+                return value
+        return None
+
+    def _extract_thread_id_from_result(self, result: Any) -> str | None:
+        if not isinstance(result, dict):
+            return None
+        thread = result.get("thread")
+        if isinstance(thread, dict):
+            thread_id = thread.get("id")
+            if isinstance(thread_id, str) and thread_id:
+                return thread_id
+        thread_id = result.get("threadId")
+        if isinstance(thread_id, str) and thread_id:
+            return thread_id
+        return None
+
+    async def _create_started_client(self, *, kind: str) -> _ManagedClient:
+        client = CodexClient()
+        handle = _ManagedClient(client=client, kind=kind)
+        self._attach_handlers(handle)
+        await client.start()
+        return handle
+
+    async def _create_managed_client(self, *, kind: str) -> _ManagedClient:
+        handle = await self._create_started_client(kind=kind)
+        if self._client_info is None:
+            raise RuntimeError("Codex client manager has not been initialized")
+        await handle.client.initialize(self._client_info)
+        return handle
+
+    def _attach_handlers(self, handle: _ManagedClient) -> None:
+        handle.client.on_any(lambda method, params, _handle=handle: self._dispatch_any(_handle, method, params))
+        handle.client.on_approval_request(
+            lambda payload, _handle=handle: self._dispatch_approval(_handle, payload)
+        )
+        for method, handlers in self._event_handlers.items():
+            for handler in handlers:
+                handle.client.on(method, handler)
+
+    async def _dispatch_any(self, handle: _ManagedClient, method: str, params: dict[str, Any] | None) -> None:
+        for handler in list(self._any_event_handlers):
+            await self._run_handler(handler, method, params, wildcard=True)
+        for handler in list(self._event_handlers.get(method, [])):
+            await self._run_handler(handler, method, params, wildcard=False)
+
+    async def _dispatch_approval(self, handle: _ManagedClient, payload: dict[str, Any]) -> None:
+        request_id = payload.get("id")
+        if isinstance(request_id, int):
+            with self._lock:
+                self._approval_request_clients[request_id] = handle
+        for handler in list(self._approval_handlers):
+            try:
+                result = handler(payload)
+                if isawaitable(result):
+                    await result
+            except Exception:
+                logger.exception("Error in approval request handler request_id=%s", request_id)
+
+    async def _run_handler(self, handler: Callable, method: str, params: dict[str, Any] | None, *, wildcard: bool):
+        try:
+            result = handler(method, params) if wildcard else handler(params)
+            if isawaitable(result):
+                await result
+        except Exception as exc:
+            label = "wildcard event handler" if wildcard else "event handler"
+            logger.error("Error in %s for %s: %s", label, method, exc)

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/codex/command_router/core.py

@@ -94,8 +94,8 @@ class CommandRouter:
     async def _dispatch_compact(self, args: list[str], _user_id: int) -> CommandResult:
         return await self.threads.compact(args)
 
-    async def _dispatch_rollback(self, args: list[str], _user_id: int) -> CommandResult:
-        return await self.threads.rollback(args)
+    async def _dispatch_rollback(self, args: list[str], user_id: int) -> CommandResult:
+        return await self.threads.rollback(args, user_id)
 
     async def _dispatch_interrupt(self, args: list[str], user_id: int) -> CommandResult:
         return await self.threads.interrupt(user_id, args)

{codex-telegram-0.4.14 → codex-telegram-0.4.16}/codex/command_router/threads.py

@@ -480,12 +480,18 @@ class ThreadCommands:
         await self.ctx.codex.call("thread/compact/start", {"threadId": thread_id})
         return text_result(f"Compaction started: {thread_id}", thread_id=thread_id)
 
-    async def rollback(self, args: list[str]) -> CommandResult:
+    async def rollback(self, args: list[str], user_id: int) -> CommandResult:
+        from models.user import user_manager
+
         if not args:
             return usage_result("Usage: /rollback <n_turns>")
 
         n = int(args[0])
-        result = await self.ctx.codex.call("thread/rollback", {"n": n})
+        active_thread_id = user_manager.get(user_id).active_thread_id
+        if not active_thread_id:
+            return text_result("No active thread.")
+
+        result = await self.ctx.codex.call("thread/rollback", {"threadId": active_thread_id, "n": n})
         thread = result.get("thread", {})
         return text_result(f"Rolled back. Thread: {thread.get('id', 'unknown')}")