codex-telegram 0.4.6__tar.gz → 0.4.8__tar.gz

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: codex-telegram
-Version: 0.4.6
+Version: 0.4.8
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License
@@ -218,6 +218,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: python-telegram-bot>=20.0
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn>=0.30.0
+Dynamic: license-file
 
 # Codex Telegram + Web
 

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/codex/client.py

@@ -1,5 +1,6 @@
 import asyncio
 import inspect
+from dataclasses import dataclass
 from typing import Any, Callable
 import logging
 
@@ -10,6 +11,12 @@ from utils.config import get
 logger = logging.getLogger("codex-telegram.codex")
 
 
+@dataclass(slots=True)
+class _ApprovalWaiter:
+    future: asyncio.Future[str]
+    loop: asyncio.AbstractEventLoop
+
+
 class CodexClient:
     def __init__(self):
         self.protocol = Protocol()
@@ -17,7 +24,7 @@ class CodexClient:
         self._reader_task: asyncio.Task | None = None
         self._stderr_task: asyncio.Task | None = None
         self._pending: dict[int, asyncio.Future[JSONRPCResponse]] = {}
-        self._pending_approvals: dict[int, asyncio.Future[str]] = {}
+        self._pending_approvals: dict[int, _ApprovalWaiter] = {}
         self._event_handlers: dict[str, list[Callable]] = {}
         self._any_event_handlers: list[Callable] = []
         self._approval_handlers: list[Callable] = []
@@ -114,10 +121,18 @@ class CodexClient:
         self._approval_handlers.append(handler)
 
     def submit_approval_decision(self, request_id: int, decision: str) -> bool:
-        future = self._pending_approvals.get(request_id)
-        if future is None or future.done():
+        waiter = self._pending_approvals.get(request_id)
+        if waiter is None or waiter.future.done():
             return False
-        future.set_result(decision)
+
+        def _resolve() -> None:
+            if not waiter.future.done():
+                waiter.future.set_result(decision)
+
+        if waiter.loop.is_running():
+            waiter.loop.call_soon_threadsafe(_resolve)
+        else:
+            _resolve()
         return True
     
     def _write(self, msg: JSONRPCRequest | JSONRPCNotification | JSONRPCResponse):
@@ -125,7 +140,6 @@ class CodexClient:
         logger.debug("app-server stdin: %s", data)
         if self._proc and self._proc.stdin:
             self._proc.stdin.write(data.encode() + b"\n")
-            self._proc.stdin.flush()
 
     def _fail_pending(self, exc: Exception) -> None:
         for future in self._pending.values():
@@ -133,8 +147,8 @@ class CodexClient:
                 future.set_exception(exc)
         self._pending.clear()
         for future in self._pending_approvals.values():
-            if not future.done():
-                future.set_result("deny")
+            if not future.future.done():
+                future.future.set_result("deny")
         self._pending_approvals.clear()
     
     async def _read_stdout_stream(self):
@@ -500,8 +514,9 @@ class CodexClient:
                         )
                         return
 
-                future: asyncio.Future[str] = asyncio.Future()
-                self._pending_approvals[req_id] = future
+                loop = asyncio.get_running_loop()
+                future: asyncio.Future[str] = loop.create_future()
+                self._pending_approvals[req_id] = _ApprovalWaiter(future=future, loop=loop)
                 await self._emit_approval_request(method, req_id, params)
 
                 decision_choice = self._default_choice(auto_mode)

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/codex_telegram/__init__.py

@@ -1,3 +1,3 @@
 """codex-telegram package."""
 
-__version__ = "0.4.6"
+__version__ = "0.4.8"

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/codex_telegram.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: codex-telegram
-Version: 0.4.6
+Version: 0.4.8
 Summary: Bridge for controlling the Codex App Server from Telegram and Web UI
 Author: heungtae
 License:                                  Apache License
@@ -218,6 +218,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: python-telegram-bot>=20.0
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn>=0.30.0
+Dynamic: license-file
 
 # Codex Telegram + Web
 

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/tests/test_codex_client.py

@@ -1,11 +1,28 @@
+import asyncio
 import unittest
+import threading
 from unittest.mock import patch
+from types import SimpleNamespace
 
 from codex.client import CodexClient
-from codex.protocol import JSONRPCRequest
+from codex.protocol import JSONRPCRequest, JSONRPCNotification
 
 
 class CodexClientServerRequestTests(unittest.IsolatedAsyncioTestCase):
+    def test_write_does_not_require_flush_on_asyncio_stream_writer(self):
+        client = CodexClient()
+        written = []
+
+        class _DummyStdin:
+            def write(self, data):
+                written.append(data)
+
+        client._proc = SimpleNamespace(stdin=_DummyStdin())
+
+        client._write(JSONRPCNotification(method="initialized"))
+
+        self.assertEqual([b'{"method": "initialized"}\n'], written)
+
     async def test_tool_request_user_input_auto_approve_maps_to_approve_once(self):
         client = CodexClient()
         written = []
@@ -74,6 +91,45 @@ class CodexClientServerRequestTests(unittest.IsolatedAsyncioTestCase):
         answers = ((response.get("result") or {}).get("answers") or {})
         self.assertEqual({"answers": ["Approve this Session"]}, answers.get("q2"))
 
+    async def test_submit_approval_decision_is_thread_safe(self):
+        client = CodexClient()
+        written = []
+        client._write = lambda msg: written.append(msg)  # type: ignore[method-assign]
+        req = JSONRPCRequest(
+            method="item/commandExecution/requestApproval",
+            id=42,
+            params={"threadId": "thread-1"},
+        )
+
+        with patch(
+            "codex.client.get",
+            side_effect=lambda key, default=None: "interactive" if key == "approval.mode" else "approve" if key == "approval.auto_response" else default,
+        ):
+            task = asyncio.create_task(client._handle_server_request(req))
+            for _ in range(100):
+                if 42 in client._pending_approvals:
+                    break
+                await asyncio.sleep(0.01)
+            else:
+                self.fail("approval request was not registered")
+
+            accepted = {}
+
+            def approve_from_thread():
+                accepted["value"] = client.submit_approval_decision(42, "approve")
+
+            thread = threading.Thread(target=approve_from_thread)
+            thread.start()
+            thread.join()
+
+            await asyncio.wait_for(task, timeout=1.0)
+
+        self.assertTrue(accepted["value"])
+        self.assertEqual(1, len(written))
+        response = written[0].to_dict()
+        self.assertEqual(42, response.get("id"))
+        self.assertEqual({"decision": "accept"}, response.get("result"))
+
     async def test_tool_request_user_input_prefers_option_value_when_present(self):
         client = CodexClient()
         written = []

{codex-telegram-0.4.6 → codex_telegram-0.4.8}/codex_telegram.egg-info/requires.txt

@@ -1,3 +1,3 @@
-fastapi>=0.111.0
 python-telegram-bot>=20.0
+fastapi>=0.111.0
 uvicorn>=0.30.0