remote-claude 0.2.7 → 0.2.9

package/.env.example

@@ -18,3 +18,7 @@ ALLOWED_USERS=ou_xxxxx,ou_yyyyy
 # 支持多词命令，如：ccr code、/usr/local/bin/claude
 # CLAUDE_COMMAND=claude
 
+# 流式卡片配置（可选）
+# 单张卡片最多显示的 block 数量，超限自动冻结并创建新卡片（默认 50）
+# MAX_CARD_BLOCKS=50
+

package/init.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-set -e
-
 # 颜色定义
 RED=$'\033[0;31m'
 GREEN=$'\033[0;32m'
@@ -128,7 +126,7 @@ check_uv() {
     # 方式五：brew（macOS 备用）
     if ! command -v uv &> /dev/null && [[ "$OS" == "Darwin" ]] && command -v brew &> /dev/null; then
         print_warning "尝试 brew install uv..."
-        brew install uv
+        brew install uv 2>/dev/null || true
     fi
 
     if command -v uv &> /dev/null; then
@@ -181,18 +179,18 @@ check_tmux() {
                 fi
                 print_success "Homebrew 安装成功"
             fi
-            brew install tmux
+            brew install tmux 2>/dev/null || true
         elif [[ "$OS" == "Linux" ]]; then
             if command -v apt-get &> /dev/null; then
-                sudo apt-get update && sudo apt-get install -y tmux
+                sudo apt-get update && sudo apt-get install -y tmux || true
             elif command -v yum &> /dev/null; then
-                sudo yum install -y tmux
+                sudo yum install -y tmux || true
             elif command -v pacman &> /dev/null; then
-                sudo pacman -Sy --noconfirm tmux
+                sudo pacman -Sy --noconfirm tmux || true
             elif command -v apk &> /dev/null; then
-                sudo apk add --no-cache tmux
+                sudo apk add --no-cache tmux || true
             elif command -v zypper &> /dev/null; then
-                sudo zypper install -y tmux
+                sudo zypper install -y tmux || true
             else
                 print_warning "无法识别包管理器，尝试从源码编译 tmux..."
                 install_tmux_from_source
@@ -212,10 +210,10 @@ check_tmux() {
         if [[ "$OS" == "Darwin" ]]; then
             brew install libevent ncurses pkg-config bison 2>/dev/null || true
         elif command -v apt-get &> /dev/null; then
-            sudo apt-get install -y build-essential libevent-dev libncurses5-dev libncursesw5-dev bison pkg-config
+            sudo apt-get install -y build-essential libevent-dev libncurses5-dev libncursesw5-dev bison pkg-config || true
         elif command -v yum &> /dev/null; then
-            sudo yum groupinstall -y "Development Tools"
-            sudo yum install -y libevent-devel ncurses-devel bison
+            sudo yum groupinstall -y "Development Tools" || true
+            sudo yum install -y libevent-devel ncurses-devel bison || true
         fi
 
         # 确定安装前缀
@@ -249,9 +247,9 @@ check_tmux() {
         fi
 
         if [[ "$PREFIX" == "/usr/local" ]]; then
-            sudo make -C "$SRC_DIR" install
+            sudo make -C "$SRC_DIR" install || { WARNINGS+=("tmux make install 失败，请手动安装 tmux ${REQUIRED_MAJOR}.${REQUIRED_MINOR}+"); return; }
         else
-            make -C "$SRC_DIR" install
+            make -C "$SRC_DIR" install || { WARNINGS+=("tmux make install 失败，请手动安装 tmux ${REQUIRED_MAJOR}.${REQUIRED_MINOR}+"); return; }
             # 若 $HOME/.local/bin 不在 PATH 中，自动写入 shell 配置
             if [[ ":$PATH:" != *":$HOME/.local/bin:"* ]]; then
                 export PATH="$HOME/.local/bin:$PATH"
@@ -363,9 +361,9 @@ install_dependencies() {
 
     print_info "正在通过 uv 同步依赖..."
     if $NPM_MODE; then
-        uv sync --frozen
+        uv sync || { print_error "依赖安装失败"; exit 1; }
     else
-        uv sync
+        uv sync || { print_error "依赖安装失败"; exit 1; }
     fi
 
     print_success "依赖安装完成"
@@ -451,7 +449,7 @@ configure_shell() {
     print_header "安装快捷命令"
 
     SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-    chmod +x "$SCRIPT_DIR/bin/cla" "$SCRIPT_DIR/bin/cl" "$SCRIPT_DIR/bin/remote-claude"
+    chmod +x "$SCRIPT_DIR/bin/cla" "$SCRIPT_DIR/bin/cl" "$SCRIPT_DIR/bin/remote-claude" 2>/dev/null || true
 
     # 优先 /usr/local/bin，权限不够则选 ~/bin 或 ~/.local/bin 中已在 PATH 里的
     BIN_DIR="/usr/local/bin"
@@ -479,12 +477,12 @@ configure_shell() {
             fi
         fi
         mkdir -p "$BIN_DIR"
-        ln -sf "$SCRIPT_DIR/bin/cla"          "$BIN_DIR/cla"
-        ln -sf "$SCRIPT_DIR/bin/cl"           "$BIN_DIR/cl"
-        ln -sf "$SCRIPT_DIR/bin/remote-claude" "$BIN_DIR/remote-claude"
+        ln -sf "$SCRIPT_DIR/bin/cla"           "$BIN_DIR/cla"          2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/cl"            "$BIN_DIR/cl"           2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/remote-claude" "$BIN_DIR/remote-claude" 2>/dev/null || true
     else
-        ln -sf "$SCRIPT_DIR/bin/cl"           "$BIN_DIR/cl"
-        ln -sf "$SCRIPT_DIR/bin/remote-claude" "$BIN_DIR/remote-claude"
+        ln -sf "$SCRIPT_DIR/bin/cl"            "$BIN_DIR/cl"           2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/remote-claude" "$BIN_DIR/remote-claude" 2>/dev/null || true
     fi
 
     print_success "已安装 cla、cl 和 remote-claude 到 $BIN_DIR"
@@ -525,7 +523,7 @@ restart_lark_client() {
     SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
     print_info "正在重启飞书客户端..."
     cd "$SCRIPT_DIR"
-    uv run python3 remote_claude.py lark restart
+    uv run python3 remote_claude.py lark restart || { WARNINGS+=("飞书客户端重启失败，请手动运行: uv run python3 remote_claude.py lark restart"); return; }
     print_success "飞书客户端已重启"
 }
 

package/lark_client/card_builder.py

@@ -17,6 +17,12 @@ from typing import Dict, Any, List, Optional
 
 _cb_logger = logging.getLogger('CardBuilder')
 
+# CLI 类型 → 显示名称映射（用于卡片标题中的"就绪"文案）
+CLI_NAMES: Dict[str, str] = {
+    "claude": "Claude",
+    "codex": "Codex",
+}
+
 # 版本号：从 package.json 读取，import 时只读一次
 try:
     _pkg = _pl.Path(__file__).parent.parent / "package.json"
@@ -539,6 +545,17 @@ def _render_block_colored(block_dict: dict) -> Optional[str]:
             parts.append("🔐 权限确认")
         return "\n".join(parts)
 
+    elif typ == "SystemBlock":
+        content = block_dict.get("content", "")
+        if not content:
+            return None
+        ansi_content = block_dict.get("ansi_content", "")
+        ansi_ind = block_dict.get("ansi_indicator", "")
+        indicator = block_dict.get("indicator", "✻")
+        ind_md = _ansi_to_lark_md(ansi_ind) if ansi_ind else _escape_md(indicator)
+        content_md = _ansi_to_lark_md(ansi_content) if ansi_content else _escape_md(content)
+        return f"{ind_md} {content_md}"
+
     return None
 
 
@@ -565,6 +582,7 @@ def _determine_header(
     is_frozen: bool,
     option_block: Optional[dict] = None,
     disconnected: bool = False,
+    cli_type: str = "claude",
 ) -> tuple:
     """确定卡片标题和颜色模板，返回 (title, template)"""
     if disconnected:
@@ -601,7 +619,8 @@ def _determine_header(
             return "🔐 等待权限确认", "red"
         return "🤔 等待选择", "blue"
 
-    return "✅ Claude 就绪", "green"
+    cli_name = CLI_NAMES.get(cli_type, "Claude")
+    return f"✅ {cli_name} 就绪", "green"
 
 
 def _extract_buttons(blocks: List[dict], option_block: Optional[dict] = None) -> List[Dict[str, str]]:
@@ -626,6 +645,7 @@ def build_stream_card(
     option_block: Optional[dict] = None,
     session_name: Optional[str] = None,
     disconnected: bool = False,
+    cli_type: str = "claude",
 ) -> Dict[str, Any]:
     """从共享内存 blocks 流构建飞书卡片
 
@@ -637,7 +657,8 @@ def build_stream_card(
     """
     title, template = _determine_header(
         blocks, status_line, bottom_bar, is_frozen,
-        option_block=option_block, disconnected=disconnected
+        option_block=option_block, disconnected=disconnected,
+        cli_type=cli_type,
     )
 
     # === 第一层：内容区 ===
@@ -749,12 +770,17 @@ def build_stream_card(
 
 # === 辅助卡片（保留不变）===
 
-def _build_session_list_elements(sessions: List[Dict], current_session: Optional[str], session_groups: Optional[Dict[str, str]]) -> List[Dict]:
+def _build_session_list_elements(sessions: List[Dict], current_session: Optional[str], session_groups: Optional[Dict[str, str]], page: int = 0) -> List[Dict]:
     """构建会话列表元素（供 build_menu_card 复用）"""
     import os
     elements = []
     if sessions:
-        for s in sessions:
+        PER_PAGE = 8
+        total = len(sessions)
+        total_pages = max(1, (total + PER_PAGE - 1) // PER_PAGE)
+        page = max(0, min(page, total_pages - 1))
+        shown = sessions[page * PER_PAGE : (page + 1) * PER_PAGE]
+        for s in shown:
             name = s["name"]
             cwd = s.get("cwd", "")
             start_time = s.get("start_time", "")
@@ -824,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",
@@ -846,6 +884,41 @@ def _build_session_list_elements(sessions: List[Dict], current_session: Optional
 
         if elements and elements[-1].get("tag") == "hr":
             elements.pop()
+
+        if total > PER_PAGE:
+            prev_disabled = page == 0
+            next_disabled = page >= total_pages - 1
+            prev_btn = {
+                "tag": "button",
+                "text": {"tag": "plain_text", "content": "⬅ 上一页"},
+                "type": "default",
+                **({"disabled": True} if prev_disabled else {"behaviors": [{"type": "callback", "value": {
+                    "action": "menu_page", "page": page - 1
+                }}]})
+            }
+            next_btn = {
+                "tag": "button",
+                "text": {"tag": "plain_text", "content": "下一页 ➡"},
+                "type": "default",
+                **({"disabled": True} if next_disabled else {"behaviors": [{"type": "callback", "value": {
+                    "action": "menu_page", "page": page + 1
+                }}]})
+            }
+            elements.append({"tag": "hr"})
+            elements.append({
+                "tag": "column_set",
+                "flex_mode": "none",
+                "horizontal_spacing": "small",
+                "columns": [
+                    {"tag": "column", "width": "weighted", "weight": 1, "elements": [{"tag": "markdown", "content": " "}]},
+                    {"tag": "column", "width": "auto", "elements": [prev_btn]},
+                    {"tag": "column", "width": "auto", "vertical_align": "center", "elements": [
+                        {"tag": "markdown", "content": f"第 {page + 1}/{total_pages} 页"}
+                    ]},
+                    {"tag": "column", "width": "auto", "elements": [next_btn]},
+                    {"tag": "column", "width": "weighted", "weight": 1, "elements": [{"tag": "markdown", "content": " "}]},
+                ]
+            })
     else:
         elements.append({
             "tag": "markdown",
@@ -1001,41 +1074,38 @@ def build_dir_card(target, entries: List[Dict], sessions: List[Dict], tree: bool
             elements.append({"tag": "markdown", "content": f"{indent}{icon} {name}"})
 
     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} 页"}]
+        prev_disabled = page == 0
+        next_disabled = page >= total_pages - 1
+        prev_btn = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": "⬅ 上一页"},
+            "type": "default",
+            **({"disabled": True} if prev_disabled else {"behaviors": [{"type": "callback", "value": {
+                "action": "dir_page", "path": target_str, "page": page - 1
+            }}]})
+        }
+        next_btn = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": "下一页 ➡"},
+            "type": "default",
+            **({"disabled": True} if next_disabled else {"behaviors": [{"type": "callback", "value": {
+                "action": "dir_page", "path": target_str, "page": page + 1
+            }}]})
+        }
+        elements.append({
+            "tag": "column_set",
+            "flex_mode": "none",
+            "horizontal_spacing": "small",
+            "columns": [
+                {"tag": "column", "width": "weighted", "weight": 1, "elements": [{"tag": "markdown", "content": " "}]},
+                {"tag": "column", "width": "auto", "elements": [prev_btn]},
+                {"tag": "column", "width": "auto", "vertical_align": "center", "elements": [
+                    {"tag": "markdown", "content": f"第 {page + 1}/{total_pages} 页"}
+                ]},
+                {"tag": "column", "width": "auto", "elements": [next_btn]},
+                {"tag": "column", "width": "weighted", "weight": 1, "elements": [{"tag": "markdown", "content": " "}]},
+            ]
         })
-        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())
@@ -1124,12 +1194,13 @@ 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) -> Dict[str, Any]:
+                    session_groups: Optional[Dict[str, str]] = None, page: int = 0) -> Dict[str, Any]:
     """构建快捷操作菜单卡片（/menu 和 /list 共用）：内嵌会话列表 + 快捷操作"""
     elements = []
 
     elements.append({"tag": "markdown", "content": "**会话管理**"})
-    elements.extend(_build_session_list_elements(sessions, current_session, session_groups))
+    elements.append({"tag": "hr"})
+    elements.extend(_build_session_list_elements(sessions, current_session, session_groups, page=page))
 
     elements.append({"tag": "hr"})
     elements.append({"tag": "markdown", "content": "**快捷操作**"})
@@ -1159,6 +1230,17 @@ def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
                     "behaviors": [{"type": "callback", "value": {"action": "menu_tree"}}]
                 }]
             },
+            {
+                "tag": "column",
+                "width": "weighted",
+                "weight": 1,
+                "elements": [{
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": "🔄 刷新"},
+                    "type": "default",
+                    "behaviors": [{"type": "callback", "value": {"action": "menu_open"}}]
+                }]
+            },
         ]
     })
 

package/lark_client/config.py

@@ -35,3 +35,6 @@ BOT_NAME = os.getenv("BOT_NAME", "Claude")
 
 # 群聊名称前缀（格式：{GROUP_NAME_PREFIX}{dir}-{HH-MM}）
 GROUP_NAME_PREFIX = os.getenv("GROUP_NAME_PREFIX", "【Remote-Claude】")
+
+# 流式卡片配置
+MAX_CARD_BLOCKS = int(os.getenv("MAX_CARD_BLOCKS", "50"))

package/lark_client/lark_handler.py

@@ -103,7 +103,13 @@ class LarkHandler:
         except Exception as e:
             logger.warning(f"保存群聊 ID 失败: {e}")
 
-    def _remove_binding_by_chat(self, chat_id: str):
+    def _remove_binding_by_chat(self, chat_id: str, force: bool = False):
+        """移除 chat_id 的绑定。
+        群聊绑定默认不移除（避免断开后无法解散群）；
+        force=True 时强制移除（用于会话终止/解散群场景）。
+        """
+        if not force and chat_id in self._group_chat_ids:
+            return
         self._chat_bindings.pop(chat_id, None)
         self._save_chat_bindings()
 
@@ -395,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
 
@@ -409,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:
@@ -416,13 +430,21 @@ class LarkHandler:
                 if active_slice:
                     await self._update_card_disconnected(cid, sname, active_slice)
                 await self._detach(cid)
-                self._remove_binding_by_chat(cid)
+                self._remove_binding_by_chat(cid, force=True)
+
+        # 清理所有残留绑定（包括已断开的群聊，其绑定在断开时被保留）
+        for cid in [c for c, s in list(self._chat_bindings.items()) if s == session_name]:
+            self._group_chat_ids.discard(cid)
+            self._chat_bindings.pop(cid, None)
+        self._save_chat_bindings()
+        self._save_group_chat_ids()
 
         if tmux_session_exists(session_name):
             tmux_kill_session(session_name)
         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):
@@ -542,7 +564,7 @@ class LarkHandler:
         await self._send_or_update_card(chat_id, card, message_id)
 
     async def _cmd_menu(self, user_id: str, chat_id: str,
-                         message_id: Optional[str] = None):
+                         message_id: Optional[str] = None, page: int = 0):
         """显示快捷操作菜单（内嵌会话列表）"""
         sessions = list_active_sessions()
         current = self._chat_sessions.get(chat_id)
@@ -551,7 +573,7 @@ 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)
+        card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page)
         await self._send_or_update_card(chat_id, card, message_id)
 
     async def _cmd_ls(self, user_id: str, chat_id: str, args: str,
@@ -665,28 +687,14 @@ class LarkHandler:
             # 立即 attach，让新群即刻开始接收 Claude 输出
             await self._attach(group_chat_id, session_name)
 
-            await card_service.send_text(
-                chat_id,
-                f"✅ 已创建专属群「{group_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}")
 
-    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
@@ -701,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(
@@ -713,30 +718,46 @@ 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 是否成功，都清理本地绑定
-            self._remove_binding_by_chat(group_chat_id)
             self._group_chat_ids.discard(group_chat_id)
             self._save_group_chat_ids()
+            self._remove_binding_by_chat(group_chat_id, force=True)
             await self._detach(group_chat_id)
 
-            if feishu_ok:
-                notice = "✅ 群聊已解散，绑定已解除"
-            else:
-                notice = f"⚠️ Feishu 群解散失败（{feishu_msg}），已解除本地绑定。如需彻底解散请在飞书群内手动操作"
-            await card_service.send_text(chat_id, notice)
+            if not feishu_ok:
+                await card_service.send_text(
+                    chat_id,
+                    f"⚠️ Feishu 群解散失败（{feishu_msg}），已解除本地绑定。如需彻底解散请在飞书群内手动操作"
+                )
             await self._cmd_list(user_id, chat_id, message_id=message_id)
         except Exception as e:
             logger.error(f"解散群失败: {e}")
@@ -755,7 +776,9 @@ class LarkHandler:
                 logger.info(f"自动恢复绑定: chat_id={chat_id[:8]}..., session={saved_session}")
                 ok = await self._attach(chat_id, saved_session)
                 if not ok:
-                    self._remove_binding_by_chat(chat_id)
+                    self._group_chat_ids.discard(chat_id)
+                    self._save_group_chat_ids()
+                    self._remove_binding_by_chat(chat_id, force=True)
                     await card_service.send_text(
                         chat_id, f"会话 '{saved_session}' 已不存在，请重新 /attach"
                     )

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", "")
@@ -176,6 +183,13 @@ 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 == "menu_page":
+            page = int(action_value.get("page", 0))
+            print(f"[Lark] menu_page: page={page}")
+            asyncio.create_task(handler._cmd_menu(user_id, chat_id, message_id=message_id, page=page))
+            return None
+
         # 目录卡片：翻页
         if action_type == "dir_page":
             path = action_value.get("path", "")