remote-claude 0.1.6 → 0.2.0

package/lark_client/card_builder.py

@@ -261,6 +261,7 @@ def _build_menu_button_row(session_name: Optional[str] = None, disconnected: boo
                 "width": "auto",
                 "elements": [{
                     "tag": "button",
+                    "name": "enter_submit",
                     "text": {"tag": "plain_text", "content": "Enter ↵"},
                     "type": "primary",
                     "action_type": "form_submit",
@@ -290,6 +291,7 @@ def _build_menu_button_row(session_name: Optional[str] = None, disconnected: boo
                 "width": "auto",
                 "elements": [{
                     "tag": "button",
+                    "name": "enter_submit",
                     "text": {"tag": "plain_text", "content": "Enter ↵"},
                     "type": "primary",
                     "action_type": "form_submit",
@@ -312,6 +314,7 @@ def _build_menu_button_row(session_name: Optional[str] = None, disconnected: boo
         ("Ctrl+O", {"action": "send_key", "key": "ctrl_o"}),
         ("Shift+Tab", {"action": "send_key", "key": "shift_tab"}),
         ("ESC", {"action": "send_key", "key": "esc"}),
+        ("(↹)×3", {"action": "send_key", "key": "shift_tab", "times": 3}),
     ]
 
     def _make_key_column(label, value):
@@ -773,58 +776,57 @@ def _build_session_list_elements(sessions: List[Dict], current_session: Optional
                 btn_label = "进入会话"
                 btn_type = "primary"
                 btn_action = "list_attach"
-            columns = [
-                {
-                    "tag": "column",
-                    "width": "weighted",
-                    "weight": 5,
-                    "elements": [{"tag": "markdown", "content": header_text}]
-                },
+            has_group = bool(session_groups and name in session_groups)
+
+            # 右列按钮（纵向堆叠）
+            right_buttons = [
                 {
-                    "tag": "column",
-                    "width": "weighted",
-                    "weight": 2,
-                    "elements": [{
-                        "tag": "button",
-                        "text": {"tag": "plain_text", "content": btn_label},
-                        "type": btn_type,
-                        "behaviors": [{"type": "callback", "value": {
-                            "action": btn_action, "session": name
-                        }}]
-                    }]
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": btn_label},
+                    "type": btn_type,
+                    "behaviors": [{"type": "callback", "value": {
+                        "action": btn_action, "session": name
+                    }}]
                 },
                 {
-                    "tag": "column",
-                    "width": "weighted",
-                    "weight": 2,
-                    "elements": [{
-                        "tag": "button",
-                        "text": {"tag": "plain_text", "content": "进入群聊" if (session_groups and name in session_groups) else "创建群聊"},
-                        "type": "default",
-                        "behaviors": [{"type": "open_url", "default_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[name]}"}]
-                        if (session_groups and name in session_groups) else
-                        [{"type": "callback", "value": {"action": "list_new_group", "session": name}}]
-                    }]
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": "进入群聊" if has_group else "创建群聊"},
+                    "type": "default",
+                    "behaviors": [{"type": "open_url",
+                                   "default_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[name]}",
+                                   "android_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[name]}",
+                                   "ios_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[name]}",
+                                   "pc_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[name]}"}]
+                    if has_group else
+                    [{"type": "callback", "value": {"action": "list_new_group", "session": name}}]
                 },
             ]
-            if session_groups and name in session_groups:
-                columns.append({
-                    "tag": "column",
-                    "width": "weighted",
-                    "weight": 2,
-                    "elements": [{
-                        "tag": "button",
-                        "text": {"tag": "plain_text", "content": "解散群聊"},
-                        "type": "danger",
-                        "behaviors": [{"type": "callback", "value": {
-                            "action": "list_disband_group", "session": name
-                        }}]
-                    }]
+            if has_group:
+                right_buttons.append({
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": "解散群聊"},
+                    "type": "danger",
+                    "behaviors": [{"type": "callback", "value": {
+                        "action": "list_disband_group", "session": name
+                    }}]
                 })
             elements.append({
                 "tag": "column_set",
                 "flex_mode": "none",
-                "columns": columns
+                "columns": [
+                    {
+                        "tag": "column",
+                        "width": "weighted",
+                        "weight": 3,
+                        "elements": [{"tag": "markdown", "content": header_text}]
+                    },
+                    {
+                        "tag": "column",
+                        "width": "weighted",
+                        "weight": 2,
+                        "elements": right_buttons
+                    },
+                ]
             })
             elements.append({"tag": "hr"})
 
@@ -872,7 +874,7 @@ def _dir_session_name(path: str) -> str:
     return name or "session"
 
 
-def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool = False, session_groups: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool = False, session_groups: Optional[Dict[str, str]] = None, page: int = 0) -> Dict[str, Any]:
     """构建目录浏览卡片
 
     顶层目录（depth==0）带两个操作按钮：
@@ -907,9 +909,17 @@ def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool
         })
         elements.append({"tag": "hr"})
 
-    cap = 20
+    PER_PAGE = 12
     total = len(entries)
-    shown = entries[:cap]
+    if tree:
+        # tree 模式不分页，直接展示全部（已有 max_items 上限）
+        shown = entries
+        page = 0
+        total_pages = 1
+    else:
+        total_pages = max(1, (total + PER_PAGE - 1) // PER_PAGE)
+        page = max(0, min(page, total_pages - 1))
+        shown = entries[page * PER_PAGE : (page + 1) * PER_PAGE]
 
     for entry in shown:
         name = entry["name"]
@@ -921,6 +931,22 @@ def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool
 
         if is_dir and depth == 0:
             auto_session = _dir_session_name(full_path)
+            group_btn = {
+                "tag": "button",
+                "text": {"tag": "plain_text", "content": "进入群聊" if (session_groups and auto_session in session_groups) else "创建群聊"},
+                "type": "default",
+                "behaviors": [{"type": "open_url",
+                               "default_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[auto_session]}",
+                               "android_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[auto_session]}",
+                               "ios_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[auto_session]}",
+                               "pc_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[auto_session]}"}]
+                if (session_groups and auto_session in session_groups) else
+                [{"type": "callback", "value": {
+                    "action": "dir_new_group",
+                    "path": full_path,
+                    "session_name": auto_session
+                }}]
+            }
             elements.append({
                 "tag": "column_set",
                 "flex_mode": "none",
@@ -928,61 +954,77 @@ def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool
                     {
                         "tag": "column",
                         "width": "weighted",
-                        "weight": 3,
-                        "elements": [{"tag": "markdown", "content": f"{icon} **{name}**"}]
-                    },
-                    {
-                        "tag": "column",
-                        "width": "weighted",
-                        "weight": 2,
+                        "weight": 4,
                         "elements": [{
-                            "tag": "button",
-                            "text": {"tag": "plain_text", "content": "📂 进入"},
-                            "type": "default",
+                            "tag": "interactive_container",
+                            "width": "fill",
+                            "height": "auto",
                             "behaviors": [{"type": "callback", "value": {
                                 "action": "dir_browse", "path": full_path
-                            }}]
+                            }}],
+                            "elements": [{"tag": "markdown", "content": f"📁 **{name}**"}]
                         }]
                     },
                     {
                         "tag": "column",
                         "width": "weighted",
                         "weight": 2,
-                        "elements": [{
-                            "tag": "button",
-                            "text": {"tag": "plain_text", "content": "🚀 在此启动"},
-                            "type": "primary",
-                            "behaviors": [{"type": "callback", "value": {
-                                "action": "dir_start",
-                                "path": full_path,
-                                "session_name": auto_session
-                            }}]
-                        }]
-                    },
-                    {
-                        "tag": "column",
-                        "width": "weighted",
-                        "weight": 2,
-                        "elements": [{
-                            "tag": "button",
-                            "text": {"tag": "plain_text", "content": "进入群聊" if (session_groups and auto_session in session_groups) else "创建群聊"},
-                            "type": "default",
-                            "behaviors": [{"type": "open_url", "default_url": f"https://applink.feishu.cn/client/chat/open?openChatId={session_groups[auto_session]}"}]
-                            if (session_groups and auto_session in session_groups) else
-                            [{"type": "callback", "value": {
-                                "action": "dir_new_group",
-                                "path": full_path,
-                                "session_name": auto_session
-                            }}]
-                        }]
+                        "elements": [
+                            {
+                                "tag": "button",
+                                "text": {"tag": "plain_text", "content": "Claude"},
+                                "type": "primary",
+                                "behaviors": [{"type": "callback", "value": {
+                                    "action": "dir_start",
+                                    "path": full_path,
+                                    "session_name": auto_session
+                                }}]
+                            },
+                            group_btn
+                        ]
                     }
                 ]
             })
+            elements.append({"tag": "hr"})
         else:
             elements.append({"tag": "markdown", "content": f"{indent}{icon} {name}"})
 
-    if total > cap:
-        elements.append({"tag": "markdown", "content": f"*...（共 {total} 项，仅显示前 {cap} 项）*"})
+    if not tree and total > PER_PAGE:
+        page_cols = []
+        if page > 0:
+            page_cols.append({
+                "tag": "column",
+                "width": "auto",
+                "elements": [{
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": "⬅️ 上一页"},
+                    "type": "default",
+                    "behaviors": [{"type": "callback", "value": {
+                        "action": "dir_page", "path": target_str, "page": page - 1
+                    }}]
+                }]
+            })
+        page_cols.append({
+            "tag": "column",
+            "width": "weighted",
+            "weight": 2,
+            "vertical_align": "center",
+            "elements": [{"tag": "markdown", "content": f"第 {page + 1}/{total_pages} 页"}]
+        })
+        if page < total_pages - 1:
+            page_cols.append({
+                "tag": "column",
+                "width": "auto",
+                "elements": [{
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": "下一页 ➡️"},
+                    "type": "default",
+                    "behaviors": [{"type": "callback", "value": {
+                        "action": "dir_page", "path": target_str, "page": page + 1
+                    }}]
+                }]
+            })
+        elements.append({"tag": "column_set", "flex_mode": "none", "columns": page_cols})
 
     elements.append({"tag": "hr"})
     elements.append(_build_menu_button_only())
@@ -1090,17 +1132,6 @@ def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
         "tag": "column_set",
         "flex_mode": "none",
         "columns": [
-            {
-                "tag": "column",
-                "width": "weighted",
-                "weight": 1,
-                "elements": [{
-                    "tag": "button",
-                    "text": {"tag": "plain_text", "content": "📖 帮助"},
-                    "type": "default",
-                    "behaviors": [{"type": "callback", "value": {"action": "menu_help"}}]
-                }]
-            },
             {
                 "tag": "column",
                 "width": "weighted",

package/lark_client/card_service.py

@@ -22,6 +22,23 @@ from lark_oapi.api.cardkit.v1 import (
 
 from . import config
 
+
+def _is_element_limit_error(msg: str) -> bool:
+    """判断飞书 API 返回的错误是否为元素超限"""
+    if not msg:
+        return False
+    lower = msg.lower()
+    return "element exceeds" in lower or "超限" in lower
+
+
+class _ElementLimitResult:
+    """元素超限的哨兵返回值，__bool__ 为 False 兼容现有 if not success 逻辑"""
+    is_element_limit = True
+
+    def __bool__(self):
+        return False
+
+
 import sys as _sys
 _sys.path.insert(0, str(__import__('pathlib').Path(__file__).parent.parent))
 try:
@@ -193,6 +210,10 @@ class CardService:
                     return True
                 else:
                     logger.warning(f"更新卡片失败(attempt={attempt+1}): card_id={card_id} seq={sequence} code={response.code} msg={response.msg}")
+                    if _is_element_limit_error(response.msg):
+                        # 元素超限是内容问题，重试无意义，直接返回哨兵值
+                        logger.warning(f"检测到元素超限错误，跳过重试: card_id={card_id}")
+                        return _ElementLimitResult()
             except Exception as e:
                 logger.error(f"更新卡片异常(attempt={attempt+1}): card_id={card_id} seq={sequence} error={e}")
 

package/lark_client/lark_handler.py

@@ -26,7 +26,6 @@ from .card_builder import (
     build_help_card,
     build_dir_card,
     build_menu_card,
-    build_session_closed_card,
 )
 from .shared_memory_poller import SharedMemoryPoller, CardSlice
 
@@ -92,11 +91,17 @@ class LarkHandler:
 
     async def _attach(self, chat_id: str, session_name: str) -> bool:
         """统一 attach 逻辑（私聊/群聊共用）"""
+        # 在断开旧连接之前，先更新旧流式卡片为已断开状态
+        old_session = self._chat_sessions.get(chat_id)
+        old_slice = self._poller.stop_and_get_active_slice(chat_id)
+        if old_slice and old_session:
+            await self._update_card_disconnected(chat_id, old_session, old_slice)
+
         # 断开旧 bridge
         old = self._bridges.pop(chat_id, None)
         if old:
             await old.disconnect()
-        self._poller.stop(chat_id)
+        # _poller.stop 已通过 stop_and_get_active_slice 完成
         self._chat_sessions.pop(chat_id, None)
         self._detached_slices.pop(chat_id, None)
 
@@ -132,19 +137,8 @@ class LarkHandler:
         self._detached_slices.pop(chat_id, None)
         self._remove_binding_by_chat(chat_id)
 
-        card = build_session_closed_card(session_name)
         if active_slice:
-            try:
-                success = await card_service.update_card(
-                    card_id=active_slice.card_id,
-                    sequence=active_slice.sequence + 1,
-                    card_content=card,
-                )
-                if success:
-                    return
-            except Exception as e:
-                logger.warning(f"_on_disconnect 就地更新失败: {e}")
-        await card_service.create_and_send_card(chat_id, card)
+            await self._update_card_disconnected(chat_id, session_name, active_slice)
 
     # ── 消息入口 ────────────────────────────────────────────────────────────
 
@@ -398,6 +392,9 @@ class LarkHandler:
         # 断开所有连接到此会话的 chat
         for cid, sname in list(self._chat_sessions.items()):
             if sname == session_name:
+                active_slice = self._poller.stop_and_get_active_slice(cid)
+                if active_slice:
+                    await self._update_card_disconnected(cid, sname, active_slice)
                 await self._detach(cid)
                 self._remove_binding_by_chat(cid)
 
@@ -410,10 +407,44 @@ class LarkHandler:
     async def _handle_list_detach(self, user_id: str, chat_id: str,
                                    message_id: Optional[str] = None):
         """会话列表卡片中断开连接，就地刷新列表"""
+        session_name = self._chat_sessions.get(chat_id, "")
+        # 更新流式卡片为已断开状态
+        active_slice = self._poller.stop_and_get_active_slice(chat_id)
+        if active_slice and session_name:
+            await self._update_card_disconnected(chat_id, session_name, active_slice)
+
         self._remove_binding_by_chat(chat_id)
-        await self._detach(chat_id)
+        await self._detach(chat_id)   # bridge.disconnect + _poller.stop（幂等）
         await self._cmd_list(user_id, chat_id, message_id=message_id)
 
+    async def _update_card_disconnected(self, chat_id: str, session_name: str,
+                                        active_slice: 'CardSlice') -> bool:
+        """读取最新 blocks 并就地更新卡片为断开状态（disconnected=True）。Best-effort，不降级发新卡。"""
+        blocks = []
+        try:
+            import sys as _sys
+            _sys.path.insert(0, str(Path(__file__).parent.parent / "server"))
+            from shared_state import SharedStateReader, get_mq_path
+            mq_path = get_mq_path(session_name)
+            if mq_path.exists():
+                reader = SharedStateReader(session_name)
+                state = reader.read()
+                reader.close()
+                blocks = state.get("blocks", [])
+        except Exception:
+            pass
+        blocks_slice = blocks[active_slice.start_idx:]
+        card = build_stream_card(blocks_slice, disconnected=True, session_name=session_name)
+        try:
+            return await card_service.update_card(
+                card_id=active_slice.card_id,
+                sequence=active_slice.sequence + 1,
+                card_content=card,
+            )
+        except Exception as e:
+            logger.warning(f"_update_card_disconnected 失败 ({chat_id[:8]}...): {e}")
+            return False
+
     async def _handle_stream_detach(self, user_id: str, chat_id: str,
                                      session_name: str, message_id: Optional[str] = None):
         """流式卡片中断开连接，就地更新卡片为已断开状态"""
@@ -500,7 +531,7 @@ class LarkHandler:
         await self._send_or_update_card(chat_id, card, message_id)
 
     async def _cmd_ls(self, user_id: str, chat_id: str, args: str,
-                       tree: bool = False, message_id: Optional[str] = None):
+                       tree: bool = False, message_id: Optional[str] = None, page: int = 0):
         """查看目录文件结构"""
         all_sessions = list_active_sessions()
         sessions_info = []
@@ -540,10 +571,11 @@ class LarkHandler:
             return
 
         session_groups = {sname: cid for cid, sname in self._chat_bindings.items() if cid.startswith("oc_")}
-        card = build_dir_card(target, entries, sessions_info, tree=tree, session_groups=session_groups)
+        card = build_dir_card(target, entries, sessions_info, tree=tree, session_groups=session_groups, page=page)
         await self._send_or_update_card(chat_id, card, message_id)
 
-    async def _cmd_new_group(self, user_id: str, chat_id: str, args: str):
+    async def _cmd_new_group(self, user_id: str, chat_id: str, args: str,
+                              message_id: Optional[str] = None):
         """创建专属群聊并绑定 Claude 会话"""
         session_name = args.strip()
         if not session_name:
@@ -606,6 +638,8 @@ class LarkHandler:
                 f"✅ 已创建专属群「【{dir_label}】{config.BOT_NAME}」并已连接\n"
                 f"在群内直接发消息即可与 Claude 交互"
             )
+            # 刷新会话列表卡片，使"创建群聊"按钮变为"进入群聊"
+            await self._cmd_list(user_id, chat_id, message_id=message_id)
         except Exception as e:
             logger.error(f"创建群失败: {e}")
             await card_service.send_text(chat_id, f"创建群失败：{e}")
@@ -623,6 +657,7 @@ class LarkHandler:
 
         import json as _json
         import urllib.request
+        import urllib.error
         from . import config
         try:
             token_resp = urllib.request.urlopen(
@@ -635,20 +670,39 @@ class LarkHandler:
             )
             token = _json.loads(token_resp.read())["tenant_access_token"]
 
-            disband_resp = urllib.request.urlopen(
-                urllib.request.Request(
-                    f"https://open.feishu.cn/open-apis/im/v1/chats/{group_chat_id}",
-                    headers={"Authorization": f"Bearer {token}"},
-                    method="DELETE"
-                ), timeout=10
-            )
-            disband_data = _json.loads(disband_resp.read())
-            if disband_data.get("code") != 0:
-                await card_service.send_text(chat_id, f"解散群失败：{disband_data.get('msg')}")
-                return
-
+            feishu_ok = False
+            feishu_msg = ""
+            try:
+                disband_resp = urllib.request.urlopen(
+                    urllib.request.Request(
+                        f"https://open.feishu.cn/open-apis/im/v1/chats/{group_chat_id}",
+                        headers={"Authorization": f"Bearer {token}"},
+                        method="DELETE"
+                    ), timeout=10
+                )
+                disband_data = _json.loads(disband_resp.read())
+                feishu_ok = disband_data.get("code") == 0
+                feishu_msg = disband_data.get("msg", "")
+            except urllib.error.HTTPError as e:
+                err_body = e.read().decode("utf-8", errors="replace")
+                try:
+                    err_data = _json.loads(err_body)
+                    feishu_ok = False
+                    feishu_msg = f"code={err_data.get('code')} {err_data.get('msg', '')}"
+                except Exception:
+                    feishu_ok = False
+                    feishu_msg = f"HTTP {e.code}"
+                logger.error(f"解散群 API 失败: {feishu_msg}")
+
+            # 无论 Feishu delete 是否成功，都清理本地绑定
             self._remove_binding_by_chat(group_chat_id)
             await self._detach(group_chat_id)
+
+            if feishu_ok:
+                notice = "✅ 群聊已解散，绑定已解除"
+            else:
+                notice = f"⚠️ Feishu 群解散失败（{feishu_msg}），已解除本地绑定。如需彻底解散请在飞书群内手动操作"
+            await card_service.send_text(chat_id, notice)
             await self._cmd_list(user_id, chat_id, message_id=message_id)
         except Exception as e:
             logger.error(f"解散群失败: {e}")
@@ -800,7 +854,7 @@ class LarkHandler:
                 })
         except PermissionError:
             pass
-        return entries[:30]
+        return entries
 
     @staticmethod
     def _collect_tree_entries(target, max_depth: int = 2, max_items: int = 60) -> list:
@@ -830,6 +884,15 @@ class LarkHandler:
         _walk(target, 0)
         return entries
 
+    async def disconnect_all_for_shutdown(self) -> None:
+        """lark stop 时清理所有活跃流式卡片（更新为已断开状态）"""
+        chat_ids = list(self._bridges.keys())
+        for chat_id in chat_ids:
+            session_name = self._chat_sessions.get(chat_id, "")
+            active_slice = self._poller.stop_and_get_active_slice(chat_id)
+            if active_slice and session_name:
+                await self._update_card_disconnected(chat_id, session_name, active_slice)
+
     @staticmethod
     def _get_pid_cwd(pid: int) -> Optional[str]:
         """获取进程的工作目录（macOS/Linux）"""

package/lark_client/main.py

@@ -30,6 +30,17 @@ from lark_oapi.event.callback.model.p2_card_action_trigger import (
 from . import config
 from .lark_handler import handler
 
+
+async def _graceful_shutdown() -> None:
+    """优雅关闭：更新所有活跃流式卡片为已断开状态后退出"""
+    try:
+        await handler.disconnect_all_for_shutdown()
+    except Exception as e:
+        print(f"[Lark] graceful shutdown 异常: {e}")
+    finally:
+        import os
+        os._exit(0)
+
 def check_user_allowed(user_id: str) -> bool:
     """检查用户是否在白名单中"""
     if not config.ENABLE_USER_WHITELIST:
@@ -148,7 +159,7 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
         if action_type == "list_new_group":
             session_name = action_value.get("session", "")
             print(f"[Lark] list_new_group: session={session_name}")
-            asyncio.create_task(handler._cmd_new_group(user_id, chat_id, session_name))
+            asyncio.create_task(handler._cmd_new_group(user_id, chat_id, session_name, message_id=message_id))
             return None
 
         # 列表卡片：解散群聊
@@ -165,6 +176,14 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
             asyncio.create_task(handler._cmd_ls(user_id, chat_id, path, message_id=message_id))
             return None
 
+        # 目录卡片：翻页
+        if action_type == "dir_page":
+            path = action_value.get("path", "")
+            page = int(action_value.get("page", 0))
+            print(f"[Lark] dir_page: path={path}, page={page}")
+            asyncio.create_task(handler._cmd_ls(user_id, chat_id, path, message_id=message_id, page=page))
+            return None
+
         # 目录卡片：在该目录创建新 Claude 会话
         if action_type == "dir_start":
             path = action_value.get("path", "")
@@ -219,8 +238,13 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
         # 快捷键按钮（callback 模式）
         if action_type == "send_key":
             key_name = action_value.get("key", "")
-            print(f"[Lark] send_key: key={key_name}")
-            asyncio.create_task(handler.send_raw_key(user_id, chat_id, key_name))
+            times = action_value.get("times", 1)
+            print(f"[Lark] send_key: key={key_name}" + (f" ×{times}" if times > 1 else ""))
+            async def _multi_send(k=key_name, t=times):
+                for _ in range(t):
+                    await handler.send_raw_key(user_id, chat_id, k)
+                    await asyncio.sleep(0.15)
+            asyncio.create_task(_multi_send())
             return None
 
         # 各卡片底部菜单按钮：辅助卡片就地→菜单，流式卡片降级新卡
@@ -288,12 +312,20 @@ class LarkBot:
         self.ws_client.start()
 
     def _signal_handler(self, signum, frame):
-        """处理退出信号"""
+        """处理退出信号（SIGTERM / SIGINT）"""
         print("\n正在关闭...")
         self.running = False
-        if self.ws_client:
-            # WebSocket 客户端没有 stop 方法，直接退出
-            sys.exit(0)
+        # 调度异步清理（更新所有活跃卡片为已断开状态后退出）
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                loop.call_soon_threadsafe(
+                    lambda: asyncio.ensure_future(_graceful_shutdown())
+                )
+                return
+        except Exception:
+            pass
+        sys.exit(0)
 
 
 def main():

package/lark_client/shared_memory_poller.py

@@ -247,7 +247,13 @@ class SharedMemoryPoller:
                 card_content=card_dict,
             )
 
-            if not success:
+            if getattr(success, 'is_element_limit', False):
+                # 元素超限：冻结旧卡 + 推新流式卡
+                await self._handle_element_limit(
+                    tracker, blocks, status_line, bottom_bar, agent_panel, option_block
+                )
+                return
+            elif not success:
                 # 降级：创建新卡片替代
                 logger.warning(
                     f"update_card 失败 card_id={active.card_id} seq={active.sequence}，降级为新卡片"
@@ -305,6 +311,48 @@ class SharedMemoryPoller:
         else:
             logger.warning(f"create_card 失败 session={tracker.session_name}")
 
+    async def _handle_element_limit(
+        self, tracker: StreamTracker, blocks: List[dict],
+        status_line: Optional[dict], bottom_bar: Optional[dict],
+        agent_panel: Optional[dict] = None,
+        option_block: Optional[dict] = None,
+    ) -> None:
+        """元素超限：冻结旧卡片 + 推送新流式卡片"""
+        active = tracker.cards[-1]
+        logger.warning(f"元素超限，冻结卡片 {active.card_id} 并推新卡")
+
+        # 1. 冻结旧卡片（灰色 header，无状态区和按钮）
+        from .card_builder import build_stream_card
+        blocks_slice = blocks[active.start_idx:]
+        frozen_card = build_stream_card(blocks_slice, None, None, is_frozen=True)
+        active.sequence += 1
+        await self._card_service.update_card(active.card_id, active.sequence, frozen_card)
+        active.frozen = True
+        _track_stats('card', 'freeze', session_name=tracker.session_name,
+                     chat_id=tracker.chat_id)
+
+        # 2. 创建新流式卡片，从最近 INITIAL_WINDOW 个 blocks 开始（重置窗口）
+        new_start = max(0, len(blocks) - INITIAL_WINDOW)
+        new_blocks = blocks[new_start:]
+        if not new_blocks and not status_line and not bottom_bar:
+            return
+        new_card_dict = build_stream_card(
+            new_blocks, status_line, bottom_bar,
+            agent_panel=agent_panel, option_block=option_block,
+            session_name=tracker.session_name,
+        )
+        new_card_id = await self._card_service.create_card(new_card_dict)
+        if new_card_id:
+            await self._card_service.send_card(tracker.chat_id, new_card_id)
+            tracker.cards.append(CardSlice(card_id=new_card_id, start_idx=new_start))
+            tracker.content_hash = self._compute_hash(new_blocks, status_line, bottom_bar, agent_panel, option_block)
+            _track_stats('card', 'create', session_name=tracker.session_name,
+                         chat_id=tracker.chat_id)
+            logger.info(
+                f"[ELEMENT_LIMIT_SPLIT] session={tracker.session_name} "
+                f"new_start={new_start} blocks={len(new_blocks)} card_id={new_card_id}"
+            )
+
     async def _freeze_and_split(
         self, tracker: StreamTracker, blocks: List[dict],
         status_line: Optional[dict], bottom_bar: Optional[dict],

package/package.json

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

package/server/server.py

@@ -624,22 +624,22 @@ class ProxyServer:
             raise
 
         if pid == 0:
-            # 子进程：恢复调用方 shell 的完整环境变量
-            for k, v in _extra_env.items():
-                os.environ[k] = v
-            # 环境已加载到内存，立即删除快照文件（execvp 前销毁）
+            # 环境已加载到内存，立即删除快照文件（exec 前销毁）
             try:
                 env_snapshot_path.unlink()
             except Exception:
                 pass
+            # 以快照为权威来源完整替换子进程环境，确保 unset 的变量也消失
+            # 若 snapshot 加载失败（_extra_env 为空），降级使用当前进程环境
+            child_env = dict(_extra_env) if _extra_env else dict(os.environ)
             # 恢复 TERM 以支持 kitty keyboard protocol（Shift+Enter 等扩展键）
             # tmux 会将 TERM 改为 tmux-256color，导致 Claude CLI 不启用 kitty protocol
-            os.environ['TERM'] = 'xterm-256color'
+            child_env['TERM'] = 'xterm-256color'
             # 清除 tmux 标识变量（PTY 数据不经过 tmux，不应让 Claude CLI 误判终端环境）
-            for key in ('TMUX', 'TMUX_PANE'):
-                os.environ.pop(key, None)
-            os.execvp("claude", ["claude"] + self.claude_args)
-            os._exit(1)  # execvp 失败时兜底退出
+            child_env.pop('TMUX', None)
+            child_env.pop('TMUX_PANE', None)
+            os.execvpe("claude", ["claude"] + self.claude_args, child_env)
+            os._exit(1)  # execvpe 失败时兜底退出
         else:
             # 父进程
             self.master_fd = fd