remote-claude 1.0.2 → 1.0.4

package/lark_client/lark_handler.py

@@ -11,8 +11,11 @@
 import asyncio
 import json
 import logging
+import os as _os
 import subprocess
 import sys
+import time
+from datetime import datetime as _datetime
 from pathlib import Path
 from typing import Optional, Dict, Any, List
 
@@ -30,7 +33,23 @@ from .card_builder import (
 from .shared_memory_poller import SharedMemoryPoller, CardSlice
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
-from utils.session import list_active_sessions, get_socket_path, get_chat_bindings_file, ensure_user_data_dir
+from utils.session import list_active_sessions, get_socket_path, get_chat_bindings_file, ensure_user_data_dir, USER_DATA_DIR
+
+
+def _read_log_since(since: '_datetime', log_path: 'Path') -> str:
+    """读取 startup.log 中 since 时间点之后的日志行"""
+    if not log_path.exists():
+        return ""
+    lines = []
+    for line in log_path.read_text(encoding="utf-8", errors="replace").splitlines():
+        try:
+            ts = _datetime.strptime(line[:23], "%Y-%m-%d %H:%M:%S.%f")
+            if ts >= since:
+                lines.append(line)
+        except ValueError:
+            if lines:
+                lines.append(line)
+    return "\n".join(lines)
 
 try:
     from stats import track as _track_stats
@@ -66,6 +85,8 @@ class LarkHandler:
         self._group_chat_ids: set = self._load_group_chat_ids()
         # chat_id → CardSlice（用户主动断开后保留，供重连时冻结旧卡片）
         self._detached_slices: Dict[str, CardSlice] = {}
+        # 正在启动中的会话名集合（防止并发点击触发竞态）
+        self._starting_sessions: set = set()
 
     # ── 持久化绑定 ──────────────────────────────────────────────────────────
 
@@ -168,6 +189,9 @@ class LarkHandler:
         if active_slice:
             await self._update_card_disconnected(chat_id, session_name, active_slice)
 
+        # 会话退出时自动解散绑定到该会话的所有专属群聊
+        await self._disband_groups_for_session(session_name, source="disconnect")
+
     # ── 消息入口 ────────────────────────────────────────────────────────────
 
     async def handle_message(self, user_id: str, chat_id: str, text: str,
@@ -225,6 +249,8 @@ class LarkHandler:
             await self._cmd_help(user_id, chat_id)
         elif command == "/menu":
             await self._cmd_menu(user_id, chat_id)
+        elif command == "/press":
+            await self._cmd_press(user_id, chat_id, args)
         else:
             await card_service.send_text(chat_id, f"未知命令: {command}\n使用 /help 查看帮助")
 
@@ -282,7 +308,7 @@ class LarkHandler:
         if card_id:
             await card_service.send_card(chat_id, card_id)
 
-    async def _cmd_start(self, user_id: str, chat_id: str, args: str):
+    async def _cmd_start(self, user_id: str, chat_id: str, args: str, cli_type: str = "claude"):
         """启动新会话"""
         parts = args.strip().split(maxsplit=1)
         if not parts:
@@ -316,47 +342,41 @@ class LarkHandler:
             )
             return
 
+        if session_name in self._starting_sessions:
+            await card_service.send_text(chat_id, f"会话 '{session_name}' 正在启动中，请稍候")
+            return
+        self._starting_sessions.add(session_name)
+
         script_dir = Path(__file__).parent.parent.absolute()
         server_script = script_dir / "server" / "server.py"
-        cmd = [sys.executable, str(server_script), session_name]
+        cmd = ["uv", "run", "--project", str(script_dir), "python3", str(server_script), session_name]
+        if cli_type == "codex":
+            cmd += ["--cli-type", "codex"]
         if self._poller.get_bypass_enabled():
-            cmd += ["--", "--dangerously-skip-permissions", "--permission-mode=dontAsk"]
+            if cli_type == "codex":
+                cmd += ["--", "--dangerously-bypass-approvals-and-sandbox"]
+            else:
+                cmd += ["--", "--dangerously-skip-permissions", "--permission-mode=dontAsk"]
 
-        logger.info(f"启动会话: {session_name}, 工作目录: {work_dir}, 命令: {' '.join(cmd)}")
+        logger.info(f"启动会话: {session_name}, 工作目录: {work_dir}, cli_type: {cli_type}, 命令: {' '.join(cmd)}")
         _track_stats('lark', 'cmd_start', session_name=session_name, chat_id=chat_id)
 
         try:
-            import os as _os
-            from datetime import datetime as _datetime
             env = _os.environ.copy()
             env.pop("CLAUDECODE", None)
 
-            from utils.session import USER_DATA_DIR
             log_path = USER_DATA_DIR / "startup.log"
             start_time = _datetime.now()
 
-            proc = subprocess.Popen(
-                cmd,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                start_new_session=True,
-                cwd=work_dir,
-                env=env,
-            )
-
-            def _read_log_since(since):
-                if not log_path.exists():
-                    return ""
-                lines = []
-                for line in log_path.read_text(encoding="utf-8").splitlines():
-                    try:
-                        ts = _datetime.strptime(line[:23], "%Y-%m-%d %H:%M:%S.%f")
-                        if ts >= since:
-                            lines.append(line)
-                    except ValueError:
-                        if lines:
-                            lines.append(line)
-                return "\n".join(lines)
+            with open(log_path, 'a') as stderr_fd:
+                proc = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=stderr_fd,
+                    start_new_session=True,
+                    cwd=work_dir,
+                    env=env,
+                )
 
             socket_path = get_socket_path(session_name)
             for i in range(120):
@@ -367,13 +387,13 @@ class LarkHandler:
                     elapsed = (i + 1) // 10
                     rc = proc.poll()
                     if rc is not None:
-                        log_content = _read_log_since(start_time)
+                        log_content = _read_log_since(start_time, log_path)
                         logger.warning(f"会话启动失败: server 进程已退出 (exitcode={rc}, elapsed={elapsed}s)\n{log_content}")
                         await card_service.send_text(chat_id, f"错误: Server 进程意外退出 (code={rc})\n\n{log_content}")
                         return
                     logger.info(f"等待 server socket... ({elapsed}s)")
             else:
-                log_content = _read_log_since(start_time)
+                log_content = _read_log_since(start_time, log_path)
                 logger.error(f"会话启动超时 (12s), session={session_name}\n{log_content}")
                 await card_service.send_text(chat_id, f"错误: 会话启动超时 (12s)\n\n{log_content}")
                 return
@@ -391,44 +411,66 @@ class LarkHandler:
         except Exception as e:
             logger.error(f"启动会话失败: {e}")
             await card_service.send_text(chat_id, f"错误: 启动失败 - {e}")
+        finally:
+            self._starting_sessions.discard(session_name)
 
     async def _cmd_start_and_new_group(self, user_id: str, chat_id: str,
-                                       session_name: str, path: str):
+                                       session_name: str, path: str, cli_type: str = "claude"):
         """在指定目录启动会话并创建专属群聊"""
-        sessions = list_active_sessions()
-        if any(s["name"] == session_name for s in sessions):
-            # 会话已存在，直接创建群聊
-            await self._cmd_new_group(user_id, chat_id, session_name)
-            return
-
         work_path = Path(path).expanduser()
         if not work_path.is_dir():
             await card_service.send_text(chat_id, f"错误: 路径无效: {path}")
             return
 
+        sessions = list_active_sessions()
+        active_names = {s["name"] for s in sessions}
+        if session_name in active_names or session_name in self._starting_sessions:
+            session_name = f"{session_name}_{_datetime.now().strftime('%m%d_%H%M%S')}"
+
+        self._starting_sessions.add(session_name)
+
         work_dir = str(work_path.absolute())
         script_dir = Path(__file__).parent.parent.absolute()
         server_script = script_dir / "server" / "server.py"
-        cmd = [sys.executable, str(server_script), session_name]
+        cmd = ["uv", "run", "--project", str(script_dir), "python3", str(server_script), session_name]
+        if cli_type == "codex":
+            cmd += ["--cli-type", "codex"]
         if self._poller.get_bypass_enabled():
-            cmd += ["--", "--dangerously-skip-permissions", "--permission-mode=dontAsk"]
+            if cli_type == "codex":
+                cmd += ["--", "--dangerously-bypass-approvals-and-sandbox"]
+            else:
+                cmd += ["--", "--dangerously-skip-permissions", "--permission-mode=dontAsk"]
 
         try:
-            import os as _os
             env = _os.environ.copy()
             env.pop("CLAUDECODE", None)
-            subprocess.Popen(
-                cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-                start_new_session=True, cwd=work_dir, env=env,
-            )
+
+            log_path = USER_DATA_DIR / "startup.log"
+            start_time = _datetime.now()
+
+            with open(log_path, 'a') as stderr_fd:
+                proc = subprocess.Popen(
+                    cmd, stdout=subprocess.DEVNULL, stderr=stderr_fd,
+                    start_new_session=True, cwd=work_dir, env=env,
+                )
 
             socket_path = get_socket_path(session_name)
-            for _ in range(120):
+            for i in range(120):
                 await asyncio.sleep(0.1)
                 if socket_path.exists():
                     break
+                if (i + 1) % 10 == 0:
+                    elapsed = (i + 1) // 10
+                    rc = proc.poll()
+                    if rc is not None:
+                        log_content = _read_log_since(start_time, log_path)
+                        logger.warning(f"启动并创建群聊失败: server 进程已退出 (exitcode={rc}, elapsed={elapsed}s)\n{log_content}")
+                        await card_service.send_text(chat_id, f"错误: Server 进程意外退出 (code={rc})\n\n{log_content}")
+                        return
             else:
-                await card_service.send_text(chat_id, "错误: 会话启动超时")
+                log_content = _read_log_since(start_time, log_path)
+                logger.error(f"启动并创建群聊超时 (12s), session={session_name}\n{log_content}")
+                await card_service.send_text(chat_id, f"错误: 会话启动超时 (12s)\n\n{log_content}")
                 return
 
             await self._cmd_new_group(user_id, chat_id, session_name)
@@ -436,6 +478,8 @@ class LarkHandler:
         except Exception as e:
             logger.error(f"启动并创建群聊失败: {e}")
             await card_service.send_text(chat_id, f"操作失败：{e}")
+        finally:
+            self._starting_sessions.discard(session_name)
 
     async def _cmd_kill(self, user_id: str, chat_id: str, args: str,
                         message_id: Optional[str] = None):
@@ -700,7 +744,8 @@ class LarkHandler:
         session = next((s for s in sessions if s["name"] == session_name), None)
         pid = session.get("pid") if session else None
         cwd = self._get_pid_cwd(pid) if pid else None
-        dir_label = cwd.rstrip("/").rsplit("/", 1)[-1] if cwd else session_name
+        from .card_builder import _get_display_name
+        dir_label = _get_display_name(session_name, cwd)
 
         from . import config
         try:
@@ -791,6 +836,32 @@ class LarkHandler:
         except Exception as e:
             return False, str(e)
 
+    async def _disband_groups_for_session(self, session_name: str, source: str = ""):
+        """解散绑定到指定会话的所有专属群聊"""
+        disbanded = []
+        for cid in list(self._group_chat_ids):
+            if self._chat_bindings.get(cid) == session_name:
+                log_prefix = f"[{source}] " if source else ""
+                logger.info(f"{log_prefix}自动解散群聊: chat_id={cid[:8]}..., session={session_name}")
+                # 先清理本地状态（防止并发协程重入时重复处理）
+                self._group_chat_ids.discard(cid)
+                self._chat_bindings.pop(cid, None)
+                disbanded.append(cid)
+                # 停止轮询 + 断开 bridge
+                self._poller.stop(cid)
+                bridge = self._bridges.pop(cid, None)
+                if bridge:
+                    await bridge.disconnect()
+                self._chat_sessions.pop(cid, None)
+                self._detached_slices.pop(cid, None)
+                # 调用飞书 API 解散
+                ok, err = await self._disband_group_via_api(cid)
+                if not ok:
+                    logger.warning(f"{log_prefix}解散群 {cid[:8]}... API 失败: {err}")
+        if disbanded:
+            self._save_chat_bindings()
+            self._save_group_chat_ids()
+
     async def _cmd_disband_group(self, user_id: str, chat_id: str, session_name: str,
                                   message_id: Optional[str] = None):
         """解散与指定会话绑定的专属群聊"""
@@ -842,6 +913,8 @@ class LarkHandler:
                     await card_service.send_text(
                         chat_id, f"会话 '{saved_session}' 已不存在，请重新 /attach"
                     )
+                    # 会话已不存在，解散绑定到该会话的所有专属群聊
+                    await self._disband_groups_for_session(saved_session, source="lazy")
                     return
                 bridge = self._bridges.get(chat_id)
             else:
@@ -861,12 +934,11 @@ class LarkHandler:
 
     # ── 选项处理 ─────────────────────────────────────────────────────────────
 
-    async def handle_option_select(self, user_id: str, chat_id: str, option_value: str, option_total: int = 0):
-        """处理用户选择的选项（按钮点击）
+    async def handle_option_select(self, user_id: str, chat_id: str, option_value: str, option_total: int = 0, *, needs_input: bool = False):
+        """闭环选项选择：箭头键导航 + 共享内存验证
 
-        最后一个选项特殊处理：Claude CLI 的光标选择模式中，最后一个选项
-        直接发数字键无效。改为先发倒数第二项的数字跳转，再发 ↓ 移到最后一项，
-        最后发 Enter 确认。
+        发箭头键导航到目标选项，每步从共享内存读取 selected_value 确认是否到位，
+        到位后发 Enter 确认。避免数字键在溢出选项上无效的问题。
         """
         logger.info(f"处理选项选择: user={user_id[:8]}..., option={option_value}, total={option_total}")
         _track_stats('lark', 'option_select',
@@ -878,39 +950,200 @@ class LarkHandler:
             await card_service.send_text(chat_id, "未连接到任何会话，请先使用 /attach <会话名> 连接")
             return
 
-        key_mapping = {
-            "yes": "y",
-            "no": "n",
-            "allow_once": "y",
-            "allow_always": "a",
-            "deny": "n",
+        target = option_value  # 目标选项 value（如 "2"）
+        max_steps = max(option_total, 10) if option_total > 0 else 10
+
+        # 记录初始 option_block 的 block_id，防止跨选项交互误操作
+        initial_snapshot = self._poller.read_snapshot(chat_id)
+        if not initial_snapshot:
+            return
+        initial_ob = initial_snapshot.get('option_block')
+        if not initial_ob:
+            return
+        initial_block_id = initial_ob.get('block_id', '')
+
+        for step in range(max_steps):
+            # 1. 读取当前选中项
+            snapshot = self._poller.read_snapshot(chat_id)
+            if not snapshot:
+                break
+            ob = snapshot.get('option_block')
+            if not ob:
+                break  # option_block 已消失（CLI 已进入下一状态）
+
+            # 检查 block_id 一致性
+            if initial_block_id and ob.get('block_id', '') != initial_block_id:
+                logger.warning(f"option_block 已切换，中止选项选择")
+                break
+
+            current = ob.get('selected_value', '')
+
+            # 闪烁帧重试：❯ 光标字符会时隐时现，selected_value 为空时短暂重试
+            if not current:
+                for _retry in range(5):  # 最多重试 5 次，共 500ms
+                    await asyncio.sleep(0.1)
+                    snap = self._poller.read_snapshot(chat_id)
+                    if not snap:
+                        break
+                    retry_ob = snap.get('option_block')
+                    if not retry_ob:
+                        break
+                    current = retry_ob.get('selected_value', '')
+                    if current:
+                        break
+
+            # 2. 已到位 → 发 Enter（自由输入选项只导航不发 Enter）
+            if current == target:
+                if needs_input:
+                    logger.info(f"自由输入选项已到位: target={target}，不发送 Enter")
+                    self._poller.kick(chat_id)
+                    return
+                logger.info(f"选项已到位: current={current} == target={target}，发送 Enter")
+                success = await bridge.send_raw(b"\r")
+                if success:
+                    self._poller.kick(chat_id)
+                else:
+                    await card_service.send_text(chat_id, "发送选择失败")
+                return
+
+            # 3. 未到位 → 发箭头键
+            if current and target:
+                try:
+                    if int(current) < int(target):
+                        logger.info(f"步骤{step}: current={current} < target={target}，发送 ↓")
+                        await bridge.send_raw(b"\x1b[B")  # ↓
+                    else:
+                        logger.info(f"步骤{step}: current={current} > target={target}，发送 ↑")
+                        await bridge.send_raw(b"\x1b[A")  # ↑
+                except ValueError:
+                    logger.warning(f"步骤{step}: 无法比较 current={current!r} 和 target={target!r}，发送 ↓")
+                    await bridge.send_raw(b"\x1b[B")
+            else:
+                # selected_value 重试后仍为空（真正的初始状态），默认向下
+                logger.info(f"步骤{step}: selected_value 重试后仍为空，发送 ↓")
+                await bridge.send_raw(b"\x1b[B")
+
+            # 4. 等待共享内存更新（轮询直到 selected_value 变为另一个非空值或超时）
+            old_selected = current
+            deadline = time.time() + 2.0  # 单步超时 2s
+            while time.time() < deadline:
+                await asyncio.sleep(0.1)  # 100ms 轮询
+                snap = self._poller.read_snapshot(chat_id)
+                if not snap:
+                    break
+                new_ob = snap.get('option_block')
+                if not new_ob:
+                    break  # option_block 消失，退出
+                if initial_block_id and new_ob.get('block_id', '') != initial_block_id:
+                    break  # block_id 变了，外层会处理
+                new_selected = new_ob.get('selected_value', '')
+                # 忽略闪烁帧：只有变为另一个非空值才视为真正变化
+                if new_selected and new_selected != old_selected:
+                    break
+
+        # 超过 max_steps 仍未到位，记录警告
+        logger.warning(f"选项选择超步数: target={target}, steps={max_steps}")
+
+    # ── 快捷键发送 ─────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _parse_key_combo(combo: str) -> Optional[bytes]:
+        """将用户输入的按键字符串解析为终端转义序列字节，解析失败返回 None"""
+        BASE_KEY_MAP = {
+            "up":       b"\x1b[A",
+            "down":     b"\x1b[B",
+            "right":    b"\x1b[C",
+            "left":     b"\x1b[D",
+            "enter":    b"\r",
+            "esc":      b"\x1b",
+            "tab":      b"\t",
+            "backspace": b"\x7f",
+            "delete":   b"\x1b[3~",
+            "space":    b" ",
+            "home":     b"\x1b[H",
+            "end":      b"\x1b[F",
+            "pageup":   b"\x1b[5~",
+            "pagedown": b"\x1b[6~",
+            "f1":  b"\x1bOP",   "f2":  b"\x1bOQ",  "f3":  b"\x1bOR",  "f4":  b"\x1bOS",
+            "f5":  b"\x1b[15~", "f6":  b"\x1b[17~","f7":  b"\x1b[18~","f8":  b"\x1b[19~",
+            "f9":  b"\x1b[20~", "f10": b"\x1b[21~","f11": b"\x1b[23~","f12": b"\x1b[24~",
         }
-        key_to_send = key_mapping.get(option_value.lower())
-
-        if key_to_send:
-            # 固定映射的选项（permission 类型）
-            logger.info(f"发送按键到 Claude: {key_to_send}")
-            success = await bridge.send_key(key_to_send)
-        elif option_total > 1 and option_value == str(option_total):
-            # 最后一个选项：发 (N-1) 次 ↓ → Enter
-            import asyncio
-            steps = option_total - 1
-            logger.info(f"最后一个选项，发送: {steps}次↓ → Enter")
-            for _ in range(steps):
-                await bridge.send_raw(b"\x1b[B")  # ↓ 箭头
-                await asyncio.sleep(0.05)
-            success = await bridge.send_raw(b"\r")
-        else:
-            # 普通数字选项
-            logger.info(f"发送按键到 Claude: {option_value}")
-            success = await bridge.send_key(option_value)
 
+        s = combo.strip().lower()
+        parts = [p.strip() for p in s.split("+")]
+
+        mods = set()
+        keys = []
+        for p in parts:
+            if p in ("ctrl", "alt", "shift"):
+                mods.add(p)
+            else:
+                keys.append(p)
+
+        if len(keys) != 1:
+            return None
+        key = keys[0]
+
+        # ctrl+letter → \x01-\x1a
+        if mods == {"ctrl"}:
+            if len(key) == 1 and 'a' <= key <= 'z':
+                return bytes([ord(key) - ord('a') + 1])
+            # ctrl+[ = ESC, ctrl+\ = FS 等特殊控制字符
+            ctrl_special = {'[': b'\x1b', '\\': b'\x1c', ']': b'\x1d', '^': b'\x1e', '_': b'\x1f'}
+            if key in ctrl_special:
+                return ctrl_special[key]
+            return None
+
+        # alt+key → ESC prefix
+        if mods == {"alt"}:
+            base = BASE_KEY_MAP.get(key)
+            if base:
+                return b"\x1b" + base
+            if len(key) == 1:
+                return b"\x1b" + key.encode()
+            return None
+
+        # shift+tab / shift+enter
+        if mods == {"shift"}:
+            if key == "tab":
+                return b"\x1b[Z"
+            if key == "enter":
+                return b"\x1b[13;2u"
+            return None
+
+        # 无修饰键
+        if not mods:
+            return BASE_KEY_MAP.get(key)
+
+        return None
+
+    async def _cmd_press(self, user_id: str, chat_id: str, args: str):
+        """发送任意按键组合到会话"""
+        combo = args.strip()
+        if not combo:
+            await card_service.send_text(
+                chat_id,
+                "用法：`/press <按键>`\n"
+                "例如：`/press ctrl+c`、`/press esc`、`/press ctrl+f`、`/press alt+x`\n"
+                "支持：ctrl/alt/shift 修饰键，方向键 up/down/left/right，enter/esc/tab/backspace/delete/space/home/end/pageup/pagedown/f1-f12"
+            )
+            return
+
+        raw = LarkHandler._parse_key_combo(combo)
+        if raw is None:
+            await card_service.send_text(chat_id, f"❌ 无法解析按键：`{combo}`\n使用 `/press` 查看支持的按键格式")
+            return
+
+        bridge = self._bridges.get(chat_id)
+        if not bridge or not bridge.running:
+            await card_service.send_text(chat_id, "❌ 当前未连接到会话，请先使用 /attach 连接")
+            return
+
+        success = await bridge.send_raw(raw)
         if success:
-            self._poller.kick(chat_id)
+            logger.info(f"[press] 发送按键 {combo!r} ({raw!r}) 到会话")
         else:
-            await card_service.send_text(chat_id, "发送选择失败")
-
-    # ── 快捷键发送 ─────────────────────────────────────────────────────────────
+            await card_service.send_text(chat_id, f"❌ 发送按键 `{combo}` 失败")
 
     async def send_raw_key(self, user_id: str, chat_id: str, key_name: str):
         """发送原始控制键到 Claude CLI"""

package/lark_client/main.py

@@ -8,8 +8,10 @@ Remote Claude 飞书客户端
 import asyncio
 import json
 import logging
+import os
 import signal
 import sys
+import urllib.request
 from pathlib import Path
 
 
@@ -183,8 +185,9 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
         if action_type == "select_option":
             option_value = action_value.get("value", "")
             option_total = int(action_value.get("total", "0"))
-            print(f"[Lark] 用户选择了选项: {option_value} (total={option_total})")
-            asyncio.create_task(handler.handle_option_select(user_id, chat_id, option_value, option_total))
+            needs_input = action_value.get("needs_input", False)
+            print(f"[Lark] 用户选择了选项: {option_value} (total={option_total}, needs_input={needs_input})")
+            asyncio.create_task(handler.handle_option_select(user_id, chat_id, option_value, option_total, needs_input=needs_input))
             return None
 
         # 列表卡片：进入会话
@@ -247,16 +250,18 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
         if action_type == "dir_start":
             path = action_value.get("path", "")
             session_name = action_value.get("session_name", "")
-            print(f"[Lark] dir_start: path={path}, session={session_name}")
-            asyncio.create_task(handler._cmd_start(user_id, chat_id, f"{session_name} {path}"))
+            cli_type = action_value.get("cli_type", "claude")
+            print(f"[Lark] dir_start: path={path}, session={session_name}, cli_type={cli_type}")
+            asyncio.create_task(handler._cmd_start(user_id, chat_id, f"{session_name} {path}", cli_type=cli_type))
             return None
 
         # 目录卡片：在该目录启动会话并创建专属群聊
         if action_type == "dir_new_group":
             path = action_value.get("path", "")
             session_name = action_value.get("session_name", "")
-            print(f"[Lark] dir_new_group: path={path}, session={session_name}")
-            asyncio.create_task(handler._cmd_start_and_new_group(user_id, chat_id, session_name, path))
+            cli_type = action_value.get("cli_type", "claude")
+            print(f"[Lark] dir_new_group: path={path}, session={session_name}, cli_type={cli_type}")
+            asyncio.create_task(handler._cmd_start_and_new_group(user_id, chat_id, session_name, path, cli_type=cli_type))
             return None
 
         # /menu 卡片按钮
@@ -375,6 +380,21 @@ class LarkBot:
             log_level=lark.LogLevel.INFO,
         )
 
+        # 代理兼容：检测 SOCKS 代理，按配置决定是否绕过
+        proxy_info = urllib.request.getproxies()
+        socks_proxy = (proxy_info.get('socks') or proxy_info.get('all')
+                       or proxy_info.get('https') or proxy_info.get('http'))
+        if socks_proxy and 'socks' in socks_proxy.lower():
+            if config.LARK_NO_PROXY:
+                # 用户选择绕过代理 → 清除代理环境变量
+                for var in ('ALL_PROXY', 'all_proxy', 'HTTPS_PROXY', 'https_proxy',
+                            'HTTP_PROXY', 'http_proxy', 'SOCKS_PROXY', 'socks_proxy'):
+                    os.environ.pop(var, None)
+                print(f"检测到 SOCKS 代理 ({socks_proxy})，已按 LARK_NO_PROXY=1 绕过")
+            else:
+                print(f"检测到 SOCKS 代理 ({socks_proxy})，将通过代理连接")
+                print("  如连接失败，可在 .env 中设置 LARK_NO_PROXY=1 绕过代理")
+
         self.running = True
         print("\n机器人已启动，等待消息...")
         print("在飞书中发送 /help 查看使用说明\n")

package/lark_client/session_bridge.py

@@ -119,22 +119,16 @@ class SessionBridge:
         if not self.writer or not self.running:
             return False
         try:
+            # 分两步发送：先发文本，等 Ink 框架处理完毕，再发 Enter
+            # 不能合并为 text+\r 一次写入（Ink 同一 tick 处理时 \r 会被提前消费，导致需要两次 Enter）
+            # 不能在文本前/后加 ESC（ESC+Enter 被终端解释为 Alt+Enter，导致换行而非提交）
             msg = InputMessage(text.encode('utf-8'), self.client_id)
             self.writer.write(encode_message(msg))
             await self.writer.drain()
-
-            # 发送 Escape 退出多行模式
-            await asyncio.sleep(0.1)
-            msg = InputMessage(b"\x1b", self.client_id)
-            self.writer.write(encode_message(msg))
-            await self.writer.drain()
-
-            # 发送 Enter 提交
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.05)
             msg = InputMessage(b"\r", self.client_id)
             self.writer.write(encode_message(msg))
             await self.writer.drain()
-
             return True
         except Exception as e:
             logger.error(f"发送失败: {e}")