nonebot-plugin-codex 0.1.4__tar.gz → 0.1.5__tar.gz

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-codex
-Version: 0.1.4
+Version: 0.1.5
 Summary: Telegram bridge plugin for driving Codex from NoneBot
 Author-Email: ttiee <469784630@qq.com>
 License: GPL-3.0-or-later
@@ -40,6 +40,13 @@ _✨ 在 Telegram 里驱动 Codex CLI 的 NoneBot 插件 ✨_
 
 </div>
 
+<p align="center">
+  <img src="docs/images/readme/1.jpg" width="24%" alt="nonebot-plugin-codex screenshot 1">
+  <img src="docs/images/readme/2.jpg" width="24%" alt="nonebot-plugin-codex screenshot 2">
+  <img src="docs/images/readme/3.jpg" width="24%" alt="nonebot-plugin-codex screenshot 3">
+  <img src="docs/images/readme/4.jpg" width="24%" alt="nonebot-plugin-codex screenshot 4">
+</p>
+
 ## 项目介绍
 
 `nonebot-plugin-codex` 是一个面向 Telegram 场景的 NoneBot 插件，用来把本机 `codex` CLI 暴露为可对话、可续聊、可管理工作目录的聊天式开发助手。
@@ -180,8 +187,8 @@ codex_diagnostic_history = 20
 # 单条 Telegram 消息的分片长度，过长回复会自动拆分
 codex_chunk_size = 3500
 
-# 读取 Codex stdout / stderr 的缓冲区大小
-codex_stream_read_limit = 1048576
+# 单条 Codex 协议消息允许的最大字节数
+codex_stream_read_limit = 8388608
 
 ```
 
@@ -189,7 +196,8 @@ codex_stream_read_limit = 1048576
 
 - `codex_binary`：如果宿主机不是直接执行 `codex`，改成实际绝对路径。
 - `codex_workdir`：默认工作目录，也是 `/cd` 相对路径解析与目录浏览器 Home 的基准。
-- 其余项分别控制停止超时、进度保留条数、诊断输出条数、Telegram 分片长度和流读取上限。
+- `codex_stream_read_limit`：限制单条 Codex 协议帧的最大字节数，不是 Telegram 消息分片长度。
+- 其余项分别控制停止超时、进度保留条数、诊断输出条数和 Telegram 分片长度。
 - 插件自己的配置数据由 `nonebot-plugin-localstore` 自动管理。
 - 模型缓存、Codex CLI 配置和历史会话目录默认读取 `~/.codex/*`，属于插件内部实现路径。
 

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/README.md

@@ -27,6 +27,13 @@ _✨ 在 Telegram 里驱动 Codex CLI 的 NoneBot 插件 ✨_
 
 </div>
 
+<p align="center">
+  <img src="docs/images/readme/1.jpg" width="24%" alt="nonebot-plugin-codex screenshot 1">
+  <img src="docs/images/readme/2.jpg" width="24%" alt="nonebot-plugin-codex screenshot 2">
+  <img src="docs/images/readme/3.jpg" width="24%" alt="nonebot-plugin-codex screenshot 3">
+  <img src="docs/images/readme/4.jpg" width="24%" alt="nonebot-plugin-codex screenshot 4">
+</p>
+
 ## 项目介绍
 
 `nonebot-plugin-codex` 是一个面向 Telegram 场景的 NoneBot 插件，用来把本机 `codex` CLI 暴露为可对话、可续聊、可管理工作目录的聊天式开发助手。
@@ -167,8 +174,8 @@ codex_diagnostic_history = 20
 # 单条 Telegram 消息的分片长度，过长回复会自动拆分
 codex_chunk_size = 3500
 
-# 读取 Codex stdout / stderr 的缓冲区大小
-codex_stream_read_limit = 1048576
+# 单条 Codex 协议消息允许的最大字节数
+codex_stream_read_limit = 8388608
 
 ```
 
@@ -176,7 +183,8 @@ codex_stream_read_limit = 1048576
 
 - `codex_binary`：如果宿主机不是直接执行 `codex`，改成实际绝对路径。
 - `codex_workdir`：默认工作目录，也是 `/cd` 相对路径解析与目录浏览器 Home 的基准。
-- 其余项分别控制停止超时、进度保留条数、诊断输出条数、Telegram 分片长度和流读取上限。
+- `codex_stream_read_limit`：限制单条 Codex 协议帧的最大字节数，不是 Telegram 消息分片长度。
+- 其余项分别控制停止超时、进度保留条数、诊断输出条数和 Telegram 分片长度。
 - 插件自己的配置数据由 `nonebot-plugin-localstore` 自动管理。
 - 模型缓存、Codex CLI 配置和历史会话目录默认读取 `~/.codex/*`，属于插件内部实现路径。
 

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-codex"
-version = "0.1.4"
+version = "0.1.5"
 description = "Telegram bridge plugin for driving Codex from NoneBot"
 authors = [
     { name = "ttiee", email = "469784630@qq.com" },

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/src/nonebot_plugin_codex/config.py

@@ -12,4 +12,4 @@ class Config(BaseModel):
     codex_progress_history: int = 6
     codex_diagnostic_history: int = 20
     codex_chunk_size: int = 3500
-    codex_stream_read_limit: int = 1024 * 1024
+    codex_stream_read_limit: int = 8 * 1024 * 1024

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/src/nonebot_plugin_codex/native_client.py

@@ -7,6 +7,8 @@ from dataclasses import field, dataclass
 from typing import Any
 from collections.abc import Callable, Awaitable
 
+from .protocol_io import NdjsonProcessReader, ProtocolStreamError
+
 Callback = Callable[[str], object]
 ProcessLauncher = Callable[..., Awaitable[Any]]
 
@@ -93,7 +95,7 @@ class NativeCodexClient:
         launcher: ProcessLauncher | None = None,
         client_name: str = "tg_bot",
         client_version: str = "0",
-        stream_read_limit: int = 1024 * 1024,
+        stream_read_limit: int = 8 * 1024 * 1024,
     ) -> None:
         self.binary = binary
         self.launcher = launcher or asyncio.create_subprocess_exec
@@ -101,6 +103,7 @@ class NativeCodexClient:
         self.client_version = client_version
         self.stream_read_limit = stream_read_limit
         self._process: Any = None
+        self._reader: NdjsonProcessReader | None = None
         self._initialized = False
         self._next_request_id = 1
 
@@ -115,10 +118,14 @@ class NativeCodexClient:
 
     async def close(self, timeout: float = 5.0) -> None:
         process = self._process
+        reader = self._reader
         self._process = None
+        self._reader = None
         self._initialized = False
         self._next_request_id = 1
         await _terminate_process(process, timeout)
+        if reader is not None:
+            await reader.wait_closed()
 
     async def start_thread(
         self,
@@ -322,9 +329,13 @@ class NativeCodexClient:
             "stdio://",
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.STDOUT,
+            stderr=asyncio.subprocess.PIPE,
             limit=self.stream_read_limit,
         )
+        self._reader = NdjsonProcessReader(
+            self._process,
+            frame_limit=self.stream_read_limit,
+        )
         request_id = self._allocate_request_id()
         await self._write_message(
             {
@@ -398,12 +409,19 @@ class NativeCodexClient:
             return result
 
     async def _read_message(self, diagnostics: list[str]) -> dict[str, Any] | None:
-        if self._process is None or getattr(self._process, "stdout", None) is None:
+        if self._process is None or self._reader is None:
             raise RuntimeError("Codex app-server 尚未启动。")
-        raw_line = await self._process.stdout.readline()
-        if not raw_line:
+
+        diagnostics.extend(self._reader.drain_stderr_lines())
+        try:
+            line = await self._reader.read_stdout_line()
+        except ProtocolStreamError as exc:
+            diagnostics.extend(self._reader.drain_stderr_lines())
+            raise RuntimeError(str(exc)) from exc
+        diagnostics.extend(self._reader.drain_stderr_lines())
+
+        if line is None:
             raise RuntimeError("Codex app-server 已提前退出。")
-        line = raw_line.decode("utf-8", errors="replace").strip()
         if not line:
             return None
         try:

nonebot_plugin_codex-0.1.5/src/nonebot_plugin_codex/protocol_io.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+READ_CHUNK_SIZE = 4096
+
+
+def oversized_frame_message(limit: int) -> str:
+    return (
+        "Codex 返回的单条协议消息超过 "
+        f"`codex_stream_read_limit`（当前 {limit} 字节）。"
+    )
+
+
+def incomplete_frame_message() -> str:
+    return "Codex 返回了不完整的协议消息。"
+
+
+def truncated_stderr_message(limit: int) -> str:
+    return (
+        "Codex stderr 单行输出超过 "
+        f"`codex_stream_read_limit`（当前 {limit} 字节），已截断。"
+    )
+
+
+class ProtocolStreamError(RuntimeError):
+    pass
+
+
+class NdjsonProcessReader:
+    def __init__(
+        self,
+        process: Any,
+        *,
+        frame_limit: int,
+        read_chunk_size: int = READ_CHUNK_SIZE,
+    ) -> None:
+        self._stdout = getattr(process, "stdout", None)
+        self._stderr = getattr(process, "stderr", None)
+        self._frame_limit = frame_limit
+        self._read_chunk_size = max(1, read_chunk_size)
+        self._stdout_buffer = bytearray()
+        self._stderr_buffer = bytearray()
+        self._stderr_lines: list[str] = []
+        self._stderr_skipping_line = False
+        self._stderr_task: asyncio.Task[None] | None = None
+        if self._stderr is not None:
+            self._stderr_task = asyncio.create_task(self._drain_stderr())
+
+    async def read_stdout_line(self) -> str | None:
+        if self._stdout is None:
+            raise RuntimeError("Codex 协议 stdout 不可用。")
+
+        while True:
+            newline_index = self._stdout_buffer.find(b"\n")
+            if newline_index >= 0:
+                frame = bytes(self._stdout_buffer[: newline_index + 1])
+                del self._stdout_buffer[: newline_index + 1]
+                if newline_index > self._frame_limit:
+                    raise ProtocolStreamError(oversized_frame_message(self._frame_limit))
+                return frame.decode("utf-8", errors="replace").strip()
+
+            if len(self._stdout_buffer) > self._frame_limit:
+                self._stdout_buffer.clear()
+                raise ProtocolStreamError(oversized_frame_message(self._frame_limit))
+
+            chunk = await self._stdout.read(self._read_chunk_size)
+            if not chunk:
+                if self._stdout_buffer:
+                    self._stdout_buffer.clear()
+                    raise ProtocolStreamError(incomplete_frame_message())
+                return None
+            self._stdout_buffer.extend(chunk)
+
+    def drain_stderr_lines(self) -> list[str]:
+        lines = list(self._stderr_lines)
+        self._stderr_lines.clear()
+        return lines
+
+    async def wait_closed(self) -> None:
+        if self._stderr_task is not None:
+            await self._stderr_task
+
+    async def _drain_stderr(self) -> None:
+        if self._stderr is None:
+            return
+
+        while True:
+            chunk = await self._stderr.read(self._read_chunk_size)
+            if not chunk:
+                break
+            self._stderr_buffer.extend(chunk)
+            self._consume_stderr_buffer(final=False)
+
+        self._consume_stderr_buffer(final=True)
+
+    def _consume_stderr_buffer(self, *, final: bool) -> None:
+        while True:
+            if self._stderr_skipping_line:
+                newline_index = self._stderr_buffer.find(b"\n")
+                if newline_index < 0:
+                    if final:
+                        self._stderr_buffer.clear()
+                        self._stderr_skipping_line = False
+                    return
+                del self._stderr_buffer[: newline_index + 1]
+                self._stderr_skipping_line = False
+                continue
+
+            newline_index = self._stderr_buffer.find(b"\n")
+            if newline_index >= 0:
+                frame = bytes(self._stderr_buffer[: newline_index + 1])
+                del self._stderr_buffer[: newline_index + 1]
+                line = frame.decode("utf-8", errors="replace").strip()
+                if line:
+                    self._stderr_lines.append(line)
+                continue
+
+            if len(self._stderr_buffer) > self._frame_limit:
+                self._stderr_lines.append(truncated_stderr_message(self._frame_limit))
+                self._stderr_buffer.clear()
+                self._stderr_skipping_line = True
+                return
+
+            if final:
+                line = self._stderr_buffer.decode("utf-8", errors="replace").strip()
+                self._stderr_buffer.clear()
+                if line:
+                    self._stderr_lines.append(line)
+            return

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/src/nonebot_plugin_codex/service.py

@@ -18,6 +18,7 @@ from dataclasses import field, asdict, dataclass
 from nonebot.adapters.telegram.model import InlineKeyboardButton, InlineKeyboardMarkup
 
 from .native_client import NativeCodexClient
+from .protocol_io import NdjsonProcessReader, ProtocolStreamError
 
 ProgressCallback = Callable[[str], Awaitable[None]]
 StreamTextCallback = Callable[[str], Awaitable[None]]
@@ -52,7 +53,7 @@ class CodexBridgeSettings:
     progress_history: int = 6
     diagnostic_history: int = 20
     chunk_size: int = 3500
-    stream_read_limit: int = 1024 * 1024
+    stream_read_limit: int = 8 * 1024 * 1024
     models_cache_path: Path = field(
         default_factory=lambda: Path.home() / ".codex" / "models_cache.json"
     )
@@ -468,6 +469,16 @@ def _append_diagnostic(session: ChatSession, line: str, limit: int) -> None:
         del session.diagnostics[:-limit]
 
 
+def _drain_protocol_reader_diagnostics(
+    session: ChatSession,
+    reader: NdjsonProcessReader,
+    *,
+    limit: int,
+) -> None:
+    for line in reader.drain_stderr_lines():
+        _append_diagnostic(session, line, limit)
+
+
 def _apply_event(
     session: ChatSession,
     event: dict[str, Any],
@@ -2994,11 +3005,15 @@ class CodexBridgeService:
         process = await self.launcher(
             *argv,
             stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.STDOUT,
+            stderr=asyncio.subprocess.PIPE,
             cwd=preferences.workdir,
             limit=self.settings.stream_read_limit,
         )
         session.process = process
+        reader = NdjsonProcessReader(
+            process,
+            frame_limit=self.settings.stream_read_limit,
+        )
 
         if on_progress is not None:
             await on_progress(
@@ -3012,13 +3027,23 @@ class CodexBridgeService:
                 )
             )
 
-        stdout = getattr(process, "stdout", None)
+        exit_code: int | None = None
+        cancelled = False
         try:
-            while stdout is not None:
-                raw_line = await stdout.readline()
-                if not raw_line:
+            while True:
+                _drain_protocol_reader_diagnostics(
+                    session,
+                    reader,
+                    limit=self.settings.diagnostic_history,
+                )
+                line = await reader.read_stdout_line()
+                _drain_protocol_reader_diagnostics(
+                    session,
+                    reader,
+                    limit=self.settings.diagnostic_history,
+                )
+                if line is None:
                     break
-                line = raw_line.decode("utf-8", errors="replace").strip()
                 if not line:
                     continue
                 event = parse_event_line(line)
@@ -3042,10 +3067,21 @@ class CodexBridgeService:
 
             exit_code = await process.wait()
             cancelled = session.cancel_requested
+        except ProtocolStreamError as exc:
+            _append_diagnostic(session, str(exc), self.settings.diagnostic_history)
+            await terminate_process(process, self.settings.kill_timeout)
+            exit_code = 1
+            cancelled = session.cancel_requested
         except Exception:
             await terminate_process(process, self.settings.kill_timeout)
             raise
         finally:
+            await reader.wait_closed()
+            _drain_protocol_reader_diagnostics(
+                session,
+                reader,
+                limit=self.settings.diagnostic_history,
+            )
             session.running = False
             session.process = None
             session.cancel_requested = False

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/tests/test_config.py

@@ -43,6 +43,12 @@ def test_config_accepts_supported_field_values() -> None:
     assert config.codex_stream_read_limit == 4096
 
 
+def test_config_defaults_stream_limit_to_8_mib() -> None:
+    config = Config()
+
+    assert config.codex_stream_read_limit == 8 * 1024 * 1024
+
+
 def test_config_ignores_removed_legacy_fields() -> None:
     config = Config(
         legacy_binary="legacy-bin",

nonebot_plugin_codex-0.1.5/tests/test_native_client.py

@@ -0,0 +1,401 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Any
+from dataclasses import dataclass
+
+import pytest
+
+from nonebot_plugin_codex.native_client import NativeCodexClient
+
+
+class FakeStdout:
+    def __init__(self, lines: list[str]) -> None:
+        self._lines = [line.encode("utf-8") for line in lines]
+
+    async def readline(self) -> bytes:
+        if self._lines:
+            return self._lines.pop(0)
+        await asyncio.sleep(0)
+        return b""
+
+    async def read(self, _size: int = -1) -> bytes:
+        return await self.readline()
+
+
+class FakeStdin:
+    def __init__(self) -> None:
+        self.buffer: list[str] = []
+
+    def write(self, data: bytes) -> None:
+        self.buffer.append(data.decode("utf-8"))
+
+    async def drain(self) -> None:
+        return None
+
+
+@dataclass
+class FakeProcess:
+    stdout: FakeStdout
+    stdin: FakeStdin
+    stderr: FakeStdout | None = None
+    returncode: int | None = None
+
+    def terminate(self) -> None:
+        self.returncode = 0
+
+    def kill(self) -> None:
+        self.returncode = -9
+
+    async def wait(self) -> int:
+        self.returncode = self.returncode or 0
+        return self.returncode
+
+
+@pytest.mark.asyncio
+async def test_native_client_start_resume_and_stream_text() -> None:
+    requests: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
+    process = FakeProcess(
+        stdout=FakeStdout(
+            [
+                json.dumps({"jsonrpc": "2.0", "id": 1, "result": {}}) + "\n",
+                json.dumps(
+                    {
+                        "jsonrpc": "2.0",
+                        "id": 2,
+                        "result": {
+                            "thread": {
+                                "id": "thread-1",
+                                "name": "Thread One",
+                                "updatedAt": "2025-03-01T00:00:00Z",
+                                "cwd": "/tmp/work",
+                                "source": "cli",
+                            }
+                        },
+                    }
+                )
+                + "\n",
+                json.dumps({"jsonrpc": "2.0", "id": 3, "result": {}}) + "\n",
+                json.dumps({"jsonrpc": "2.0", "method": "turn/started", "params": {}})
+                + "\n",
+                json.dumps(
+                    {
+                        "jsonrpc": "2.0",
+                        "method": "item/agentMessage/delta",
+                        "params": {"delta": "hello"},
+                    }
+                )
+                + "\n",
+                json.dumps(
+                    {
+                        "jsonrpc": "2.0",
+                        "method": "turn/completed",
+                        "params": {
+                            "threadId": "thread-1",
+                            "turn": {"status": "completed", "error": None},
+                        },
+                    }
+                )
+                + "\n",
+            ]
+        ),
+        stdin=FakeStdin(),
+    )
+
+    async def launcher(*args: Any, **kwargs: Any) -> FakeProcess:
+        requests.append((args, kwargs))
+        return process
+
+    client = NativeCodexClient(binary="codex", launcher=launcher)
+    progress: list[str] = []
+    streamed: list[str] = []
+
+    thread = await client.start_thread(
+        workdir="/tmp/work",
+        model="gpt-5",
+        reasoning_effort="xhigh",
+        permission_mode="safe",
+    )
+    result = await client.run_turn(
+        thread.thread_id,
+        "hello",
+        on_progress=progress.append,
+        on_stream_text=streamed.append,
+    )
+
+    assert requests[0][0][:3] == ("codex", "app-server", "--listen")
+    assert thread.thread_id == "thread-1"
+    assert progress == ["开始处理请求"]
+    assert streamed == ["hello"]
+    assert result.exit_code == 0
+    assert result.final_text == ""
+
+
+@pytest.mark.asyncio
+async def test_native_client_reads_large_stdout_frame_without_readline_limit(
+    tmp_path: Path,
+) -> None:
+    long_text = "A" * (2 * 1024 * 1024)
+    thread_payload = {
+        "jsonrpc": "2.0",
+        "id": 2,
+        "result": {
+            "thread": {
+                "id": "thread-1",
+                "name": "Thread One",
+                "updatedAt": "2025-03-01T00:00:00Z",
+                "cwd": "/tmp/work",
+                "source": "cli",
+            }
+        },
+    }
+    item_payload = {
+        "jsonrpc": "2.0",
+        "method": "item/completed",
+        "params": {
+            "threadId": "thread-1",
+            "item": {
+                "id": "msg-1",
+                "type": "agentMessage",
+                "text": long_text,
+            },
+        },
+    }
+    completed_payload = {
+        "jsonrpc": "2.0",
+        "method": "turn/completed",
+        "params": {
+            "threadId": "thread-1",
+            "turn": {"status": "completed", "error": None},
+        },
+    }
+    script = (
+        "import json, sys\n"
+        f"long_text = {long_text!r}\n"
+        "messages = [\n"
+        "    {'jsonrpc': '2.0', 'id': 1, 'result': {}},\n"
+        f"    {thread_payload!r},\n"
+        "    {'jsonrpc': '2.0', 'id': 3, 'result': {}},\n"
+        f"    {item_payload!r},\n"
+        f"    {completed_payload!r},\n"
+        "]\n"
+        "for message in messages:\n"
+        "    sys.stdout.write(json.dumps(message) + '\\n')\n"
+        "    sys.stdout.flush()\n"
+    )
+    script_path = tmp_path / "large_native_stdout.py"
+    script_path.write_text(script, encoding="utf-8")
+
+    async def launcher(*_args: Any, **_kwargs: Any):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            str(script_path),
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            limit=1024,
+        )
+
+    client = NativeCodexClient(
+        binary="codex",
+        launcher=launcher,
+        stream_read_limit=8 * 1024 * 1024,
+    )
+    try:
+        thread = await client.start_thread(
+            workdir="/tmp/work",
+            model="gpt-5",
+            reasoning_effort="xhigh",
+            permission_mode="safe",
+        )
+        result = await client.run_turn(thread.thread_id, "hello")
+
+        assert result.exit_code == 0
+        assert result.final_text == long_text
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_native_client_ignores_large_stderr_frames() -> None:
+    huge_stderr = "E" * 4096
+    thread_payload = {
+        "jsonrpc": "2.0",
+        "id": 2,
+        "result": {
+            "thread": {
+                "id": "thread-1",
+                "name": "Thread One",
+                "updatedAt": "2025-03-01T00:00:00Z",
+                "cwd": "/tmp/work",
+                "source": "cli",
+            }
+        },
+    }
+    script = (
+        "import json, sys\n"
+        f"huge_stderr = {huge_stderr!r}\n"
+        "sys.stdout.write("
+        "json.dumps({'jsonrpc': '2.0', 'id': 1, 'result': {}}) + '\\n'"
+        ")\n"
+        "sys.stdout.flush()\n"
+        "sys.stderr.write(huge_stderr + '\\n')\n"
+        "sys.stderr.flush()\n"
+        f"sys.stdout.write(json.dumps({thread_payload!r}) + '\\n')\n"
+        "sys.stdout.flush()\n"
+    )
+
+    async def launcher(*_args: Any, **kwargs: Any):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-c",
+            script,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=kwargs.get("stderr", asyncio.subprocess.PIPE),
+            limit=int(kwargs.get("limit", 1024)),
+    )
+
+    client = NativeCodexClient(binary="codex", launcher=launcher, stream_read_limit=1024)
+    try:
+        thread = await client.start_thread(
+            workdir="/tmp/work",
+            model="gpt-5",
+            reasoning_effort="xhigh",
+            permission_mode="safe",
+        )
+
+        assert thread.thread_id == "thread-1"
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_native_client_reports_friendly_error_for_oversized_frame() -> None:
+    long_text = "A" * 4096
+    thread_payload = {
+        "jsonrpc": "2.0",
+        "id": 2,
+        "result": {
+            "thread": {
+                "id": "thread-1",
+                "name": "Thread One",
+                "updatedAt": "2025-03-01T00:00:00Z",
+                "cwd": "/tmp/work",
+                "source": "cli",
+            }
+        },
+    }
+    item_payload = {
+        "jsonrpc": "2.0",
+        "method": "item/completed",
+        "params": {
+            "threadId": "thread-1",
+            "item": {
+                "id": "msg-1",
+                "type": "agentMessage",
+                "text": long_text,
+            },
+        },
+    }
+    script = (
+        "import json, sys\n"
+        f"long_text = {long_text!r}\n"
+        "sys.stdout.write("
+        "json.dumps({'jsonrpc': '2.0', 'id': 1, 'result': {}}) + '\\n'"
+        ")\n"
+        "sys.stdout.flush()\n"
+        f"sys.stdout.write(json.dumps({thread_payload!r}) + '\\n')\n"
+        "sys.stdout.flush()\n"
+        "sys.stdout.write("
+        "json.dumps({'jsonrpc': '2.0', 'id': 3, 'result': {}}) + '\\n'"
+        ")\n"
+        "sys.stdout.flush()\n"
+        f"sys.stdout.write(json.dumps({item_payload!r}) + '\\n')\n"
+        "sys.stdout.flush()\n"
+    )
+
+    async def launcher(*_args: Any, **kwargs: Any):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-c",
+            script,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=kwargs.get("stderr", asyncio.subprocess.PIPE),
+            limit=int(kwargs.get("limit", 1024)),
+        )
+
+    client = NativeCodexClient(binary="codex", launcher=launcher, stream_read_limit=1024)
+    try:
+        thread = await client.start_thread(
+            workdir="/tmp/work",
+            model="gpt-5",
+            reasoning_effort="xhigh",
+            permission_mode="safe",
+        )
+
+        with pytest.raises(RuntimeError, match="codex_stream_read_limit"):
+            await client.run_turn(thread.thread_id, "hello")
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_native_client_reports_incomplete_protocol_frame() -> None:
+    thread_payload = {
+        "jsonrpc": "2.0",
+        "id": 2,
+        "result": {
+            "thread": {
+                "id": "thread-1",
+                "name": "Thread One",
+                "updatedAt": "2025-03-01T00:00:00Z",
+                "cwd": "/tmp/work",
+                "source": "cli",
+            }
+        },
+    }
+    script = (
+        "import json, sys\n"
+        "sys.stdout.write("
+        "json.dumps({'jsonrpc': '2.0', 'id': 1, 'result': {}}) + '\\n'"
+        ")\n"
+        "sys.stdout.flush()\n"
+        f"sys.stdout.write(json.dumps({thread_payload!r}) + '\\n')\n"
+        "sys.stdout.flush()\n"
+        "sys.stdout.write("
+        "json.dumps({'jsonrpc': '2.0', 'id': 3, 'result': {}}) + '\\n'"
+        ")\n"
+        "sys.stdout.flush()\n"
+        "sys.stdout.write('{\"jsonrpc\":\"2.0\",\"method\":\"turn/completed\"')\n"
+        "sys.stdout.flush()\n"
+    )
+
+    async def launcher(*_args: Any, **kwargs: Any):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-c",
+            script,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=kwargs.get("stderr", asyncio.subprocess.PIPE),
+            limit=int(kwargs.get("limit", 1024)),
+        )
+
+    client = NativeCodexClient(binary="codex", launcher=launcher, stream_read_limit=1024)
+    try:
+        thread = await client.start_thread(
+            workdir="/tmp/work",
+            model="gpt-5",
+            reasoning_effort="xhigh",
+            permission_mode="safe",
+        )
+
+        with pytest.raises(RuntimeError, match="不完整的协议消息"):
+            await client.run_turn(thread.thread_id, "hello")
+    finally:
+        await client.close()

{nonebot_plugin_codex-0.1.4 → nonebot_plugin_codex-0.1.5}/tests/test_service.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import asyncio
 import json
 from pathlib import Path
+import sys
 
 import pytest
 
@@ -33,6 +35,8 @@ def make_service(
     model_cache_file: Path,
     *,
     threads: list[NativeThreadSummary] | None = None,
+    launcher=None,
+    stream_read_limit: int = 1024 * 1024,
 ) -> CodexBridgeService:
     codex_config = tmp_path / "config.toml"
     codex_config.write_text('model = "gpt-5"\nmodel_reasoning_effort = "xhigh"\n')
@@ -42,6 +46,7 @@ def make_service(
             workdir=str(tmp_path),
             models_cache_path=model_cache_file,
             codex_config_path=codex_config,
+            stream_read_limit=stream_read_limit,
             preferences_path=(
                 tmp_path / "data" / "nonebot_plugin_codex" / "preferences.json"
             ),
@@ -49,6 +54,7 @@ def make_service(
             sessions_dir=tmp_path / ".codex" / "sessions",
             archived_sessions_dir=tmp_path / ".codex" / "archived_sessions",
         ),
+        launcher=launcher,
         native_client=DummyNativeClient(threads),
         which_resolver=lambda _: "/usr/bin/codex",
     )
@@ -539,3 +545,102 @@ async def test_apply_effort_setting_panel_accepts_model_supported_medium(
 
     assert "medium" in notice
     assert service.get_preferences("private_1").reasoning_effort == "medium"
+
+
+@pytest.mark.asyncio
+async def test_run_prompt_exec_ignores_large_stderr_frames(
+    tmp_path: Path,
+    model_cache_file: Path,
+) -> None:
+    huge_stderr = "E" * 4096
+    completed_payload = {
+        "type": "item.completed",
+        "item": {"type": "agent_message", "text": "done"},
+    }
+    script = (
+        "import json, sys\n"
+        f"huge_stderr = {huge_stderr!r}\n"
+        "messages = [\n"
+        "    {'type': 'thread.started', 'thread_id': 'exec-1'},\n"
+        "    {'type': 'turn.started'},\n"
+        f"    {completed_payload!r},\n"
+        "]\n"
+        "sys.stderr.write(huge_stderr + '\\n')\n"
+        "sys.stderr.flush()\n"
+        "for message in messages:\n"
+        "    sys.stdout.write(json.dumps(message) + '\\n')\n"
+        "    sys.stdout.flush()\n"
+    )
+
+    async def launcher(*_args, **kwargs):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-c",
+            script,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=kwargs.get("stderr", asyncio.subprocess.PIPE),
+            limit=int(kwargs.get("limit", 1024)),
+        )
+
+    service = make_service(
+        tmp_path,
+        model_cache_file,
+        launcher=launcher,
+        stream_read_limit=1024,
+    )
+
+    result = await service.run_prompt("private_1", "hello", mode_override="exec")
+
+    assert result.exit_code == 0
+    assert result.final_text == "done"
+
+
+@pytest.mark.asyncio
+async def test_run_prompt_exec_returns_friendly_protocol_error_and_cleans_up(
+    tmp_path: Path,
+    model_cache_file: Path,
+) -> None:
+    long_text = "A" * 4096
+    completed_payload = {
+        "type": "item.completed",
+        "item": {"type": "agent_message", "text": long_text},
+    }
+    script = (
+        "import json, sys\n"
+        f"long_text = {long_text!r}\n"
+        "messages = [\n"
+        "    {'type': 'thread.started', 'thread_id': 'exec-1'},\n"
+        "    {'type': 'turn.started'},\n"
+        f"    {completed_payload!r},\n"
+        "]\n"
+        "for message in messages:\n"
+        "    sys.stdout.write(json.dumps(message) + '\\n')\n"
+        "    sys.stdout.flush()\n"
+    )
+
+    async def launcher(*_args, **kwargs):
+        return await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-c",
+            script,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=kwargs.get("stderr", asyncio.subprocess.PIPE),
+            limit=int(kwargs.get("limit", 1024)),
+        )
+
+    service = make_service(
+        tmp_path,
+        model_cache_file,
+        launcher=launcher,
+        stream_read_limit=1024,
+    )
+
+    result = await service.run_prompt("private_1", "hello", mode_override="exec")
+    session = service.get_session("private_1")
+
+    assert result.exit_code == 1
+    assert any("codex_stream_read_limit" in line for line in result.diagnostics)
+    assert session.running is False
+    assert session.process is None

nonebot_plugin_codex-0.1.4/tests/test_native_client.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-import json
-import asyncio
-from typing import Any
-from dataclasses import dataclass
-
-import pytest
-
-from nonebot_plugin_codex.native_client import NativeCodexClient
-
-
-class FakeStdout:
-    def __init__(self, lines: list[str]) -> None:
-        self._lines = [line.encode("utf-8") for line in lines]
-
-    async def readline(self) -> bytes:
-        if self._lines:
-            return self._lines.pop(0)
-        await asyncio.sleep(0)
-        return b""
-
-
-class FakeStdin:
-    def __init__(self) -> None:
-        self.buffer: list[str] = []
-
-    def write(self, data: bytes) -> None:
-        self.buffer.append(data.decode("utf-8"))
-
-    async def drain(self) -> None:
-        return None
-
-
-@dataclass
-class FakeProcess:
-    stdout: FakeStdout
-    stdin: FakeStdin
-    returncode: int | None = None
-
-    def terminate(self) -> None:
-        self.returncode = 0
-
-    def kill(self) -> None:
-        self.returncode = -9
-
-    async def wait(self) -> int:
-        self.returncode = self.returncode or 0
-        return self.returncode
-
-
-@pytest.mark.asyncio
-async def test_native_client_start_resume_and_stream_text() -> None:
-    requests: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
-    process = FakeProcess(
-        stdout=FakeStdout(
-            [
-                json.dumps({"jsonrpc": "2.0", "id": 1, "result": {}}) + "\n",
-                json.dumps(
-                    {
-                        "jsonrpc": "2.0",
-                        "id": 2,
-                        "result": {
-                            "thread": {
-                                "id": "thread-1",
-                                "name": "Thread One",
-                                "updatedAt": "2025-03-01T00:00:00Z",
-                                "cwd": "/tmp/work",
-                                "source": "cli",
-                            }
-                        },
-                    }
-                )
-                + "\n",
-                json.dumps({"jsonrpc": "2.0", "id": 3, "result": {}}) + "\n",
-                json.dumps({"jsonrpc": "2.0", "method": "turn/started", "params": {}})
-                + "\n",
-                json.dumps(
-                    {
-                        "jsonrpc": "2.0",
-                        "method": "item/agentMessage/delta",
-                        "params": {"delta": "hello"},
-                    }
-                )
-                + "\n",
-                json.dumps(
-                    {
-                        "jsonrpc": "2.0",
-                        "method": "turn/completed",
-                        "params": {
-                            "threadId": "thread-1",
-                            "turn": {"status": "completed", "error": None},
-                        },
-                    }
-                )
-                + "\n",
-            ]
-        ),
-        stdin=FakeStdin(),
-    )
-
-    async def launcher(*args: Any, **kwargs: Any) -> FakeProcess:
-        requests.append((args, kwargs))
-        return process
-
-    client = NativeCodexClient(binary="codex", launcher=launcher)
-    progress: list[str] = []
-    streamed: list[str] = []
-
-    thread = await client.start_thread(
-        workdir="/tmp/work",
-        model="gpt-5",
-        reasoning_effort="xhigh",
-        permission_mode="safe",
-    )
-    result = await client.run_turn(
-        thread.thread_id,
-        "hello",
-        on_progress=progress.append,
-        on_stream_text=streamed.append,
-    )
-
-    assert requests[0][0][:3] == ("codex", "app-server", "--listen")
-    assert thread.thread_id == "thread-1"
-    assert progress == ["开始处理请求"]
-    assert streamed == ["hello"]
-    assert result.exit_code == 0
-    assert result.final_text == ""