remote-claude 0.2.8 → 0.2.9

package/lark_client/card_builder.py

@@ -850,6 +850,18 @@ def _build_session_list_elements(sessions: List[Dict], current_session: Optional
                         "action": "list_disband_group", "session": name
                     }}]
                 })
+            right_buttons.append({
+                "tag": "button",
+                "text": {"tag": "plain_text", "content": "🗑️ 关闭"},
+                "type": "danger",
+                "confirm": {
+                    "title": {"tag": "plain_text", "content": "确认关闭会话"},
+                    "text": {"tag": "plain_text", "content": f"确定要关闭「{name}」吗？此操作不可撤销。"}
+                },
+                "behaviors": [{"type": "callback", "value": {
+                    "action": "list_kill", "session": name
+                }}]
+            })
             elements.append({
                 "tag": "column_set",
                 "flex_mode": "none",

package/lark_client/lark_handler.py

@@ -401,7 +401,8 @@ class LarkHandler:
             logger.error(f"启动并创建群聊失败: {e}")
             await card_service.send_text(chat_id, f"操作失败：{e}")
 
-    async def _cmd_kill(self, user_id: str, chat_id: str, args: str):
+    async def _cmd_kill(self, user_id: str, chat_id: str, args: str,
+                        message_id: Optional[str] = None):
         """终止会话"""
         from utils.session import cleanup_session, tmux_session_exists, tmux_kill_session
 
@@ -415,6 +416,13 @@ class LarkHandler:
             await card_service.send_text(chat_id, f"错误: 会话 '{session_name}' 不存在")
             return
 
+        # 解散绑定该会话的专属群聊（必须在断开连接之前，否则 _chat_bindings 已被清除）
+        for cid in list(self._group_chat_ids):
+            if self._chat_bindings.get(cid) == session_name:
+                ok, err = await self._disband_group_via_api(cid)
+                if not ok:
+                    logger.warning(f"关闭会话时解散群 {cid} 失败: {err}")
+
         # 断开所有连接到此会话的 chat
         for cid, sname in list(self._chat_sessions.items()):
             if sname == session_name:
@@ -436,6 +444,7 @@ class LarkHandler:
         cleanup_session(session_name)
 
         await card_service.send_text(chat_id, f"✅ 会话 '{session_name}' 已终止")
+        await self._cmd_list(user_id, chat_id, message_id=message_id)
 
     async def _handle_list_detach(self, user_id: str, chat_id: str,
                                    message_id: Optional[str] = None):
@@ -684,17 +693,8 @@ class LarkHandler:
             logger.error(f"创建群失败: {e}")
             await card_service.send_text(chat_id, f"创建群失败：{e}")
 
-    async def _cmd_disband_group(self, user_id: str, chat_id: str, session_name: str,
-                                  message_id: Optional[str] = None):
-        """解散与指定会话绑定的专属群聊"""
-        group_chat_id = next(
-            (cid for cid, sname in self._chat_bindings.items() if sname == session_name and cid.startswith("oc_")),
-            None
-        )
-        if not group_chat_id:
-            await card_service.send_text(chat_id, f"会话 '{session_name}' 没有绑定群聊")
-            return
-
+    async def _disband_group_via_api(self, group_chat_id: str) -> tuple:
+        """调用飞书 API 解散群聊，返回 (ok: bool, err_msg: str)"""
         import json as _json
         import urllib.request
         import urllib.error
@@ -709,9 +709,6 @@ class LarkHandler:
                 ), timeout=10
             )
             token = _json.loads(token_resp.read())["tenant_access_token"]
-
-            feishu_ok = False
-            feishu_msg = ""
             try:
                 disband_resp = urllib.request.urlopen(
                     urllib.request.Request(
@@ -721,17 +718,33 @@ class LarkHandler:
                     ), timeout=10
                 )
                 disband_data = _json.loads(disband_resp.read())
-                feishu_ok = disband_data.get("code") == 0
-                feishu_msg = disband_data.get("msg", "")
+                if disband_data.get("code") == 0:
+                    return True, ""
+                return False, 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', '')}"
+                    return False, f"code={err_data.get('code')} {err_data.get('msg', '')}"
                 except Exception:
-                    feishu_ok = False
-                    feishu_msg = f"HTTP {e.code}"
+                    return False, f"HTTP {e.code}"
+        except Exception as e:
+            return False, str(e)
+
+    async def _cmd_disband_group(self, user_id: str, chat_id: str, session_name: str,
+                                  message_id: Optional[str] = None):
+        """解散与指定会话绑定的专属群聊"""
+        group_chat_id = next(
+            (cid for cid, sname in self._chat_bindings.items() if sname == session_name and cid.startswith("oc_")),
+            None
+        )
+        if not group_chat_id:
+            await card_service.send_text(chat_id, f"会话 '{session_name}' 没有绑定群聊")
+            return
+
+        try:
+            feishu_ok, feishu_msg = await self._disband_group_via_api(group_chat_id)
+            if not feishu_ok:
                 logger.error(f"解散群 API 失败: {feishu_msg}")
 
             # 无论 Feishu delete 是否成功，都清理本地绑定

package/lark_client/main.py

@@ -169,6 +169,13 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
             asyncio.create_task(handler._cmd_disband_group(user_id, chat_id, session_name, message_id=message_id))
             return None
 
+        # 列表卡片：关闭会话
+        if action_type == "list_kill":
+            session_name = action_value.get("session", "")
+            print(f"[Lark] list_kill: session={session_name}")
+            asyncio.create_task(handler._cmd_kill(user_id, chat_id, session_name, message_id=message_id))
+            return None
+
         # 目录卡片：进入子目录（继续浏览，就地更新原卡片）
         if action_type == "dir_browse":
             path = action_value.get("path", "")

package/package.json

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

package/server/server.py

@@ -708,21 +708,34 @@ class ProxyServer:
             cli_label = self.cli_type.capitalize()
             print(f"[Server] {cli_label} 已启动 (PID: {pid}, PTY: {self.PTY_COLS}×{self.PTY_ROWS})")
 
+    _COALESCE_MAX = 64 * 1024  # 64KB，防止单次广播过大
+
     async def _read_pty(self):
         """读取 PTY 输出并广播"""
         loop = asyncio.get_event_loop()
 
         while self.running and self.master_fd is not None:
             try:
-                # 使用 asyncio 读取
+                # 第一次 read（在线程池中，可能阻塞等待数据）
                 data = await loop.run_in_executor(
                     None, self._read_pty_sync
                 )
                 if data:
+                    # 贪婪合并：非阻塞读取紧接数据，合并为一次广播
+                    buf = bytearray(data)
+                    while len(buf) < self._COALESCE_MAX:
+                        try:
+                            more = os.read(self.master_fd, 4096)
+                            if not more:
+                                break
+                            buf.extend(more)
+                        except (BlockingIOError, OSError):
+                            break
+                    coalesced = bytes(buf)
                     # 保存到历史
-                    self.history.append(data)
+                    self.history.append(coalesced)
                     # 广播给所有客户端
-                    await self._broadcast_output(data)
+                    await self._broadcast_output(coalesced)
                 elif data is None:
                     # 暂时无数据（BlockingIOError），稍等继续
                     await asyncio.sleep(0.01)