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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-codex
-Version: 0.1.3
+Version: 0.1.4
 Summary: Telegram bridge plugin for driving Codex from NoneBot
 Author-Email: ttiee <469784630@qq.com>
 License: GPL-3.0-or-later
@@ -122,6 +122,7 @@ codex_workdir = "/home/yourname"
 
 ```text
 /codex
+/panel
 /cd /home/yourname/projects/demo
 /mode resume
 然后继续直接发送普通文本消息续聊
@@ -129,6 +130,8 @@ codex_workdir = "/home/yourname"
 
 `/codex` 不带参数时会打开一个 Telegram 内的使用引导面板，方便你直接查看当前模式、工作目录、设置摘要，并进入目录浏览、设置面板或历史会话。
 
+`/panel` 和 `/status` 会打开统一的“当前工作台”面板，把模式、模型、推理强度、权限、工作目录、当前会话状态和最近历史摘要放在同一屏里，并提供进入设置、目录、历史、新会话和停止会话的快捷操作。
+
 你也可以直接把首条任务跟在 `/codex` 后面：
 
 ```text
@@ -147,6 +150,7 @@ codex_workdir = "/home/yourname"
 ```text
 /help
 /start
+/panel
 ```
 
 ## 配置说明
@@ -196,6 +200,8 @@ codex_stream_read_limit = 1048576
 | `/codex [prompt]` | 打开引导面板，或直接附带首条任务连接 Codex |
 | `/help` | 打开使用引导面板 |
 | `/start` | 打开使用引导面板 |
+| `/panel` | 打开统一工作台面板 |
+| `/status` | 打开统一工作台面板 |
 | `/mode [resume\|exec]` | 查看或切换默认模式 |
 | `/exec <prompt>` | 以一次性 `exec` 模式执行任务 |
 | `/new` | 新建当前聊天会话 |
@@ -229,6 +235,7 @@ codex_stream_read_limit = 1048576
 
 ## 目录与历史会话
 
+- `/panel` 或 `/status` 会打开统一工作台，一屏查看当前设置、工作目录、会话状态和最近历史，并跳转到常用控制面板。
 - `/cd` 可打开目录浏览器，逐级进入目录、切换 Home、显示隐藏目录，并把当前浏览目录设置为工作目录。
 - `/sessions` 会列出 native 与 exec 历史会话，便于恢复此前任务。
 - 历史会话恢复时会尝试切回原始工作目录；如果原目录不存在，会保留当前目录并给出提示。

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

@@ -109,6 +109,7 @@ codex_workdir = "/home/yourname"
 
 ```text
 /codex
+/panel
 /cd /home/yourname/projects/demo
 /mode resume
 然后继续直接发送普通文本消息续聊
@@ -116,6 +117,8 @@ codex_workdir = "/home/yourname"
 
 `/codex` 不带参数时会打开一个 Telegram 内的使用引导面板，方便你直接查看当前模式、工作目录、设置摘要，并进入目录浏览、设置面板或历史会话。
 
+`/panel` 和 `/status` 会打开统一的“当前工作台”面板，把模式、模型、推理强度、权限、工作目录、当前会话状态和最近历史摘要放在同一屏里，并提供进入设置、目录、历史、新会话和停止会话的快捷操作。
+
 你也可以直接把首条任务跟在 `/codex` 后面：
 
 ```text
@@ -134,6 +137,7 @@ codex_workdir = "/home/yourname"
 ```text
 /help
 /start
+/panel
 ```
 
 ## 配置说明
@@ -183,6 +187,8 @@ codex_stream_read_limit = 1048576
 | `/codex [prompt]` | 打开引导面板，或直接附带首条任务连接 Codex |
 | `/help` | 打开使用引导面板 |
 | `/start` | 打开使用引导面板 |
+| `/panel` | 打开统一工作台面板 |
+| `/status` | 打开统一工作台面板 |
 | `/mode [resume\|exec]` | 查看或切换默认模式 |
 | `/exec <prompt>` | 以一次性 `exec` 模式执行任务 |
 | `/new` | 新建当前聊天会话 |
@@ -216,6 +222,7 @@ codex_stream_read_limit = 1048576
 
 ## 目录与历史会话
 
+- `/panel` 或 `/status` 会打开统一工作台，一屏查看当前设置、工作目录、会话状态和最近历史，并跳转到常用控制面板。
 - `/cd` 可打开目录浏览器，逐级进入目录、切换 Home、显示隐藏目录，并把当前浏览目录设置为工作目录。
 - `/sessions` 会列出 native 与 exec 历史会话，便于恢复此前任务。
 - 历史会话恢复时会尝试切回原始工作目录；如果原目录不存在，会保留当前目录并给出提示。

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

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

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/src/nonebot_plugin_codex/__init__.py

@@ -88,6 +88,8 @@ if _runtime_ready:
     codex_cmd = on_command("codex", priority=10, block=True)
     help_cmd = on_command("help", priority=10, block=True)
     start_cmd = on_command("start", priority=10, block=True)
+    panel_cmd = on_command("panel", priority=10, block=True)
+    status_cmd = on_command("status", priority=10, block=True)
     mode_cmd = on_command("mode", priority=10, block=True)
     exec_cmd = on_command("exec", priority=10, block=True)
     new_cmd = on_command("new", priority=10, block=True)
@@ -125,6 +127,12 @@ if _runtime_ready:
         block=True,
         rule=handlers.is_onboarding_callback,
     )
+    workspace_callback = on_type(
+        CallbackQueryEvent,
+        priority=10,
+        block=True,
+        rule=handlers.is_workspace_callback,
+    )
 
     @codex_cmd.handle()
     async def _handle_codex(
@@ -140,6 +148,14 @@ if _runtime_ready:
     async def _handle_start(bot: Bot, event: MessageEvent) -> None:
         await handlers.handle_start(bot, event)
 
+    @panel_cmd.handle()
+    async def _handle_panel(bot: Bot, event: MessageEvent) -> None:
+        await handlers.handle_panel(bot, event)
+
+    @status_cmd.handle()
+    async def _handle_status(bot: Bot, event: MessageEvent) -> None:
+        await handlers.handle_status(bot, event)
+
     @mode_cmd.handle()
     async def _handle_mode(
         bot: Bot, event: MessageEvent, args: Message = CommandArg()
@@ -220,6 +236,12 @@ if _runtime_ready:
     ) -> None:
         await handlers.handle_onboarding_callback(bot, event)
 
+    @workspace_callback.handle()
+    async def _handle_workspace_callback(
+        bot: Bot, event: CallbackQueryEvent
+    ) -> None:
+        await handlers.handle_workspace_callback(bot, event)
+
     @follow_up.handle()
     async def _handle_follow_up(bot: Bot, event: MessageEvent) -> None:
         await handlers.handle_follow_up(bot, event)

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

@@ -40,6 +40,8 @@ SETTING_STALE_MESSAGE = "设置面板已失效，请重新执行对应命令"
 SUPPORTED_SETTING_PANELS = {"mode", "model", "effort", "permission"}
 ONBOARDING_CALLBACK_PREFIX = "cop"
 ONBOARDING_STALE_MESSAGE = "引导面板已失效，请重新执行 /codex"
+WORKSPACE_CALLBACK_PREFIX = "cwp"
+WORKSPACE_STALE_MESSAGE = "工作台面板已失效，请重新执行 /panel"
 
 
 @dataclass(slots=True)
@@ -205,6 +207,14 @@ class OnboardingPanelState:
     message_id: int | None = None
 
 
+@dataclass(slots=True)
+class WorkspacePanelState:
+    chat_key: str
+    token: str
+    version: int
+    message_id: int | None = None
+
+
 def build_chat_key(chat_type: str, chat_id: int) -> str:
     if chat_type == "private":
         return f"private_{chat_id}"
@@ -356,6 +366,22 @@ def decode_onboarding_callback(payload: str) -> tuple[str, int, str]:
     return token, version, parts[3]
 
 
+def encode_workspace_callback(token: str, version: int, action: str) -> str:
+    return f"{WORKSPACE_CALLBACK_PREFIX}:{token}:{version}:{action}"
+
+
+def decode_workspace_callback(payload: str) -> tuple[str, int, str]:
+    parts = payload.split(":")
+    if len(parts) != 4 or parts[0] != WORKSPACE_CALLBACK_PREFIX:
+        raise ValueError("无效的工作台回调。")
+    token = parts[1]
+    try:
+        version = int(parts[2])
+    except ValueError as exc:
+        raise ValueError("无效的工作台回调。") from exc
+    return token, version, parts[3]
+
+
 def parse_event_line(line: str) -> dict[str, Any] | None:
     try:
         payload = json.loads(line)
@@ -528,6 +554,7 @@ class CodexBridgeService:
         self.history_browsers: dict[str, HistoryBrowserState] = {}
         self.setting_panels: dict[str, SettingPanelState] = {}
         self.onboarding_panels: dict[str, OnboardingPanelState] = {}
+        self.workspace_panels: dict[str, WorkspacePanelState] = {}
         self._native_history_entries: list[HistoricalSessionSummary] = []
         self._native_history_loaded = False
         self._history_log_cache: dict[str, HistoryLogCacheEntry] = {}
@@ -1715,6 +1742,194 @@ class CodexBridgeService:
         self.get_onboarding_panel(chat_key, token=token, version=version)
         self.onboarding_panels.pop(chat_key, None)
 
+    def _replace_workspace_panel_state(
+        self,
+        chat_key: str,
+        *,
+        previous: WorkspacePanelState | None = None,
+    ) -> WorkspacePanelState:
+        state = WorkspacePanelState(
+            chat_key=chat_key,
+            token=previous.token if previous else self._make_browser_token(),
+            version=(previous.version + 1) if previous else 1,
+            message_id=previous.message_id if previous else None,
+        )
+        self.workspace_panels[chat_key] = state
+        return state
+
+    def open_workspace_panel(self, chat_key: str) -> WorkspacePanelState:
+        self.get_preferences(chat_key)
+        return self._replace_workspace_panel_state(chat_key)
+
+    def get_workspace_panel(
+        self,
+        chat_key: str,
+        token: str | None = None,
+        version: int | None = None,
+    ) -> WorkspacePanelState:
+        state = self.workspace_panels.get(chat_key)
+        if state is None:
+            raise ValueError(WORKSPACE_STALE_MESSAGE)
+        if token is not None and state.token != token:
+            raise ValueError(WORKSPACE_STALE_MESSAGE)
+        if version is not None and state.version != version:
+            raise ValueError(WORKSPACE_STALE_MESSAGE)
+        return state
+
+    def remember_workspace_panel_message(
+        self,
+        chat_key: str,
+        token: str,
+        message_id: int | None,
+    ) -> None:
+        if message_id is None:
+            return
+        panel = self.get_workspace_panel(chat_key, token=token)
+        panel.message_id = message_id
+
+    def close_workspace_panel(self, chat_key: str, token: str, version: int) -> None:
+        self.get_workspace_panel(chat_key, token=token, version=version)
+        self.workspace_panels.pop(chat_key, None)
+
+    def _workspace_active_mode(self, chat_key: str, preferences: ChatPreferences) -> str:
+        session = self.sessions.get(chat_key)
+        if session is not None and session.active_mode in {"resume", "exec"}:
+            return session.active_mode
+        return preferences.default_mode
+
+    def _workspace_session_summary(self, chat_key: str) -> str:
+        session = self.sessions.get(chat_key)
+        if session is None:
+            return "未开始"
+        active_mode = (
+            session.active_mode
+            if session.active_mode in {"resume", "exec"}
+            else "resume"
+        )
+        thread_id = (
+            self._current_exec_thread_id(session)
+            if active_mode == "exec"
+            else session.native_thread_id or session.thread_id
+        )
+        if not thread_id and not session.active:
+            return "未开始"
+        if not thread_id:
+            return f"{active_mode} | 未绑定"
+        return f"{active_mode} | {thread_id}"
+
+    def _workspace_recent_history_lines(self) -> list[str]:
+        try:
+            entries = self.list_history_sessions()[:2]
+        except ValueError:
+            return ["最近历史：不可用"]
+        if not entries:
+            return ["最近历史：无"]
+        lines = ["最近历史："]
+        for entry in entries:
+            lines.append(
+                "- "
+                f"{entry.thread_name} | "
+                f"{self._format_history_relative_time(entry.updated_at)}"
+            )
+        return lines
+
+    def navigate_workspace_panel(
+        self,
+        chat_key: str,
+        token: str,
+        version: int,
+        action: str,
+    ) -> WorkspacePanelState:
+        panel = self.get_workspace_panel(chat_key, token=token, version=version)
+        if action != "refresh":
+            raise ValueError("未知工作台操作。")
+        return self._replace_workspace_panel_state(chat_key, previous=panel)
+
+    def render_workspace_panel(
+        self, chat_key: str
+    ) -> tuple[str, InlineKeyboardMarkup]:
+        panel = self.get_workspace_panel(chat_key)
+        preferences = self.get_preferences(chat_key)
+        lines = [
+            "当前工作台",
+            f"当前模式：{self._workspace_active_mode(chat_key, preferences)}",
+            f"当前设置：{format_preferences_summary(preferences)}",
+            f"当前工作目录：{preferences.workdir}",
+            f"当前会话：{self._workspace_session_summary(chat_key)}",
+            *self._workspace_recent_history_lines(),
+        ]
+        keyboard = [
+            [
+                InlineKeyboardButton(
+                    text="模式",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "mode"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="模型",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "model"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="强度",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "effort"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="权限",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "permission"
+                    ),
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="目录",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "browse"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="历史",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "history"
+                    ),
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="新会话",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "new"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="停止",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "stop"
+                    ),
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="刷新",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "refresh"
+                    ),
+                ),
+                InlineKeyboardButton(
+                    text="关闭",
+                    callback_data=encode_workspace_callback(
+                        panel.token, panel.version, "close"
+                    ),
+                ),
+            ],
+        ]
+        return "\n".join(lines), InlineKeyboardMarkup(inline_keyboard=keyboard)
+
     def render_onboarding_panel(
         self, chat_key: str
     ) -> tuple[str, InlineKeyboardMarkup]:

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/src/nonebot_plugin_codex/telegram.py

@@ -19,10 +19,13 @@ from .service import (
     ONBOARDING_CALLBACK_PREFIX,
     SETTING_STALE_MESSAGE,
     SETTING_CALLBACK_PREFIX,
+    WORKSPACE_STALE_MESSAGE,
+    WORKSPACE_CALLBACK_PREFIX,
     CodexBridgeService,
     chunk_text,
     build_chat_key,
     decode_onboarding_callback,
+    decode_workspace_callback,
     format_result_text,
     decode_browser_callback,
     decode_history_callback,
@@ -354,6 +357,11 @@ class TelegramHandlers:
             f"{ONBOARDING_CALLBACK_PREFIX}:"
         )
 
+    async def is_workspace_callback(self, event: CallbackQueryEvent) -> bool:
+        return isinstance(event.data, str) and event.data.startswith(
+            f"{WORKSPACE_CALLBACK_PREFIX}:"
+        )
+
     def callback_message_id(self, event: CallbackQueryEvent) -> int | None:
         message = getattr(event, "message", None)
         return getattr(message, "message_id", None)
@@ -446,6 +454,18 @@ class TelegramHandlers:
             getattr(message, "message_id", None),
         )
 
+    async def send_workspace_panel(
+        self, bot: Bot, event: MessageEvent, chat_key: str
+    ) -> None:
+        panel = self.service.open_workspace_panel(chat_key)
+        text, markup = self.service.render_workspace_panel(chat_key)
+        message = await self.send_event_message(bot, event, text, reply_markup=markup)
+        self.service.remember_workspace_panel_message(
+            chat_key,
+            panel.token,
+            getattr(message, "message_id", None),
+        )
+
     async def edit_or_resend_browser(
         self,
         bot: Bot,
@@ -547,6 +567,39 @@ class TelegramHandlers:
                 getattr(message, "message_id", None),
             )
 
+    async def edit_or_resend_workspace_panel(
+        self,
+        bot: Bot,
+        event: CallbackQueryEvent,
+        chat_key: str,
+    ) -> None:
+        panel = self.service.get_workspace_panel(chat_key)
+        text, markup = self.service.render_workspace_panel(chat_key)
+        message_id = self.callback_message_id(event) or panel.message_id
+        chat_id = self.event_chat(event).id
+        try:
+            if message_id is None:
+                raise ValueError("missing message id")
+            await self.edit_message(
+                bot,
+                chat_id=chat_id,
+                message_id=message_id,
+                text=text,
+                reply_markup=markup,
+            )
+            self.service.remember_workspace_panel_message(
+                chat_key, panel.token, message_id
+            )
+        except Exception:
+            message = await self.send_chat_message(
+                bot, chat_id, text, reply_markup=markup
+            )
+            self.service.remember_workspace_panel_message(
+                chat_key,
+                panel.token,
+                getattr(message, "message_id", None),
+            )
+
     async def handle_codex(self, bot: Bot, event: MessageEvent, args: Message) -> None:
         chat_key = self.chat_key(event)
         session = self.service.activate_chat(chat_key)
@@ -569,6 +622,12 @@ class TelegramHandlers:
     async def handle_start(self, bot: Bot, event: MessageEvent) -> None:
         await self.send_onboarding_panel(bot, event, self.chat_key(event))
 
+    async def handle_panel(self, bot: Bot, event: MessageEvent) -> None:
+        await self.send_workspace_panel(bot, event, self.chat_key(event))
+
+    async def handle_status(self, bot: Bot, event: MessageEvent) -> None:
+        await self.send_workspace_panel(bot, event, self.chat_key(event))
+
     async def handle_mode(self, bot: Bot, event: MessageEvent, args: Message) -> None:
         chat_key = self.chat_key(event)
         mode = args.extract_plain_text().strip()
@@ -890,6 +949,79 @@ class TelegramHandlers:
                 event.id, text=self.error_text(exc), show_alert=True
             )
 
+    async def handle_workspace_callback(
+        self, bot: Bot, event: CallbackQueryEvent
+    ) -> None:
+        if not isinstance(event.data, str):
+            await bot.answer_callback_query(
+                event.id, text=WORKSPACE_STALE_MESSAGE, show_alert=True
+            )
+            return
+
+        try:
+            chat_key = self.chat_key(event)
+            chat_id = self.event_chat(event).id
+            token, version, action = decode_workspace_callback(event.data)
+            self.service.get_workspace_panel(chat_key, token=token, version=version)
+            if action in {"mode", "model", "effort", "permission"}:
+                await self.send_setting_panel_to_chat(bot, chat_id, chat_key, action)
+                await bot.answer_callback_query(event.id)
+                return
+            if action == "browse":
+                await self.send_browser_to_chat(bot, chat_id, chat_key)
+                await bot.answer_callback_query(event.id)
+                return
+            if action == "history":
+                await self.send_history_browser_to_chat(bot, chat_id, chat_key)
+                await bot.answer_callback_query(event.id)
+                return
+            if action == "new":
+                await self.service.reset_chat(chat_key, keep_active=True)
+                await self.send_chat_message(
+                    bot,
+                    chat_id,
+                    (
+                        "已清空当前 Codex 会话。下一条普通消息会按以下设置新开会话：\n"
+                        f"{self.current_summary(chat_key)}"
+                    ),
+                )
+                await bot.answer_callback_query(event.id, text="已新开会话。")
+                return
+            if action == "stop":
+                await self.service.reset_chat(chat_key, keep_active=False)
+                await self.send_chat_message(
+                    bot, chat_id, "已断开当前聊天窗口的 Codex 会话。"
+                )
+                await bot.answer_callback_query(event.id, text="已停止。")
+                return
+            if action == "close":
+                self.service.close_workspace_panel(chat_key, token, version)
+                message_id = self.callback_message_id(event)
+                if message_id is not None:
+                    await self.edit_message(
+                        bot,
+                        chat_id=chat_id,
+                        message_id=message_id,
+                        text="工作台已关闭。",
+                        reply_markup=None,
+                    )
+                await bot.answer_callback_query(event.id, text="已关闭。")
+                return
+            self.service.navigate_workspace_panel(chat_key, token, version, action)
+            await self.edit_or_resend_workspace_panel(bot, event, chat_key)
+            await bot.answer_callback_query(event.id)
+        except ValueError as exc:
+            text = str(exc) or WORKSPACE_STALE_MESSAGE
+            await bot.answer_callback_query(
+                event.id,
+                text=text,
+                show_alert=text == WORKSPACE_STALE_MESSAGE,
+            )
+        except RuntimeError as exc:
+            await bot.answer_callback_query(
+                event.id, text=self.error_text(exc), show_alert=True
+            )
+
     async def handle_follow_up(self, bot: Bot, event: MessageEvent) -> None:
         chat_key = self.chat_key(event)
         session = self.service.get_session(chat_key)

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/src/nonebot_plugin_codex/telegram_commands.py

@@ -28,6 +28,16 @@ TELEGRAM_COMMAND_SPECS: tuple[TelegramCommandSpec, ...] = (
         description="打开使用引导面板",
         usage="/start",
     ),
+    TelegramCommandSpec(
+        name="panel",
+        description="打开当前工作台",
+        usage="/panel",
+    ),
+    TelegramCommandSpec(
+        name="status",
+        description="打开当前工作台",
+        usage="/status",
+    ),
     TelegramCommandSpec(
         name="mode",
         description="查看或切换默认模式",

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/tests/test_release_notes.py

@@ -20,7 +20,8 @@ def test_render_release_notes_groups_conventional_commits() -> None:
         ],
     )
 
-    assert "# v0.1.2" in notes
+    assert notes.startswith("Released on ")
+    assert "# v0.1.2" not in notes
     assert (
         "Compare: https://github.com/ttiee/nonebot-plugin-codex/compare/"
         "v0.1.1...v0.1.2"

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

@@ -451,6 +451,56 @@ def test_render_setting_panels_show_expected_headings(
     assert markup.inline_keyboard
 
 
+def test_render_workspace_panel_shows_current_state_and_recent_history(
+    tmp_path: Path,
+    model_cache_file: Path,
+) -> None:
+    service = make_service(tmp_path, model_cache_file)
+    workdir = tmp_path / "workspace"
+    workdir.mkdir()
+    service.preference_overrides["private_1"] = service._default_preferences()  # noqa: SLF001
+    service.preference_overrides["private_1"].workdir = str(workdir.resolve())
+    session = service.activate_chat("private_1")
+    session.active_mode = "exec"
+    session.exec_thread_id = "exec-1"
+    session.thread_id = "exec-1"
+    write_history_session(
+        tmp_path,
+        session_id="exec-1",
+        thread_name="Recent Session",
+        assistant_text="assistant world",
+    )
+
+    service.open_workspace_panel("private_1")
+    text, markup = service.render_workspace_panel("private_1")
+
+    assert "当前工作台" in text
+    assert "当前模式：exec" in text
+    assert "模型: gpt-5 | 推理: xhigh | 权限: safe" in text
+    assert f"当前工作目录：{workdir.resolve()}" in text
+    assert "当前会话：exec | exec-1" in text
+    assert "Recent Session" in text
+    assert markup.inline_keyboard
+
+
+def test_navigate_workspace_panel_refresh_reuses_token_and_bumps_version(
+    tmp_path: Path,
+    model_cache_file: Path,
+) -> None:
+    service = make_service(tmp_path, model_cache_file)
+
+    panel = service.open_workspace_panel("private_1")
+    refreshed = service.navigate_workspace_panel(
+        "private_1",
+        panel.token,
+        panel.version,
+        "refresh",
+    )
+
+    assert refreshed.token == panel.token
+    assert refreshed.version == panel.version + 1
+
+
 @pytest.mark.asyncio
 async def test_apply_permission_setting_panel_updates_preference(
     tmp_path: Path, model_cache_file: Path

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/tests/test_telegram_commands.py

@@ -12,6 +12,8 @@ def test_build_telegram_commands_uses_expected_order_and_chinese_descriptions()
         "codex",
         "help",
         "start",
+        "panel",
+        "status",
         "mode",
         "exec",
         "new",
@@ -30,6 +32,8 @@ def test_build_telegram_commands_uses_expected_order_and_chinese_descriptions()
         {"command": "codex", "description": "连接 Codex 并可附带首条任务"},
         {"command": "help", "description": "打开使用引导面板"},
         {"command": "start", "description": "打开使用引导面板"},
+        {"command": "panel", "description": "打开当前工作台"},
+        {"command": "status", "description": "打开当前工作台"},
         {"command": "mode", "description": "查看或切换默认模式"},
         {"command": "exec", "description": "以一次性 exec 模式执行任务"},
         {"command": "new", "description": "新建当前聊天会话"},
@@ -47,6 +51,7 @@ def test_build_telegram_commands_uses_expected_order_and_chinese_descriptions()
 
 def test_build_plugin_usage_lists_all_commands() -> None:
     assert build_plugin_usage() == (
-        "/codex [prompt], /help, /start, /mode, /exec, /new, /stop, /models, "
-        "/model, /effort, /permission, /pwd, /cd, /home, /sessions"
+        "/codex [prompt], /help, /start, /panel, /status, /mode, /exec, /new, "
+        "/stop, /models, /model, /effort, /permission, /pwd, /cd, /home, "
+        "/sessions"
     )

{nonebot_plugin_codex-0.1.3 → nonebot_plugin_codex-0.1.4}/tests/test_telegram_handlers.py

@@ -16,6 +16,7 @@ from nonebot_plugin_codex.service import (
     encode_browser_callback,
     encode_history_callback,
     encode_setting_callback,
+    encode_workspace_callback,
 )
 
 
@@ -146,6 +147,8 @@ class FakeService:
         self.setting_text = "模式设置"
         self.onboarding_text = "开始使用 Codex"
         self.onboarding_markup = SimpleNamespace(name="onboarding")
+        self.workspace_text = "当前工作台"
+        self.workspace_markup = SimpleNamespace(name="workspace")
         self.default_mode = "resume"
         self.execute_calls: list[tuple[str, str | None]] = []
         self.browser_token = "token"
@@ -162,6 +165,9 @@ class FakeService:
         self.onboarding_token = "onboarding"
         self.onboarding_version = 1
         self.onboarding_closed = False
+        self.workspace_token = "workspace"
+        self.workspace_version = 1
+        self.workspace_closed = False
 
     def get_session(self, chat_key: str) -> ChatSession:
         return self.session
@@ -362,6 +368,49 @@ class FakeService:
     def close_onboarding_panel(self, chat_key: str, token: str, version: int) -> None:
         self.onboarding_closed = True
 
+    def open_workspace_panel(self, chat_key: str) -> SimpleNamespace:
+        return SimpleNamespace(token=self.workspace_token)
+
+    def render_workspace_panel(self, chat_key: str) -> tuple[str, Any]:
+        return self.workspace_text, self.workspace_markup
+
+    def remember_workspace_panel_message(
+        self, chat_key: str, token: str, message_id: int | None
+    ) -> None:
+        return None
+
+    def get_workspace_panel(
+        self,
+        chat_key: str,
+        token: str | None = None,
+        version: int | None = None,
+    ) -> SimpleNamespace:
+        if token is not None and token != self.workspace_token:
+            raise ValueError("工作台面板已失效，请重新执行 /panel")
+        if version is not None and version != self.workspace_version:
+            raise ValueError("工作台面板已失效，请重新执行 /panel")
+        return SimpleNamespace(
+            token=self.workspace_token,
+            version=self.workspace_version,
+            message_id=1,
+        )
+
+    def close_workspace_panel(self, chat_key: str, token: str, version: int) -> None:
+        self.workspace_closed = True
+
+    def navigate_workspace_panel(
+        self,
+        chat_key: str,
+        token: str,
+        version: int,
+        action: str,
+    ) -> SimpleNamespace:
+        return SimpleNamespace(
+            token=self.workspace_token,
+            version=self.workspace_version,
+            message_id=1,
+        )
+
 
 def make_real_service(
     tmp_path: Path,
@@ -527,6 +576,143 @@ async def test_handle_sessions_opens_history_browser() -> None:
     assert bot.sent[0]["text"] == "Codex 历史会话"
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("handler_name", ["handle_panel", "handle_status"])
+async def test_panel_and_status_open_workspace_panel(handler_name: str) -> None:
+    service = FakeService()
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+
+    await getattr(handlers, handler_name)(bot, FakeEvent(""))
+
+    assert bot.sent[0]["text"] == "当前工作台"
+    assert bot.sent[0]["reply_markup"] is service.workspace_markup
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("action", "expected_text"),
+    [
+        ("mode", "模式设置"),
+        ("model", "模型设置"),
+        ("effort", "推理强度设置"),
+        ("permission", "权限模式设置"),
+        ("browse", "目录浏览"),
+        ("history", "Codex 历史会话"),
+    ],
+)
+async def test_handle_workspace_callback_opens_existing_panels(
+    action: str,
+    expected_text: str,
+) -> None:
+    service = FakeService()
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+    event = FakeCallbackEvent(
+        encode_workspace_callback(
+            service.workspace_token,
+            service.workspace_version,
+            action,
+        )
+    )
+
+    await handlers.handle_workspace_callback(bot, event)
+
+    assert bot.sent[0]["text"] == expected_text
+
+
+@pytest.mark.asyncio
+async def test_handle_workspace_callback_new_resets_chat() -> None:
+    service = FakeService()
+    service.session.thread_id = "thread-1"
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+    event = FakeCallbackEvent(
+        encode_workspace_callback(
+            service.workspace_token,
+            service.workspace_version,
+            "new",
+        )
+    )
+
+    await handlers.handle_workspace_callback(bot, event)
+
+    assert "已清空当前 Codex 会话" in bot.sent[0]["text"]
+    assert bot.answered[0]["text"] == "已新开会话。"
+
+
+@pytest.mark.asyncio
+async def test_handle_workspace_callback_stop_disconnects_chat() -> None:
+    service = FakeService()
+    service.session.active = True
+    service.session.thread_id = "thread-1"
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+    event = FakeCallbackEvent(
+        encode_workspace_callback(
+            service.workspace_token,
+            service.workspace_version,
+            "stop",
+        )
+    )
+
+    await handlers.handle_workspace_callback(bot, event)
+
+    assert bot.sent[0]["text"] == "已断开当前聊天窗口的 Codex 会话。"
+    assert bot.answered[0]["text"] == "已停止。"
+
+
+@pytest.mark.asyncio
+async def test_handle_workspace_callback_refresh_rerenders_panel() -> None:
+    service = FakeService()
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+    event = FakeCallbackEvent(
+        encode_workspace_callback(
+            service.workspace_token,
+            service.workspace_version,
+            "refresh",
+        )
+    )
+
+    await handlers.handle_workspace_callback(bot, event)
+
+    assert bot.edited[0]["text"] == "当前工作台"
+
+
+@pytest.mark.asyncio
+async def test_handle_workspace_callback_close_closes_panel() -> None:
+    service = FakeService()
+    handlers = TelegramHandlers(service)
+    bot = FakeBot()
+    event = FakeCallbackEvent(
+        encode_workspace_callback(
+            service.workspace_token,
+            service.workspace_version,
+            "close",
+        )
+    )
+
+    await handlers.handle_workspace_callback(bot, event)
+
+    assert service.workspace_closed is True
+    assert bot.edited[0]["text"] == "工作台已关闭。"
+    assert bot.answered[0]["text"] == "已关闭。"
+
+
+@pytest.mark.asyncio
+async def test_handle_workspace_callback_rejects_stale_payload() -> None:
+    handlers = TelegramHandlers(FakeService())
+    bot = FakeBot()
+
+    await handlers.handle_workspace_callback(
+        bot, FakeCallbackEvent("cwp:stale:1:browse")
+    )
+
+    assert bot.answered[0]["text"] == "工作台面板已失效，请重新执行 /panel"
+    assert bot.answered[0]["show_alert"] is True
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("payload", "expected_text"),