remote-claude 1.0.1 → 1.0.3

package/.env.example

@@ -30,3 +30,7 @@ ALLOWED_USERS=ou_xxxxx,ou_yyyyy
 # 支持: DEBUG / INFO / WARNING / ERROR
 # SERVER_LOG_LEVEL=INFO
 
+# SOCKS 代理兼容（可选）
+# 系统有 SOCKS 代理但飞书可直连时，设为 1 绕过代理
+# LARK_NO_PROXY=1
+

package/lark_client/card_builder.py

@@ -427,6 +427,7 @@ def _build_buttons_v2(options: List[Dict[str, str]]) -> List[Dict[str, Any]]:
                                     "value": {
                                         "action": "select_option",
                                         "value": opt["value"],
+                                        "needs_input": opt.get("needs_input", False),
                                         "total": str(total),
                                     }
                                 }
@@ -1022,16 +1023,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)
+            # 前缀匹配：找 session_groups 中精确匹配或以 auto_session + "_" 开头的条目（取最后一个，即最新的）
+            matched_group_cid = None
+            if session_groups:
+                for sn, cid in session_groups.items():
+                    if sn == auto_session or sn.startswith(auto_session + "_"):
+                        matched_group_cid = cid
             group_btn = {
                 "tag": "button",
-                "text": {"tag": "plain_text", "content": "进入群聊" if (session_groups and auto_session in session_groups) else "创建群聊"},
+                "text": {"tag": "plain_text", "content": "进入群聊" if matched_group_cid 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
+                               "default_url": f"https://applink.feishu.cn/client/chat/open?openChatId={matched_group_cid}",
+                               "android_url": f"https://applink.feishu.cn/client/chat/open?openChatId={matched_group_cid}",
+                               "ios_url": f"https://applink.feishu.cn/client/chat/open?openChatId={matched_group_cid}",
+                               "pc_url": f"https://applink.feishu.cn/client/chat/open?openChatId={matched_group_cid}"}]
+                if matched_group_cid else
                 [{"type": "callback", "value": {
                     "action": "dir_new_group",
                     "path": full_path,
@@ -1202,7 +1209,8 @@ def build_session_closed_card(session_name: str) -> Dict[str, Any]:
 
 def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
                     session_groups: Optional[Dict[str, str]] = None, page: int = 0,
-                    notify_enabled: bool = True, urgent_enabled: bool = False) -> Dict[str, Any]:
+                    notify_enabled: bool = True, urgent_enabled: bool = False,
+                    bypass_enabled: bool = False) -> Dict[str, Any]:
     """构建快捷操作菜单卡片（/menu 和 /list 共用）：内嵌会话列表 + 快捷操作"""
     elements = []
 
@@ -1301,6 +1309,14 @@ def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
         ]
     })
 
+    bypass_label = "🔓 新会话bypass: 开" if bypass_enabled else "🔒 新会话bypass: 关"
+    elements.append({
+        "tag": "button",
+        "text": {"tag": "plain_text", "content": bypass_label},
+        "type": "default",
+        "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_bypass"}}]
+    })
+
     return {
         "schema": "2.0",
         "config": {"wide_screen_mode": True},

package/lark_client/config.py

@@ -48,3 +48,7 @@ LARK_LOG_LEVEL = {
     "WARNING": 30,
     "ERROR": 40,
 }.get(_LARK_LOG_LEVEL, 20)  # 默认 INFO
+
+# SOCKS 代理兼容（可选，默认 False）
+# 系统有 SOCKS 代理但飞书可直连时，设为 1 绕过代理
+LARK_NO_PROXY = os.getenv("LARK_NO_PROXY", "").strip() in ("1", "true", "yes")

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,
@@ -316,45 +340,36 @@ 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 self._poller.get_bypass_enabled():
+            cmd += ["--", "--dangerously-skip-permissions", "--permission-mode=dontAsk"]
 
         logger.info(f"启动会话: {session_name}, 工作目录: {work_dir}, 命令: {' '.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):
@@ -365,13 +380,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
@@ -389,42 +404,61 @@ 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):
         """在指定目录启动会话并创建专属群聊"""
-        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 self._poller.get_bypass_enabled():
+            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)
@@ -432,6 +466,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):
@@ -607,7 +643,8 @@ class LarkHandler:
         }
         card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page,
                                notify_enabled=self._poller.get_notify_enabled(),
-                               urgent_enabled=self._poller.get_urgent_enabled())
+                               urgent_enabled=self._poller.get_urgent_enabled(),
+                               bypass_enabled=self._poller.get_bypass_enabled())
         await self._send_or_update_card(chat_id, card, message_id)
 
     async def _cmd_toggle_notify(self, user_id: str, chat_id: str,
@@ -624,6 +661,13 @@ class LarkHandler:
         self._poller.set_urgent_enabled(new_value)
         await self._cmd_menu(user_id, chat_id, message_id=message_id)
 
+    async def _cmd_toggle_bypass(self, user_id: str, chat_id: str,
+                                  message_id: Optional[str] = None):
+        """切换新会话 bypass 开关并刷新菜单卡片"""
+        new_value = not self._poller.get_bypass_enabled()
+        self._poller.set_bypass_enabled(new_value)
+        await self._cmd_menu(user_id, chat_id, message_id=message_id)
+
     async def _cmd_ls(self, user_id: str, chat_id: str, args: str,
                        tree: bool = False, message_id: Optional[str] = None, page: int = 0):
         """查看目录文件结构"""
@@ -779,6 +823,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):
         """解散与指定会话绑定的专属群聊"""
@@ -830,6 +900,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:
@@ -849,12 +921,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',
@@ -866,37 +937,99 @@ 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",
-        }
-        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)
+        target = option_value  # 目标选项 value（如 "2"）
+        max_steps = max(option_total, 10) if option_total > 0 else 10
 
-        if success:
-            self._poller.kick(chat_id)
-        else:
-            await card_service.send_text(chat_id, "发送选择失败")
+        # 记录初始 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}")
 
     # ── 快捷键发送 ─────────────────────────────────────────────────────────────
 

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
 
         # 列表卡片：进入会话
@@ -314,6 +317,10 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
             asyncio.create_task(handler._cmd_toggle_urgent(user_id, chat_id, message_id=message_id))
             return None
 
+        if action_type == "menu_toggle_bypass":
+            asyncio.create_task(handler._cmd_toggle_bypass(user_id, chat_id, message_id=message_id))
+            return None
+
         # 各卡片底部菜单按钮：辅助卡片就地→菜单，流式卡片降级新卡
         if action_type == "menu_open":
             asyncio.create_task(handler._cmd_menu(user_id, chat_id, message_id=message_id))
@@ -371,6 +378,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}")

package/lark_client/shared_memory_poller.py

@@ -40,6 +40,7 @@ from utils.session import ensure_user_data_dir, USER_DATA_DIR
 # ── 常量 ──────────────────────────────────────────────────────────────────────
 INITIAL_WINDOW = 30    # 首次 attach 最多显示最近 30 个 blocks
 from .config import MAX_CARD_BLOCKS  # 单张卡片最多 N 个 blocks → 超限冻结（可通过 .env 配置）
+CARD_SIZE_LIMIT = 25 * 1024  # 25KB，飞书限制 30KB，留 5KB 余量
 POLL_INTERVAL = 1.0    # 轮询间隔（秒）
 RAPID_INTERVAL = 0.2   # 快速轮询间隔（秒）
 RAPID_DURATION = 2.0   # 快速轮询持续时间（秒）
@@ -153,6 +154,16 @@ class SharedMemoryPoller:
         if exc:
             logger.error(f"轮询 Task 异常: chat_id={chat_id[:8]}..., {exc}", exc_info=exc)
 
+    def read_snapshot(self, chat_id: str) -> Optional[dict]:
+        """直接读取指定 chat_id 的当前共享内存快照（供 handle_option_select 等即时查询使用）"""
+        tracker = self._trackers.get(chat_id)
+        if tracker and tracker.reader:
+            try:
+                return tracker.reader.read()
+            except Exception as e:
+                logger.warning(f"read_snapshot 失败: {e}")
+        return None
+
     def kick(self, chat_id: str) -> None:
         """触发立即轮询并进入快速轮询模式"""
         self._rapid_until[chat_id] = time.time() + RAPID_DURATION
@@ -262,6 +273,16 @@ class SharedMemoryPoller:
             from .card_builder import build_stream_card
             card_dict = build_stream_card(blocks_slice, status_line, bottom_bar, agent_panel=agent_panel, option_block=option_block, session_name=tracker.session_name, cli_type=cli_type)
 
+            # 大小超限检查（与 blocks 数量超限同一套逻辑）
+            card_size = len(json.dumps(card_dict, ensure_ascii=False).encode('utf-8'))
+            if card_size > CARD_SIZE_LIMIT:
+                freeze_count = self._find_freeze_count(blocks_slice, tracker.session_name)
+                await self._freeze_and_split(
+                    tracker, blocks, status_line, bottom_bar, agent_panel, option_block,
+                    cli_type=cli_type, freeze_count=freeze_count,
+                )
+                return
+
             active.sequence += 1
             success = await self._card_service.update_card(
                 card_id=active.card_id,
@@ -326,6 +347,15 @@ class SharedMemoryPoller:
 
         from .card_builder import build_stream_card
         card_dict = build_stream_card(blocks_slice, status_line, bottom_bar, agent_panel=agent_panel, option_block=option_block, session_name=tracker.session_name, cli_type=cli_type)
+
+        # 新卡大小检查：超限则从头部裁剪
+        card_size = len(json.dumps(card_dict, ensure_ascii=False).encode('utf-8'))
+        while card_size > CARD_SIZE_LIMIT and len(blocks_slice) > 1:
+            blocks_slice = blocks_slice[1:]
+            start_idx += 1
+            card_dict = build_stream_card(blocks_slice, status_line, bottom_bar, agent_panel=agent_panel, option_block=option_block, session_name=tracker.session_name, cli_type=cli_type)
+            card_size = len(json.dumps(card_dict, ensure_ascii=False).encode('utf-8'))
+
         card_id = await self._card_service.create_card(card_dict)
 
         if card_id:
@@ -384,6 +414,24 @@ class SharedMemoryPoller:
                 f"[ELEMENT_LIMIT_SPLIT] session={tracker.session_name} "
                 f"new_start={new_start} blocks={len(new_blocks)} card_id={new_card_id}"
             )
+            tracker.last_notify_message_id = None
+
+    def _find_freeze_count(self, blocks_slice: List[dict], session_name: str) -> int:
+        """二分查找冻结卡片能容纳的最大 blocks 数（保证卡片 JSON 大小 ≤ CARD_SIZE_LIMIT）"""
+        from .card_builder import build_stream_card
+        lo, hi = 1, len(blocks_slice)
+        result = 1
+        while lo <= hi:
+            mid = (lo + hi) // 2
+            card = build_stream_card(blocks_slice[:mid], None, None,
+                                     is_frozen=True, session_name=session_name)
+            size = len(json.dumps(card, ensure_ascii=False).encode('utf-8'))
+            if size <= CARD_SIZE_LIMIT:
+                result = mid
+                lo = mid + 1
+            else:
+                hi = mid - 1
+        return result
 
     async def _freeze_and_split(
         self, tracker: StreamTracker, blocks: List[dict],
@@ -391,12 +439,15 @@ class SharedMemoryPoller:
         agent_panel: Optional[dict] = None,
         option_block: Optional[dict] = None,
         cli_type: str = "claude",
+        freeze_count: Optional[int] = None,
     ) -> None:
         """冻结当前卡片 + 开新卡"""
         active = tracker.cards[-1]
+        count = freeze_count if freeze_count is not None else MAX_CARD_BLOCKS
+        reason = 'size' if freeze_count is not None else 'count'
 
-        # 冻结当前卡片（只保留前 MAX_CARD_BLOCKS 个 blocks，移除状态区和按钮）
-        frozen_blocks = blocks[active.start_idx:active.start_idx + MAX_CARD_BLOCKS]
+        # 冻结当前卡片（只保留前 count 个 blocks，移除状态区和按钮）
+        frozen_blocks = blocks[active.start_idx:active.start_idx + count]
         from .card_builder import build_stream_card
         frozen_card = build_stream_card(frozen_blocks, None, None, is_frozen=True)
         active.sequence += 1
@@ -406,16 +457,25 @@ class SharedMemoryPoller:
                      chat_id=tracker.chat_id)
         logger.info(
             f"[FREEZE] session={tracker.session_name} card_id={active.card_id} "
-            f"blocks=[{active.start_idx}:{active.start_idx + MAX_CARD_BLOCKS}]"
+            f"blocks=[{active.start_idx}:{active.start_idx + count}] reason={reason}"
         )
 
         # 创建新卡片
-        new_start = active.start_idx + MAX_CARD_BLOCKS
+        new_start = active.start_idx + count
         new_blocks = blocks[new_start:]
         if not new_blocks:
             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, cli_type=cli_type)
+
+        # 新卡大小检查：超限则从头部裁剪
+        new_card_size = len(json.dumps(new_card_dict, ensure_ascii=False).encode('utf-8'))
+        while new_card_size > CARD_SIZE_LIMIT and len(new_blocks) > 1:
+            new_blocks = new_blocks[1:]
+            new_start += 1
+            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, cli_type=cli_type)
+            new_card_size = len(json.dumps(new_card_dict, ensure_ascii=False).encode('utf-8'))
+
         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)
@@ -425,6 +485,7 @@ class SharedMemoryPoller:
                 f"[NEW after FREEZE] session={tracker.session_name} start_idx={new_start} "
                 f"blocks={len(new_blocks)} card_id={new_card_id}"
             )
+            tracker.last_notify_message_id = None
 
     async def _check_ready_notification(
         self, tracker: StreamTracker,
@@ -504,6 +565,17 @@ class SharedMemoryPoller:
         _save_urgent_enabled(enabled)
         logger.info(f"加急通知开关已{'开启' if enabled else '关闭'}")
 
+    def get_bypass_enabled(self) -> bool:
+        """获取新会话 bypass 开关状态"""
+        return _bypass_enabled
+
+    def set_bypass_enabled(self, enabled: bool) -> None:
+        """更新新会话 bypass 开关状态并持久化"""
+        global _bypass_enabled
+        _bypass_enabled = enabled
+        _save_bypass_enabled(enabled)
+        logger.info(f"新会话 bypass 开关已{'开启' if enabled else '关闭'}")
+
     @staticmethod
     def _compute_hash(
         blocks: list, status_line: Optional[dict],
@@ -534,6 +606,7 @@ def _is_ready(blocks: list, status_line: Optional[dict], option_block: Optional[
 _READY_COUNT_FILE = USER_DATA_DIR / "ready_notify_count"
 _NOTIFY_ENABLED_FILE = USER_DATA_DIR / "ready_notify_enabled"
 _URGENT_ENABLED_FILE = USER_DATA_DIR / "urgent_notify_enabled"
+_BYPASS_ENABLED_FILE = USER_DATA_DIR / "bypass_enabled"
 
 
 def _load_notify_enabled() -> bool:
@@ -570,9 +643,27 @@ def _save_urgent_enabled(enabled: bool) -> None:
         logger.warning(f"_save_urgent_enabled 失败: {e}")
 
 
+def _load_bypass_enabled() -> bool:
+    """读取新会话 bypass 开关状态，不存在或解析失败返回 False（默认关闭）"""
+    try:
+        return _BYPASS_ENABLED_FILE.read_text().strip() == "1"
+    except Exception:
+        return False
+
+
+def _save_bypass_enabled(enabled: bool) -> None:
+    """持久化新会话 bypass 开关状态"""
+    try:
+        ensure_user_data_dir()
+        _BYPASS_ENABLED_FILE.write_text("1" if enabled else "0")
+    except Exception as e:
+        logger.warning(f"_save_bypass_enabled 失败: {e}")
+
+
 # 模块级开关状态：启动时加载一次
 _notify_enabled: bool = _load_notify_enabled()
 _urgent_enabled: bool = _load_urgent_enabled()
+_bypass_enabled: bool = _load_bypass_enabled()
 
 
 def _increment_ready_count() -> int:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-claude",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "双端共享 Claude CLI 工具",
   "bin": {
     "remote-claude": "bin/remote-claude",
@@ -8,6 +8,7 @@
     "cl": "bin/cl"
   },
   "scripts": {
+    "preinstall": "bash scripts/preinstall.sh",
     "postinstall": "bash scripts/postinstall.sh"
   },
   "files": [

package/pyproject.toml

@@ -8,6 +8,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "pyte>=0.8.0",
     "mixpanel>=5.0.0",
+    "python-socks[asyncio]>=2.0.0",
 ]
 
 [project.scripts]

package/scripts/preinstall.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+# 升级前尝试停止旧的 lark 客户端（失败不报错）
+remote-claude lark stop 2>/dev/null || true
+exit 0

package/server/parsers/claude_parser.py

@@ -258,6 +258,40 @@ def _get_row_text(screen: pyte.Screen, row: int) -> str:
     return ''.join(buf).rstrip()
 
 
+def _is_dim_fg(fg_color: str) -> bool:
+    """判断前景色是否为灰色/暗色（placeholder 风格）。"""
+    if not fg_color or fg_color == 'default':
+        return False
+    name = fg_color.lower().replace(' ', '').replace('-', '')
+    if name in ('brightblack', 'black'):  # bright_black = gray
+        return True
+    if len(fg_color) == 6:
+        try:
+            r, g, b = int(fg_color[0:2], 16), int(fg_color[2:4], 16), int(fg_color[4:6], 16)
+            L = 0.2126 * r + 0.7152 * g + 0.0722 * b
+            # 灰色调（R≈G≈B）且非纯白 → inactive/placeholder 颜色（如 999999 亮度 153 > 128）
+            if max(r, g, b) - min(r, g, b) <= 30 and L < 230:
+                return True
+            # 非灰色但较暗
+            return L < 128
+        except ValueError:
+            pass
+    return False
+
+
+def _option_label_is_dim(screen: pyte.Screen, row: int) -> bool:
+    """检查选项行 label 部分前景色是否为暗色（自由输入 placeholder 风格）。"""
+    text = _get_row_text(screen, row)
+    m = re.match(r'^[\s❯]*\d+[.)]\s+', text)
+    if not m:
+        return False
+    col = m.end()
+    buf_row = screen.buffer[row]
+    if col not in buf_row or not buf_row[col].data.strip():
+        return False
+    return _is_dim_fg(buf_row[col].fg)
+
+
 def _get_col0(screen: pyte.Screen, row: int) -> str:
     """获取指定行第一列字符（col=0）"""
     try:
@@ -874,6 +908,7 @@ class ClaudeParser(BaseParser):
 
         options: List[dict] = []
         current_opt: Optional[dict] = None
+        selected_value = ""
         ansi_raw_lines = [_get_row_ansi_text(screen, r) for r in input_rows + overflow]
 
         for row in all_option_rows:
@@ -891,7 +926,10 @@ class ClaudeParser(BaseParser):
                     'label': m.group(2).strip(),
                     'value': m.group(1),
                     'description': '',
+                    'needs_input': _option_label_is_dim(screen, row),  # 自由输入选项检测
                 }
+                if line.startswith('❯'):
+                    selected_value = m.group(1)
             elif current_opt is not None and line:
                 # 描述行
                 current_opt['description'] = (
@@ -905,6 +943,7 @@ class ClaudeParser(BaseParser):
             return OptionBlock(
                 sub_type='option', tag=tag, question=question, options=options,
                 ansi_raw='\n'.join(ansi_raw_lines).rstrip(),
+                selected_value=selected_value,
             )
         return None
 
@@ -1020,6 +1059,7 @@ class ClaudeParser(BaseParser):
                 content_lines = pre_option_contents[1:-1]
 
         # 只收集范围内的 options
+        selected_value = ""
         for i in range(first_opt_idx, last_opt_idx + 1):
             line, cat = classified[i]
             if cat == 'option':
@@ -1029,6 +1069,8 @@ class ClaudeParser(BaseParser):
                         'label': m.group(2).strip(),
                         'value': m.group(1),
                     })
+                    if line.startswith('❯'):
+                        selected_value = m.group(1)
 
         return OptionBlock(
             sub_type='permission',
@@ -1037,6 +1079,7 @@ class ClaudeParser(BaseParser):
             question=question,
             options=options,
             ansi_raw='\n'.join(ansi_lines).rstrip(),
+            selected_value=selected_value,
         )
 
     def _parse_agent_list_panel(

package/server/parsers/codex_parser.py

@@ -1256,6 +1256,7 @@ class CodexParser(BaseParser):
 
         options: List[dict] = []
         current_opt: Optional[dict] = None
+        selected_value = ""
         ansi_raw_lines = [_get_row_ansi_text(screen, r) for r in input_rows + overflow]
 
         for row in all_option_rows:
@@ -1274,6 +1275,8 @@ class CodexParser(BaseParser):
                     'value': m.group(1),
                     'description': '',
                 }
+                if line[0:1] in CODEX_PROMPT_CHARS or line.startswith('❯'):
+                    selected_value = m.group(1)
             elif current_opt is not None and line:
                 # 描述行
                 current_opt['description'] = (
@@ -1287,6 +1290,7 @@ class CodexParser(BaseParser):
             return OptionBlock(
                 sub_type='option', tag=tag, question=question, options=options,
                 ansi_raw='\n'.join(ansi_raw_lines).rstrip(),
+                selected_value=selected_value,
             )
         return None
 
@@ -1407,6 +1411,7 @@ class CodexParser(BaseParser):
                 content_lines = pre_option_contents[1:-1]
 
         # 只收集范围内的 options
+        selected_value = ""
         for i in range(first_opt_idx, last_opt_idx + 1):
             line, cat = classified[i]
             if cat == 'option':
@@ -1416,6 +1421,8 @@ class CodexParser(BaseParser):
                         'label': m.group(2).strip(),
                         'value': m.group(1),
                     })
+                    if line[0:1] in CODEX_PROMPT_CHARS or line.startswith('❯'):
+                        selected_value = m.group(1)
 
         return OptionBlock(
             sub_type='permission',
@@ -1424,6 +1431,7 @@ class CodexParser(BaseParser):
             question=question,
             options=options,
             ansi_raw='\n'.join(ansi_lines).rstrip(),
+            selected_value=selected_value,
         )
 
     def _parse_agent_list_panel(

package/utils/components.py

@@ -79,6 +79,7 @@ class OptionBlock:
     ansi_raw: str = ""         # 整个选项区域的 ANSI 原始文本
     indicator: str = ""        # 首列字符原文
     ansi_indicator: str = ""   # 带 ANSI 颜色的首列字符
+    selected_value: str = ""   # 当前 ❯ 光标所在选项的 value（数字字符串）
 
 
 # 向后兼容别名