remote-claude 0.2.13 → 0.2.15

package/README.md

@@ -11,7 +11,7 @@ Claude Code 只能在启动它的那个终端窗口里操作。一旦离开电
 - **飞书里直接操作** — 手机/平板打开飞书，就能看到 Claude 的实时输出，发消息、选选项、批准权限，和终端里一模一样。
 - **用手机无缝延续电脑上做的工作** — 电脑上打开的Claude进程，也可以用飞书共享操作，开会、午休、通勤、上厕所时，都可以用手机延续之前在电脑上的工作。
 - **在电脑上也可以无缝延续手机上的工作** - 在lark端也可以打开新的Claude进程启动新的工作，回到电脑前还可以`attach`共享操作同一个Claude进程，延续手机端的工作。
-- **多端共享操作** — 多个终端 + 飞书可以共享操作同一个claude进程，回到家里ssh登录到服务器上也可以通过`attach`继续操作在公司ssh登录到服务器上打开的claude进程操作。
+- **多端共享操作** — 多个终端 + 飞书可以共享操作同一个claude/codex进程，回到家里ssh登录到服务器上也可以通过`attach`继续操作在公司ssh登录到服务器上打开的claude/codex进程操作。
 - **机制安全** - 完全不侵入 Claude 进程，remote 功能完全通过终端交互来实现，不必担心 Claude 进程意外崩溃导致工作进展丢失。
 
 ## 飞书端体验
@@ -68,7 +68,7 @@ remote-claude attach <会话名>
 
 1. 登录[飞书开放平台](https://open.feishu.cn/)，创建企业自建应用
 2. 获取 **App ID** 和 **App Secret**
-3. 用`cla`或`cl`启动一次claude, 按照交互提示填入**App ID** 和 **App Secret**
+3. 用`cla`或`cl`启动一次claude(或用cx或cdx启动一次codex), 按照交互提示填入**App ID** 和 **App Secret**
 4. [飞书开放平台]的企业自建应用页面`添加应用能力`（机器人能力）
 5. 企业自建应用页面配置事件回调（如果第3步没启动成功这里配置不了）：
   - `事件与回调` -> `事件配置` -> `订阅方式`右边的笔图标 -> `选择：使用长连接接收事件` -> `点击保存` -> `下面添加事件: 接收消息 v2.0 (im.message.receive_v1)`
@@ -123,6 +123,8 @@ remote-claude attach <会话名>
       "im:message.p2p_msg:readonly",
       "im:message.reactions:read",
       "im:message.reactions:write_only",
+      "im:message.urgent",
+      "im:message.urgent.status:write",
       "im:message:readonly",
       "im:message:recall",
       "im:message:send_as_bot",
@@ -198,9 +200,9 @@ remote-claude attach <会话名>
 7. 企业自建应用页面: `创建版本` -> `发布到线上`
 8. 至此，完成飞书机器人配置
 
-#### 4.2 通过飞书机器人操作claude
+#### 4.2 通过飞书机器人操作claude/codex
 
-1. 从飞书搜素刚刚创建的飞书机器人（第一次搜比较慢，如果搜不到可能是忘记发布了）
+1. 从飞书搜索刚刚创建的飞书机器人（第一次搜比较慢，如果搜不到可能是忘记发布了）
 2. 飞书中与机器人对话，可用命令: 
   - `/menu` 展示菜单卡片，后续操作都操作这个卡片上的按钮即可
 

package/init.sh

@@ -40,6 +40,11 @@ setup_path() {
     # 不存在则创建
     [[ -f "$PROFILE" ]] || touch "$PROFILE"
 
+    # 未写入 source .bashrc 则追加
+    if ! grep -qF '.bashrc' "$PROFILE" 2>/dev/null; then
+        echo '[ -f "$HOME/.bashrc" ] && . "$HOME/.bashrc"' >> "$PROFILE"
+    fi
+
     # 未写入则追加
     if ! grep -qF '$HOME/.local/bin' "$PROFILE" 2>/dev/null; then
         echo "" >> "$PROFILE"

package/lark_client/card_builder.py

@@ -1201,7 +1201,8 @@ def build_session_closed_card(session_name: str) -> Dict[str, Any]:
 
 
 def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
-                    session_groups: Optional[Dict[str, str]] = None, page: int = 0) -> Dict[str, Any]:
+                    session_groups: Optional[Dict[str, str]] = None, page: int = 0,
+                    notify_enabled: bool = True, urgent_enabled: bool = False) -> Dict[str, Any]:
     """构建快捷操作菜单卡片（/menu 和 /list 共用）：内嵌会话列表 + 快捷操作"""
     elements = []
 
@@ -1251,6 +1252,55 @@ def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
         ]
     })
 
+    notify_label = "🔔 完成通知: 开" if notify_enabled else "🔕 完成通知: 关"
+    if not notify_enabled:
+        urgent_label = "🔇 加急通知: 关"
+        urgent_button: Dict[str, Any] = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "disabled": True,
+        }
+    elif urgent_enabled:
+        urgent_label = "🔔 加急通知: 开"
+        urgent_button = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_urgent"}}]
+        }
+    else:
+        urgent_label = "🔕 加急通知: 关"
+        urgent_button = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_urgent"}}]
+        }
+    elements.append({
+        "tag": "column_set",
+        "flex_mode": "none",
+        "columns": [
+            {
+                "tag": "column",
+                "width": "weighted",
+                "weight": 1,
+                "elements": [{
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": notify_label},
+                    "type": "default",
+                    "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_notify"}}]
+                }]
+            },
+            {
+                "tag": "column",
+                "width": "weighted",
+                "weight": 1,
+                "elements": [urgent_button]
+            },
+        ]
+    })
+
     return {
         "schema": "2.0",
         "config": {"wide_screen_mode": True},

package/lark_client/card_service.py

@@ -223,11 +223,69 @@ class CardService:
         _track_stats('error', 'card_api', detail='update_card')
         return False
 
-    async def send_text(self, chat_id: str, text: str):
-        """发送纯文本消息（备用）"""
+    async def send_urgent_app(self, message_id: str, user_ids: list) -> bool:
+        """对已有消息发送应用内加急通知，避免发新消息顶高流式卡片"""
+        if not self.client:
+            return False
+
+        import asyncio
+        from lark_oapi.api.im.v1 import UrgentAppMessageRequest, UrgentReceivers
+
+        try:
+            request = UrgentAppMessageRequest.builder() \
+                .message_id(message_id) \
+                .user_id_type("open_id") \
+                .request_body(
+                    UrgentReceivers.builder()
+                    .user_id_list(user_ids)
+                    .build()
+                ) \
+                .build()
+
+            response = await asyncio.to_thread(self.client.im.v1.message.urgent_app, request)
+            if response.success():
+                logger.info(f"加急通知成功: message_id={message_id}, users={user_ids}")
+                return True
+            else:
+                logger.warning(f"加急通知失败: code={response.code} msg={response.msg}")
+                return False
+        except Exception as e:
+            logger.error(f"加急通知异常: {e}")
+            return False
+
+    async def cancel_urgent_app(self, message_id: str, user_ids: list) -> bool:
+        """取消已有消息的应用内加急通知"""
+        if not self.client:
+            return False
+
+        import asyncio
+        from lark_oapi.core.model import BaseRequest
+        from lark_oapi.core.enum import HttpMethod, AccessTokenType
+
+        try:
+            request = BaseRequest()
+            request.http_method = HttpMethod.POST
+            request.uri = "/open-apis/im/v2/urgent/batch_cancel"
+            request.token_types = {AccessTokenType.TENANT}
+            request.queries = [("user_id_type", "open_id")]
+            request.body = {"message_id": message_id, "receiver_user_ids": user_ids}
+
+            response = await asyncio.to_thread(self.client.request, request)
+            if response.success():
+                logger.info(f"取消加急成功: message_id={message_id}, code={response.code}")
+                return True
+            else:
+                logger.warning(f"取消加急失败: code={response.code} msg={response.msg}")
+                return False
+        except Exception as e:
+            logger.error(f"取消加急异常: {e}")
+            return False
+
+    async def send_text(self, chat_id: str, text: str) -> Optional[str]:
+        """发送纯文本消息，返回 message_id（失败返回 None）"""
         if not self.client:
             print(f"[Lark] 消息: {text}")
-            return
+            return None
 
         try:
             import asyncio
@@ -247,10 +305,14 @@ class CardService:
                 self.client.im.v1.message.create, request
             )
 
-            if not response.success():
+            if response.success():
+                return getattr(getattr(response, "data", None), "message_id", None)
+            else:
                 logger.warning(f"发送文本失败: code={response.code} msg={response.msg}")
+                return None
         except Exception as e:
             logger.error(f"发送文本异常: {e}")
+            return None
 
     # 管理活跃卡片的方法
     def get_active_card(self, chat_id: str) -> Optional[CardState]:

package/lark_client/lark_handler.py

@@ -115,7 +115,8 @@ class LarkHandler:
 
     # ── 统一 attach / detach / on_disconnect ────────────────────────────────
 
-    async def _attach(self, chat_id: str, session_name: str) -> bool:
+    async def _attach(self, chat_id: str, session_name: str,
+                      user_id: Optional[str] = None) -> bool:
         """统一 attach 逻辑（私聊/群聊共用）"""
         # 在断开旧连接之前，先更新旧流式卡片为已断开状态
         old_session = self._chat_sessions.get(chat_id)
@@ -138,7 +139,8 @@ class LarkHandler:
         if await bridge.connect():
             self._bridges[chat_id] = bridge
             self._chat_sessions[chat_id] = session_name
-            self._poller.start(chat_id, session_name)
+            self._poller.start(chat_id, session_name, is_group=(chat_id in self._group_chat_ids),
+                               notify_user_id=user_id)
             _track_stats('lark', 'attach', session_name=session_name,
                          chat_id=chat_id)
             return True
@@ -244,7 +246,7 @@ class LarkHandler:
             )
             return
 
-        ok = await self._attach(chat_id, session_name)
+        ok = await self._attach(chat_id, session_name, user_id=user_id)
         if ok:
             self._chat_bindings[chat_id] = session_name
             self._save_chat_bindings()
@@ -374,7 +376,7 @@ class LarkHandler:
                 await card_service.send_text(chat_id, f"错误: 会话启动超时 (12s)\n\n{log_content}")
                 return
 
-            ok = await self._attach(chat_id, session_name)
+            ok = await self._attach(chat_id, session_name, user_id=user_id)
             if ok:
                 self._chat_bindings[chat_id] = session_name
                 self._save_chat_bindings()
@@ -603,9 +605,25 @@ class LarkHandler:
             for cid in self._group_chat_ids
             if cid in self._chat_bindings
         }
-        card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page)
+        card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page,
+                               notify_enabled=self._poller.get_notify_enabled(),
+                               urgent_enabled=self._poller.get_urgent_enabled())
         await self._send_or_update_card(chat_id, card, message_id)
 
+    async def _cmd_toggle_notify(self, user_id: str, chat_id: str,
+                                  message_id: Optional[str] = None):
+        """切换就绪通知开关并刷新菜单卡片"""
+        new_value = not self._poller.get_notify_enabled()
+        self._poller.set_notify_enabled(new_value)
+        await self._cmd_menu(user_id, chat_id, message_id=message_id)
+
+    async def _cmd_toggle_urgent(self, user_id: str, chat_id: str,
+                                  message_id: Optional[str] = None):
+        """切换加急通知开关并刷新菜单卡片"""
+        new_value = not self._poller.get_urgent_enabled()
+        self._poller.set_urgent_enabled(new_value)
+        await self._cmd_menu(user_id, chat_id, message_id=message_id)
+
     async def _cmd_ls(self, user_id: str, chat_id: str, args: str,
                        tree: bool = False, message_id: Optional[str] = None, page: int = 0):
         """查看目录文件结构"""
@@ -715,7 +733,7 @@ class LarkHandler:
             self._group_chat_ids.add(group_chat_id)
             self._save_group_chat_ids()
             # 立即 attach，让新群即刻开始接收 Claude 输出
-            await self._attach(group_chat_id, session_name)
+            await self._attach(group_chat_id, session_name, user_id=user_id)
 
             # 刷新会话列表卡片，使"创建群聊"按钮变为"进入群聊"
             await self._cmd_list(user_id, chat_id, message_id=message_id)
@@ -804,7 +822,7 @@ class LarkHandler:
             saved_session = self._chat_bindings.get(chat_id)
             if saved_session:
                 logger.info(f"自动恢复绑定: chat_id={chat_id[:8]}..., session={saved_session}")
-                ok = await self._attach(chat_id, saved_session)
+                ok = await self._attach(chat_id, saved_session, user_id=user_id)
                 if not ok:
                     self._group_chat_ids.discard(chat_id)
                     self._save_group_chat_ids()

package/lark_client/main.py

@@ -54,11 +54,12 @@ def _setup_logging():
     for _noisy in ('urllib3', 'websockets', 'asyncio'):
         logging.getLogger(_noisy).setLevel(logging.INFO)
 
-    # 控制台输出（仅重要消息，无调试信息）
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.INFO)
-    console_handler.setFormatter(formatter)
-    root_logger.addHandler(console_handler)
+    # 控制台输出（仅在终端交互模式下启用，守护进程模式下 stderr 已重定向到日志文件）
+    if sys.stderr.isatty():
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(formatter)
+        root_logger.addHandler(console_handler)
 
 
 # 在导入 lark SDK 之前配置日志
@@ -305,6 +306,14 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
             asyncio.create_task(_multi_send())
             return None
 
+        if action_type == "menu_toggle_notify":
+            asyncio.create_task(handler._cmd_toggle_notify(user_id, chat_id, message_id=message_id))
+            return None
+
+        if action_type == "menu_toggle_urgent":
+            asyncio.create_task(handler._cmd_toggle_urgent(user_id, chat_id, message_id=message_id))
+            return None
+
         # 各卡片底部菜单按钮：辅助卡片就地→菜单，流式卡片降级新卡
         if action_type == "menu_open":
             asyncio.create_task(handler._cmd_menu(user_id, chat_id, message_id=message_id))

package/lark_client/session_bridge.py

@@ -11,7 +11,6 @@ import sys
 from pathlib import Path
 from typing import Optional, Callable, Dict
 
-logging.basicConfig(level=logging.INFO, format='[%(name)s] %(message)s')
 logger = logging.getLogger('SessionBridge')
 
 sys.path.insert(0, str(Path(__file__).parent.parent))

package/lark_client/shared_memory_poller.py

@@ -35,6 +35,8 @@ try:
 except Exception:
     def _track_stats(*args, **kwargs): pass
 
+from utils.session import ensure_user_data_dir, USER_DATA_DIR
+
 # ── 常量 ──────────────────────────────────────────────────────────────────────
 INITIAL_WINDOW = 30    # 首次 attach 最多显示最近 30 个 blocks
 from .config import MAX_CARD_BLOCKS  # 单张卡片最多 N 个 blocks → 超限冻结（可通过 .env 配置）
@@ -62,6 +64,10 @@ class StreamTracker:
     cards: List[CardSlice] = field(default_factory=list)
     content_hash: str = ""
     reader: Optional[Any] = None  # SharedStateReader，延迟初始化
+    is_group: bool = False         # 是否为群聊
+    prev_is_ready: bool = True     # 上一帧是否就绪（初始 True 避免首次误触发）
+    notify_user_id: Optional[str] = None  # 就绪通知 @ 的用户 open_id
+    last_notify_message_id: Optional[str] = None  # 上一条就绪通知的 message_id（用于后续加急复用）
 
 
 # ── 轮询器 ────────────────────────────────────────────────────────────────────
@@ -81,11 +87,13 @@ class SharedMemoryPoller:
         self._kick_events: Dict[str, asyncio.Event] = {}  # chat_id → Event（唤醒轮询）
         self._rapid_until: Dict[str, float] = {}           # chat_id → 快速模式截止时间
 
-    def start(self, chat_id: str, session_name: str) -> None:
+    def start(self, chat_id: str, session_name: str, is_group: bool = False,
+              notify_user_id: Optional[str] = None) -> None:
         """attach 成功后调用：清空旧状态，启动轮询 Task"""
         self.stop(chat_id)
 
-        tracker = StreamTracker(chat_id=chat_id, session_name=session_name)
+        tracker = StreamTracker(chat_id=chat_id, session_name=session_name, is_group=is_group,
+                                notify_user_id=notify_user_id)
         self._trackers[chat_id] = tracker
         self._kick_events[chat_id] = asyncio.Event()
 
@@ -212,6 +220,9 @@ class SharedMemoryPoller:
         option_block = state.get("option_block")
         cli_type = state.get("cli_type", "claude")
 
+        # 就绪状态转换检测
+        await self._check_ready_notification(tracker, blocks, status_line, option_block, cli_type)
+
         # 获取活跃卡片（最后一张且未冻结）
         active = None
         if tracker.cards and not tracker.cards[-1].frozen:
@@ -415,6 +426,84 @@ class SharedMemoryPoller:
                 f"blocks={len(new_blocks)} card_id={new_card_id}"
             )
 
+    async def _check_ready_notification(
+        self, tracker: StreamTracker,
+        blocks: list, status_line: Optional[dict], option_block: Optional[dict],
+        cli_type: str = "claude"
+    ) -> None:
+        """检测就绪状态转换（忙碌→就绪），群聊中发送 @所有人 提醒"""
+        current_ready = _is_ready(blocks, status_line, option_block)
+        prev_ready = tracker.prev_is_ready
+        tracker.prev_is_ready = current_ready
+
+        if current_ready and not prev_ready and tracker.is_group and _notify_enabled:
+            count = _increment_ready_count()
+            uid = tracker.notify_user_id or "all"
+            cli_name = "Claude" if cli_type == "claude" else "Codex"
+            logger.info(f"就绪提醒: chat_id={tracker.chat_id[:8]}..., count={count}, uid={uid}, "
+                        f"last_msg={'有' if tracker.last_notify_message_id else '无'}")
+
+            if tracker.last_notify_message_id and uid != "all" and _urgent_enabled:
+                # 已有通知消息 + 加急开关开启 → 尝试加急
+                try:
+                    ok = await self._card_service.send_urgent_app(
+                        tracker.last_notify_message_id, [uid]
+                    )
+                    if ok:
+                        # 加急成功 → 15 秒后自动取消
+                        asyncio.create_task(self._cancel_urgent_later(
+                            tracker.last_notify_message_id, [uid], delay=5
+                        ))
+                    else:
+                        # 加急失败（权限未开通等）→ 降级发新消息
+                        label = ""
+                        text = f'<at user_id="{uid}">{label}</at> {cli_name} 已就绪，等待您的输入...（这是第{count}次通知）'
+                        msg_id = await self._card_service.send_text(tracker.chat_id, text)
+                        if msg_id:
+                            tracker.last_notify_message_id = msg_id
+                except Exception as e:
+                    logger.warning(f"加急通知失败: {e}")
+            else:
+                # 首次通知（或无法加急时）→ 发新消息，记录 message_id
+                label = "所有人" if uid == "all" else ""
+                text = f'<at user_id="{uid}">{label}</at> {cli_name} 已就绪，等待您的输入...（这是第{count}次通知）'
+                try:
+                    msg_id = await self._card_service.send_text(tracker.chat_id, text)
+                    if msg_id:
+                        tracker.last_notify_message_id = msg_id
+                except Exception as e:
+                    logger.warning(f"就绪提醒发送失败: {e}")
+
+    async def _cancel_urgent_later(self, message_id: str, user_ids: list, delay: float = 15) -> None:
+        """延迟取消加急通知"""
+        await asyncio.sleep(delay)
+        try:
+            await self._card_service.cancel_urgent_app(message_id, user_ids)
+        except Exception as e:
+            logger.warning(f"延迟取消加急失败: {e}")
+
+    def get_notify_enabled(self) -> bool:
+        """获取就绪通知开关状态"""
+        return _notify_enabled
+
+    def set_notify_enabled(self, enabled: bool) -> None:
+        """更新就绪通知开关状态并持久化"""
+        global _notify_enabled
+        _notify_enabled = enabled
+        _save_notify_enabled(enabled)
+        logger.info(f"就绪通知开关已{'开启' if enabled else '关闭'}")
+
+    def get_urgent_enabled(self) -> bool:
+        """获取加急通知开关状态"""
+        return _urgent_enabled
+
+    def set_urgent_enabled(self, enabled: bool) -> None:
+        """更新加急通知开关状态并持久化"""
+        global _urgent_enabled
+        _urgent_enabled = enabled
+        _save_urgent_enabled(enabled)
+        logger.info(f"加急通知开关已{'开启' if enabled else '关闭'}")
+
     @staticmethod
     def _compute_hash(
         blocks: list, status_line: Optional[dict],
@@ -432,3 +521,71 @@ class SharedMemoryPoller:
         return hashlib.md5(
             json.dumps(data, ensure_ascii=False, sort_keys=True).encode()
         ).hexdigest()
+
+
+# ── 模块级辅助函数 ────────────────────────────────────────────────────────────
+
+def _is_ready(blocks: list, status_line: Optional[dict], option_block: Optional[dict]) -> bool:
+    """数据层就绪判断：无 streaming block、无 status_line（option_block 不影响就绪）"""
+    has_streaming = any(b.get("is_streaming", False) for b in blocks)
+    return not has_streaming and status_line is None
+
+
+_READY_COUNT_FILE = USER_DATA_DIR / "ready_notify_count"
+_NOTIFY_ENABLED_FILE = USER_DATA_DIR / "ready_notify_enabled"
+_URGENT_ENABLED_FILE = USER_DATA_DIR / "urgent_notify_enabled"
+
+
+def _load_notify_enabled() -> bool:
+    """读取就绪通知开关状态，不存在或解析失败返回 True（默认开启）"""
+    try:
+        return _NOTIFY_ENABLED_FILE.read_text().strip() == "1"
+    except Exception:
+        return True
+
+
+def _save_notify_enabled(enabled: bool) -> None:
+    """持久化就绪通知开关状态"""
+    try:
+        ensure_user_data_dir()
+        _NOTIFY_ENABLED_FILE.write_text("1" if enabled else "0")
+    except Exception as e:
+        logger.warning(f"_save_notify_enabled 失败: {e}")
+
+
+def _load_urgent_enabled() -> bool:
+    """读取加急通知开关状态，不存在或解析失败返回 False（默认关闭）"""
+    try:
+        return _URGENT_ENABLED_FILE.read_text().strip() == "1"
+    except Exception:
+        return False
+
+
+def _save_urgent_enabled(enabled: bool) -> None:
+    """持久化加急通知开关状态"""
+    try:
+        ensure_user_data_dir()
+        _URGENT_ENABLED_FILE.write_text("1" if enabled else "0")
+    except Exception as e:
+        logger.warning(f"_save_urgent_enabled 失败: {e}")
+
+
+# 模块级开关状态：启动时加载一次
+_notify_enabled: bool = _load_notify_enabled()
+_urgent_enabled: bool = _load_urgent_enabled()
+
+
+def _increment_ready_count() -> int:
+    """原子递增全局就绪提醒计数器，返回新值（持久化到文件）"""
+    try:
+        ensure_user_data_dir()
+        try:
+            count = int(_READY_COUNT_FILE.read_text().strip())
+        except Exception:
+            count = 0
+        count += 1
+        _READY_COUNT_FILE.write_text(str(count))
+        return count
+    except Exception as e:
+        logger.warning(f"_increment_ready_count 失败: {e}")
+        return 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-claude",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "双端共享 Claude CLI 工具",
   "bin": {
     "remote-claude": "bin/remote-claude",

package/server/parsers/base_parser.py

@@ -5,7 +5,7 @@ ClaudeParser 和 CodexParser 均继承此类。
 """
 
 from abc import ABC, abstractmethod
-from typing import List
+from typing import Any, Dict, List
 
 import pyte
 
@@ -29,6 +29,9 @@ class BaseParser(ABC):
     last_input_ansi_text: str = ''
     last_parse_timing: str = ''
     last_layout_mode: str = 'normal'
+    # 诊断用：记录最近一次 parse 的区域统计与组件统计
+    last_region_stats: Dict[str, Any] = None
+    last_component_stats: Dict[str, Any] = None
 
     @abstractmethod
     def parse(self, screen: pyte.Screen) -> List:

package/server/parsers/claude_parser.py

@@ -909,22 +909,43 @@ class ClaudeParser(BaseParser):
         return None
 
     def _extract_input_area_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区 ❯ 提示符后的当前输入文本（空提示符返回空字符串）"""
-        for row in input_rows:
+        """提取输入区 ❯ 提示符后的当前输入文本（空提示符返回空字符串）。
+        多行输入时，收集 ❯ 行之后首列为空的续行，合并为完整文本。
+        """
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) == '❯':
                 text = _get_row_text(screen, row)[1:].strip()
                 # 排除纯分割线装饰行（如 ❯─────）
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return text
+                    # 收集续行（首列为空的非空文本行）
+                    lines = [text]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，遇到新 block 或新 ❯ 行，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(next_text)
+                    return '\n'.join(lines)
         return ''
 
     def _extract_input_area_ansi_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区 ❯ 提示符后的当前输入文本（ANSI 版本）"""
-        for row in input_rows:
+        """提取输入区 ❯ 提示符后的当前输入文本（ANSI 版本）。
+        多行输入时，收集 ❯ 行之后首列为空的续行，合并为完整文本。
+        """
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) == '❯':
                 text = _get_row_text(screen, row)[1:].strip()
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return _get_row_ansi_text(screen, row, start_col=1).strip()
+                    lines = [_get_row_ansi_text(screen, row, start_col=1).strip()]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(_get_row_ansi_text(screen, next_row).strip())
+                    return '\n'.join(lines)
         return ''
 
     def _parse_permission_area(