remote-claude 0.2.9 → 0.2.11

package/.env.example

@@ -22,3 +22,7 @@ ALLOWED_USERS=ou_xxxxx,ou_yyyyy
 # 单张卡片最多显示的 block 数量，超限自动冻结并创建新卡片（默认 50）
 # MAX_CARD_BLOCKS=50
 
+# lark_client 日志级别（可选，默认 INFO）
+# 支持: DEBUG / INFO / WARNING / ERROR
+# LARK_LOG_LEVEL=INFO
+

package/README.md

@@ -43,7 +43,7 @@ cd remote_claude
 ./init.sh
 ```
 
-`init.sh` 会自动安装 uv、tmux 等依赖，配置飞书环境（可选），并写入 `cla` / `cl` 快捷命令。执行完成后重启终端生效。
+`init.sh` 会自动安装 uv、tmux 等依赖，配置飞书环境（可选），并写入 `cla` / `cl` / `cx` / `cdx` 快捷命令。执行完成后重启终端生效。
 
 ### 2. 启动
 
@@ -51,6 +51,8 @@ cd remote_claude
 |------|------|
 | `cla` | 启动 Claude (以当前目录路径为会话名) |
 | `cl` | 同 `cla`，但跳过权限确认 |
+| `cx` | 启动 Codex (以当前目录路径为会话名，跳过权限确认) |
+| `cdx` | 同 `cx`，但需要确认权限 |
 | `remote-claude` | 管理工具（一般不用）|
 
 ### 3. 从其他终端连接(比较少用)
@@ -210,6 +212,8 @@ remote-claude attach <会话名>
 |------|------|
 | `cla` | 启动飞书客户端 + 以当前目录路径为会话名启动 Claude |
 | `cl` | 同 `cla`，但跳过权限确认 |
+| `cx` | 启动飞书客户端 + 以当前目录路径为会话名启动 Codex（跳过权限确认）|
+| `cdx` | 同 `cx`，但需要确认权限 |
 
 ### 管理命令 (一般不需要)
 
@@ -260,7 +264,8 @@ CLAUDE_COMMAND=/usr/local/bin/claude
 ## 系统要求
 
 - **操作系统**: macOS 或 Linux
-- **依赖工具**: [uv](https://docs.astral.sh/uv/)、[tmux](https://github.com/tmux/tmux)、[Claude CLI](https://claude.ai/code)
+- **依赖工具**: [uv](https://docs.astral.sh/uv/)、[tmux](https://github.com/tmux/tmux)
+- **CLI 工具**: [Claude CLI](https://claude.ai/code) 或 [Codex CLI](https://github.com/openai/codex)
 - **可选**: 飞书企业自建应用
 
 ## 文档

package/bin/cdx

@@ -0,0 +1,20 @@
+#!/bin/bash
+# 解析符号链接，兼容 macOS（不支持 readlink -f）
+SOURCE="$0"
+while [ -L "$SOURCE" ]; do
+    DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+    SOURCE="$(readlink "$SOURCE")"
+    [[ "$SOURCE" != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && cd .. && pwd)"
+
+# uv 路径兜底
+if ! command -v uv &>/dev/null; then
+    [ -f "$HOME/.local/bin/uv" ] && export PATH="$HOME/.local/bin:$PATH"
+fi
+
+# 检查飞书配置
+source "$SCRIPT_DIR/scripts/check-env.sh" "$SCRIPT_DIR"
+
+uv run --project "$SCRIPT_DIR" python3 "$SCRIPT_DIR/remote_claude.py" lark start
+uv run --project "$SCRIPT_DIR" python3 "$SCRIPT_DIR/remote_claude.py" start "${PWD}_$(date +%m%d_%H%M%S)" --cli codex -- "$@"

package/bin/cx

@@ -0,0 +1,20 @@
+#!/bin/bash
+# 解析符号链接，兼容 macOS（不支持 readlink -f）
+SOURCE="$0"
+while [ -L "$SOURCE" ]; do
+    DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+    SOURCE="$(readlink "$SOURCE")"
+    [[ "$SOURCE" != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && cd .. && pwd)"
+
+# uv 路径兜底
+if ! command -v uv &>/dev/null; then
+    [ -f "$HOME/.local/bin/uv" ] && export PATH="$HOME/.local/bin:$PATH"
+fi
+
+# 检查飞书配置
+source "$SCRIPT_DIR/scripts/check-env.sh" "$SCRIPT_DIR"
+
+uv run --project "$SCRIPT_DIR" python3 "$SCRIPT_DIR/remote_claude.py" lark start
+uv run --project "$SCRIPT_DIR" python3 "$SCRIPT_DIR/remote_claude.py" start "${PWD}_$(date +%m%d_%H%M%S)" --cli codex -- --dangerously-bypass-approvals-and-sandbox "$@"

package/bin/remote-claude

@@ -21,8 +21,18 @@ if [ "$1" = "log" ]; then
         SESSION_SAFE=$(echo "$2" | tr '/.' '__')
         LOG_FILE="$LOG_DIR/${SESSION_SAFE}_messages.log"
     else
-        # 找最后启动的 session（最新的 session .pid 文件，排除 lark.pid）
-        LATEST_PID=$(ls -t "$LOG_DIR"/_*.pid 2>/dev/null | head -1)
+        # 找最后启动的 session（按创建时间排序，排除 lark.pid）
+        if [[ "$OSTYPE" == "darwin"* ]]; then
+            # macOS: stat -f "%B" 返回创建时间（秒）
+            LATEST_PID=$(ls "$LOG_DIR"/_*.pid 2>/dev/null | while read f; do
+                stat -f "%B:%N" "$f" 2>/dev/null
+            done | sort -rn | head -1 | cut -d: -f2)
+        else
+            # Linux: stat -c "%W" 返回创建时间（秒）
+            LATEST_PID=$(ls "$LOG_DIR"/_*.pid 2>/dev/null | while read f; do
+                stat -c "%W:%N" "$f" 2>/dev/null
+            done | sort -rn | head -1 | cut -d: -f2)
+        fi
         if [ -n "$LATEST_PID" ]; then
             SESSION_SAFE=$(basename "$LATEST_PID" .pid)
             LOG_FILE="$LOG_DIR/${SESSION_SAFE}_messages.log"

package/client/__init__.py

@@ -0,0 +1,3 @@
+"""
+Remote Claude 终端客户端模块
+"""

package/init.sh

@@ -350,6 +350,26 @@ check_claude() {
     fi
 }
 
+# 检查 Codex CLI
+check_codex() {
+    print_header "检查 Codex CLI"
+
+    if command -v codex &> /dev/null; then
+        print_success "Codex CLI 已安装"
+        return
+    fi
+
+    print_warning "未找到 Codex CLI"
+    print_info "请运行以下命令安装 Codex CLI："
+    print_info "  npm install -g @openai/codex"
+    print_info "或访问 https://github.com/openai/codex 了解更多"
+
+    if $NPM_MODE; then
+        print_info "（npm 模式：跳过交互，请安装后重新运行）"
+        return
+    fi
+}
+
 # 安装 Python 依赖
 install_dependencies() {
     print_header "安装 Python 依赖"
@@ -449,7 +469,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" 2>/dev/null || true
+    chmod +x "$SCRIPT_DIR/bin/cla" "$SCRIPT_DIR/bin/cl" "$SCRIPT_DIR/bin/cx" "$SCRIPT_DIR/bin/cdx" "$SCRIPT_DIR/bin/remote-claude" 2>/dev/null || true
 
     # 优先 /usr/local/bin，权限不够则选 ~/bin 或 ~/.local/bin 中已在 PATH 里的
     BIN_DIR="/usr/local/bin"
@@ -479,15 +499,21 @@ configure_shell() {
         mkdir -p "$BIN_DIR"
         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/cx"            "$BIN_DIR/cx"           2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/cdx"           "$BIN_DIR/cdx"          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"           2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/cx"            "$BIN_DIR/cx"           2>/dev/null || true
+        ln -sf "$SCRIPT_DIR/bin/cdx"           "$BIN_DIR/cdx"          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"
+    print_success "已安装 cla、cl、cx、cdx 和 remote-claude 到 $BIN_DIR"
     print_info "  cla           - 启动飞书客户端 + 以当前目录路径+时间戳为会话名启动 Claude"
     print_info "  cl            - 同 cla，但跳过权限确认"
+    print_info "  cx            - 启动飞书客户端 + 以当前目录路径+时间戳为会话名启动 Codex（跳过权限）"
+    print_info "  cdx           - 同 cx，但需确认权限"
     print_info "  remote-claude - Remote Claude 主命令（start/attach/list/kill/lark）"
 
     # 安装 shell 自动补全
@@ -536,6 +562,8 @@ ${YELLOW}快捷命令：${NC}
 
   ${GREEN}cla${NC}  - 启动飞书客户端 + 以当前目录+时间戳为会话名启动 Claude
   ${GREEN}cl${NC}   - 同 cla，但跳过权限确认
+  ${GREEN}cx${NC}   - 启动飞书客户端 + 以当前目录+时间戳为会话名启动 Codex（跳过权限）
+  ${GREEN}cdx${NC}  - 同 cx，但需确认权限
 
 详细使用说明请阅读 README.md
 
@@ -565,6 +593,7 @@ main() {
     check_uv
     check_tmux
     check_claude
+    check_codex
     install_dependencies
     if ! $NPM_MODE; then
         configure_lark

package/lark_client/card_builder.py

@@ -784,29 +784,36 @@ def _build_session_list_elements(sessions: List[Dict], current_session: Optional
             name = s["name"]
             cwd = s.get("cwd", "")
             start_time = s.get("start_time", "")
+            cli_type = s.get("cli_type", "claude")
             is_current = (name == current_session)
 
+            # CLI 类型颜色和标签：Claude=黄色，Codex=绿色
+            cli_color = "yellow" if cli_type == "claude" else "green"
+            cli_label = CLI_NAMES.get(cli_type, "Claude")
+
             status_icon = "🟢" if is_current else "⚪"
             current_label = "（当前）" if is_current else ""
             if cwd:
                 short_name = cwd.rstrip("/").rsplit("/", 1)[-1] or name
             else:
                 short_name = name
-            meta_parts = []
+
+            # 构建4行内容：名字、cli类型、启动时间、目录
+            lines = [f"{status_icon} **{short_name}**{current_label}"]
+            lines.append(f"<font color=\"{cli_color}\">{cli_label}</font>")
+
             if start_time:
-                meta_parts.append(f"启动：{start_time}")
+                lines.append(f"启动：{start_time}")
+
             if cwd:
                 home = os.path.expanduser("~")
                 display_cwd = cwd.replace(home, "~")
                 if len(display_cwd) > 40:
                     parts = display_cwd.rstrip("/").rsplit("/", 2)
                     display_cwd = "…/" + "/".join(parts[-2:]) if len(parts) > 2 else display_cwd[-40:]
-                meta_parts.append(f"`{display_cwd}`")
-            meta_str = "  ".join(meta_parts) if meta_parts else ""
+                lines.append(f"`{display_cwd}`")
 
-            header_text = f"{status_icon} **{short_name}**{current_label}"
-            if meta_str:
-                header_text += f"\n{meta_str}"
+            header_text = "\n".join(lines)
 
             if is_current:
                 btn_label = "断开连接"

package/lark_client/config.py

@@ -38,3 +38,13 @@ GROUP_NAME_PREFIX = os.getenv("GROUP_NAME_PREFIX", "【Remote-Claude】")
 
 # 流式卡片配置
 MAX_CARD_BLOCKS = int(os.getenv("MAX_CARD_BLOCKS", "50"))
+
+# lark_client 日志级别（可选，默认 INFO）
+# 支持: DEBUG / INFO / WARNING / ERROR
+_LARK_LOG_LEVEL = os.getenv("LARK_LOG_LEVEL", "INFO").upper()
+LARK_LOG_LEVEL = {
+    "DEBUG": 10,
+    "INFO": 20,
+    "WARNING": 30,
+    "ERROR": 40,
+}.get(_LARK_LOG_LEVEL, 20)  # 默认 INFO

package/lark_client/lark_handler.py

@@ -318,15 +318,20 @@ class LarkHandler:
         server_script = script_dir / "server" / "server.py"
         cmd = [sys.executable, str(server_script), session_name]
 
-        logger.info(f"启动会话: {session_name}, 工作目录: {work_dir}, 命令: {cmd}")
+        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)
 
-            subprocess.Popen(
+            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,
@@ -335,13 +340,38 @@ class LarkHandler:
                 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)
+
             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)
+                        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:
-                await card_service.send_text(chat_id, "错误: 会话启动超时")
+                log_content = _read_log_since(start_time)
+                logger.error(f"会话启动超时 (12s), session={session_name}\n{log_content}")
+                await card_service.send_text(chat_id, f"错误: 会话启动超时 (12s)\n\n{log_content}")
                 return
 
             ok = await self._attach(chat_id, session_name)

package/lark_client/main.py

@@ -12,16 +12,60 @@ import signal
 import sys
 from pathlib import Path
 
+
+# 设置 sys.path 以导入 utils 模块
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from utils.session import USER_DATA_DIR
+
+
+def _setup_logging():
+    """配置 lark_client 日志：INFO → lark_client.log, DEBUG → lark_client.debug.log"""
+    from .config import LARK_LOG_LEVEL
+
+    log_dir = USER_DATA_DIR
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    # 日志格式（含毫秒级时间戳）
+    log_format = "%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
+    formatter = logging.Formatter(log_format, datefmt=date_format)
+
+    # 根 logger 配置
+    root_logger = logging.getLogger()
+    root_logger.setLevel(LARK_LOG_LEVEL)
+
+    # 清除默认 handler
+    root_logger.handlers.clear()
+
+    # 正常日志文件（INFO 及以上）
+    info_handler = logging.FileHandler(log_dir / "lark_client.log", encoding="utf-8")
+    info_handler.setLevel(logging.INFO)
+    info_handler.setFormatter(formatter)
+    root_logger.addHandler(info_handler)
+
+    # 调试日志文件（DEBUG 及以上，仅当 LARK_LOG_LEVEL=DEBUG 时写入）
+    if LARK_LOG_LEVEL == logging.DEBUG:
+        debug_handler = logging.FileHandler(log_dir / "lark_client.debug.log", encoding="utf-8")
+        debug_handler.setLevel(logging.DEBUG)
+        debug_handler.setFormatter(formatter)
+        root_logger.addHandler(debug_handler)
+
+    # 第三方库保持 INFO 级别
+    for _noisy in ('urllib3', 'websockets', 'asyncio'):
+        logging.getLogger(_noisy).setLevel(logging.INFO)
+
+    # 控制台输出（仅重要消息，无调试信息）
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+
+
+# 在导入 lark SDK 之前配置日志
+_setup_logging()
+
 import lark_oapi as lark
 
-# 在 SDK 配置 logging 之前，先设置根 logger 和我们自己模块的 DEBUG 级别
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='[%(name)s] %(message)s',
-)
-# 将噪音较大的第三方库保持 INFO 级别
-for _noisy in ('urllib3', 'websockets', 'asyncio'):
-    logging.getLogger(_noisy).setLevel(logging.INFO)
 from lark_oapi.api.im.v1 import P2ImMessageReceiveV1
 from lark_oapi.event.callback.model.p2_card_action_trigger import (
     P2CardActionTrigger, P2CardActionTriggerResponse, CallBackToast

package/lark_client/session_bridge.py

@@ -11,7 +11,7 @@ import sys
 from pathlib import Path
 from typing import Optional, Callable, Dict
 
-logging.basicConfig(level=logging.DEBUG, format='[%(name)s] %(message)s')
+logging.basicConfig(level=logging.INFO, format='[%(name)s] %(message)s')
 logger = logging.getLogger('SessionBridge')
 
 sys.path.insert(0, str(Path(__file__).parent.parent))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-claude",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "双端共享 Claude CLI 工具",
   "bin": {
     "remote-claude": "bin/remote-claude",
@@ -33,7 +33,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yuyangzi/remote_claude.git"
+    "url": "git+https://github.com/yyzybb537/remote_claude.git"
   },
   "keywords": [
     "claude",

package/remote_claude.py

@@ -3,19 +3,24 @@
 Remote Claude - 双端共享 Claude CLI 工具
 
 命令:
-  start <name>   启动新会话（在 tmux 中）
-  attach <name>  连接到已有会话
-  list           列出所有会话
-  kill <name>    终止会话
-  lark           飞书客户端管理（start/stop/restart/status）
+  start <name>       启动新会话（在 tmux 中）
+  attach <name>      连接到已有会话
+  list               列出所有会话
+  kill <name>        终止会话
+  status <name>      显示会话状态
+  lark               飞书客户端管理（start/stop/restart/status）
+  stats              查看使用统计
+  update             更新 remote-claude 到最新版本
 """
 
 import argparse
+import logging
 import os
 import sys
 import subprocess
 import time
 import signal
+from datetime import datetime
 from pathlib import Path
 
 # 确保项目根目录在 sys.path 中，以便 import client / server 子模块
@@ -31,7 +36,7 @@ from utils.session import (
     is_lark_running, get_lark_pid, get_lark_status, get_lark_pid_file,
     save_lark_status, cleanup_lark,
     USER_DATA_DIR, ensure_user_data_dir, get_lark_log_file,
-    get_env_snapshot_path
+    get_env_snapshot_path,
 )
 
 
@@ -91,7 +96,22 @@ def cmd_start(args):
 
     server_cmd = f"{env_prefix}uv run --project '{SCRIPT_DIR}' python3 '{server_script}'{debug_flag}{debug_verbose_flag}{cli_type_flag} -- '{session_name}' {claude_args_str}"
 
-    print(f"启动会话: {session_name}")
+    # 配置启动日志（写文件 + stdout）
+    _log_path = USER_DATA_DIR / "startup.log"
+    _start_logger = logging.getLogger('Start')
+    if not _start_logger.handlers:
+        _handler_file = logging.FileHandler(_log_path, encoding="utf-8")
+        _handler_file.setFormatter(logging.Formatter(
+            "%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        ))
+        _start_logger.addHandler(_handler_file)
+        _start_logger.setLevel(logging.INFO)
+        _start_logger.propagate = False
+
+    start_time = datetime.now()
+    _start_logger.info(f"启动会话: {session_name}")
+    _start_logger.info(f"server_cmd: {server_cmd}")
 
     # 创建 tmux 会话，运行 server（detached，仅后台）
     if not tmux_create_session(session_name, server_cmd, detached=True):
@@ -100,12 +120,30 @@ def cmd_start(args):
 
     # 等待 server 启动
     socket_path = get_socket_path(session_name)
-    for _ in range(50):  # 最多等待 5 秒
+    for i in range(50):  # 最多等待 5 秒
         if socket_path.exists():
             break
         time.sleep(0.1)
+        if (i + 1) % 10 == 0:
+            elapsed = (i + 1) // 10
+            print(f"等待 Server 启动... ({elapsed}s)")
     else:
-        print("错误: Server 启动超时")
+        print("错误: Server 启动超时 (5s)")
+        # 过滤出本次启动后的日志行
+        if _log_path.exists():
+            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 >= start_time:
+                        lines.append(line)
+                except ValueError:
+                    if lines:  # 多行日志的续行，附到上一条
+                        lines.append(line)
+            if lines:
+                print(f"--- Server 日志 ({_log_path}) ---")
+                print("\n".join(lines))
+                print("-------------------")
         tmux_kill_session(session_name)
         return 1
 
@@ -148,16 +186,29 @@ def cmd_list(args):
         print("没有活跃的会话")
         return 0
 
+    # ANSI 颜色码
+    YELLOW = "\033[33m"
+    GREEN = "\033[32m"
+    RESET = "\033[0m"
+
     print("活跃会话:")
-    print("-" * 60)
-    print(f"{'名称':<20} {'PID':<10} {'tmux':<10} {'Socket'}")
-    print("-" * 60)
+    print("-" * 50)
+    print(f"{'类型':<8} {'PID':<10} {'tmux':<10} {'名称'}")
+    print("-" * 50)
 
     for s in sessions:
         tmux_status = "是" if s["tmux"] else "否"
-        print(f"{s['name']:<20} {s['pid']:<10} {tmux_status:<10} {s['socket']}")
+        cli_type = s.get('cli_type', 'claude')
+        # 根据类型选择颜色
+        if cli_type == 'codex':
+            cli_colored = f"{GREEN}{cli_type}{RESET}"
+        else:
+            cli_colored = f"{YELLOW}{cli_type}{RESET}"
+        # 带颜色的字段需要单独计算宽度
+        padding = " " * (8 - len(cli_type))
+        print(f"{cli_colored}{padding} {s['pid']:<10} {tmux_status:<10} {s['name']}")
 
-    print("-" * 60)
+    print("-" * 50)
     print(f"共 {len(sessions)} 个会话")
 
     return 0
@@ -448,9 +499,11 @@ def main():
         epilog="""
 示例:
   %(prog)s start mywork              启动名为 mywork 的会话
+  %(prog)s start mywork --cli codex  启动 codex 会话
   %(prog)s attach mywork             连接到 mywork 会话
   %(prog)s list                      列出所有会话
   %(prog)s kill mywork               终止 mywork 会话
+  %(prog)s status mywork             显示 mywork 会话状态
 
 飞书客户端:
   %(prog)s lark start                启动飞书客户端
@@ -473,6 +526,9 @@ def main():
   %(prog)s stats --detail            详细分类
   %(prog)s stats --session mywork    按会话筛选
   %(prog)s stats --reset             清空数据
+
+更新:
+  %(prog)s update                    更新到最新版本
 """
     )
 
@@ -580,12 +636,16 @@ def main():
     update_parser = subparsers.add_parser("update", help="更新 remote-claude 到最新版本")
     update_parser.set_defaults(func=cmd_update)
 
-    args = parser.parse_args()
+    args, remaining = parser.parse_known_args()
 
     if args.command is None:
         parser.print_help()
         return 0
 
+    # 将剩余参数合并到 claude_args（支持 cx/cdx 脚本中使用 -- 分隔符）
+    if args.command == "start" and hasattr(args, 'claude_args'):
+        args.claude_args = args.claude_args + remaining
+
     return args.func(args)
 
 

package/server/__init__.py

@@ -0,0 +1 @@
+# Remote Claude Server Package

package/server/server.py

@@ -9,6 +9,7 @@ Proxy Server
 """
 
 import asyncio
+import logging
 import os
 import pty
 import signal
@@ -35,9 +36,12 @@ from utils.protocol import (
 )
 from utils.session import (
     get_socket_path, get_pid_file, ensure_socket_dir,
-    generate_client_id, cleanup_session, _safe_filename, get_env_file
+    generate_client_id, cleanup_session, _safe_filename, get_env_file,
+    SOCKET_DIR
 )
 
+logger = logging.getLogger('Server')
+
 # 加载用户 .env 配置（支持 CLAUDE_COMMAND 等）
 try:
     from dotenv import load_dotenv
@@ -64,6 +68,11 @@ class _FrameObs:
     status_line: Optional[object]  # 本帧的 StatusLine（None=无）
     block_blink: bool = False      # 本帧最后一个 OutputBlock 是否 is_streaming=True
     has_background_agents: bool = False  # 底部栏是否有后台 agent 信息
+    # 用于字符变化检测（增强闪烁判断）
+    last_ob_start_row: int = -1          # 最后 OutputBlock 的起始行号（跨帧识别同一 block）
+    last_ob_indicator_char: str = ''     # 指示符字符值（pyte char.data）
+    last_ob_indicator_fg: str = ''       # 指示符前景色（pyte char.fg）
+    last_ob_indicator_bold: bool = False # 指示符 bold 属性（影响显示亮度）
 
 
 @dataclass
@@ -154,6 +163,9 @@ class OutputWatcher:
 
     def feed(self, data: bytes):
         self._renderer.feed(data)  # 直接喂持久化 screen，不再缓存原始字节
+        # 诊断日志：记录 PTY 数据到达
+        if data:
+            logger.debug(f"[diag-feed] len={len(data)} data={data[:50]!r}")
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
@@ -185,6 +197,8 @@ class OutputWatcher:
 
     async def _flush(self):
         self._pending = False
+        # 诊断日志：记录 flush 触发时间和帧窗口大小
+        logger.debug(f"[diag-flush] ts={time.time():.6f} window_size={len(self._frame_window)}")
         try:
             from utils.components import StatusLine, BottomBar, Divider, OutputBlock, AgentPanelBlock, OptionBlock
 
@@ -224,10 +238,24 @@ class OutputWatcher:
             # 4a. 记录原始帧观测（必须用未平滑的原始值）
             last_ob_blink = False
             last_ob_content = ''
+            last_ob_start_row = -1
+            last_ob_indicator_char = ''
+            last_ob_indicator_fg = ''
+            last_ob_indicator_bold = False
             for b in reversed(visible_blocks):
                 if isinstance(b, OutputBlock):
                     last_ob_blink = b.is_streaming
                     last_ob_content = b.content[:40]
+                    last_ob_start_row = b.start_row
+                    # 直接读 pyte screen buffer 获取原始字符属性（用于变化检测）
+                    if b.start_row >= 0:
+                        try:
+                            char = self._renderer.screen.buffer[b.start_row][0]
+                            last_ob_indicator_char = str(getattr(char, 'data', ''))
+                            last_ob_indicator_fg = str(getattr(char, 'fg', ''))
+                            last_ob_indicator_bold = bool(getattr(char, 'bold', False))
+                        except (KeyError, IndexError):
+                            pass
                     break
             if last_ob_blink:
                 _blink_log = open(f"/tmp/remote-claude/{self._session_name}_blink.log", "a")
@@ -241,6 +269,10 @@ class OutputWatcher:
                 status_line=raw_status_line,
                 block_blink=last_ob_blink,
                 has_background_agents=getattr(raw_bottom_bar, 'has_background_agents', False) if raw_bottom_bar else False,
+                last_ob_start_row=last_ob_start_row,
+                last_ob_indicator_char=last_ob_indicator_char,
+                last_ob_indicator_fg=last_ob_indicator_fg,
+                last_ob_indicator_bold=last_ob_indicator_bold,
             ))
             cutoff = now - self.WINDOW_SECONDS
             while self._frame_window and self._frame_window[0].ts < cutoff:
@@ -262,9 +294,27 @@ class OutputWatcher:
                 None
             )
 
-            # 4c. block blink 平滑：窗口内任意帧有 blink → streaming
-            #     修改 visible_blocks 中最后一个 OutputBlock（平滑后再合并）
+            # 4c. block blink 平滑：两种触发路径
+            # 路径1：窗口内任意帧有 pyte blink 属性
             window_block_active = any(o.block_blink for o in window_list)
+
+            # 路径2：窗口内同一 block 的指示符字符值/颜色/bold 有变化（增强闪烁判断）
+            if not window_block_active and last_ob_start_row >= 0:
+                same_block = [o for o in window_list if o.last_ob_start_row == last_ob_start_row]
+                if len(same_block) >= 2:
+                    chars = {o.last_ob_indicator_char for o in same_block if o.last_ob_indicator_char}
+                    fgs   = {o.last_ob_indicator_fg   for o in same_block if o.last_ob_indicator_fg}
+                    bolds = {o.last_ob_indicator_bold for o in same_block}
+                    if len(chars) > 1 or len(fgs) > 1 or len(bolds) > 1:
+                        window_block_active = True
+                        # 记录字符变化触发原因
+                        _blink_log = open(f"/tmp/remote-claude/{self._session_name}_blink.log", "a")
+                        _blink_log.write(
+                            f"[{time.strftime('%H:%M:%S')}] char-change row={last_ob_start_row}"
+                            f"  chars={chars}  fgs={fgs}  bolds={bolds}\n"
+                        )
+                        _blink_log.close()
+
             if window_block_active:
                 for b in reversed(visible_blocks):
                     if isinstance(b, OutputBlock):
@@ -303,6 +353,16 @@ class OutputWatcher:
                 layout_mode=self._parser.last_layout_mode,
                 cli_type=self._cli_type,
             )
+            # 诊断日志：检测最终输出中是否有同时存在 status_line 和 SystemBlock 的情况
+            if display_status:
+                status_prefix = display_status.raw[:30] if hasattr(display_status, 'raw') else str(display_status)[:30]
+                has_systemblock_with_status = any(
+                    b.__class__.__name__ == 'SystemBlock' and
+                    hasattr(b, 'content') and status_prefix in b.content
+                    for b in all_blocks
+                )
+                if has_systemblock_with_status:
+                    logger.debug(f"[diag-output] BOTH status_line and SystemBlock present! status_line={status_prefix!r}")
             self.last_window = window
 
             # 7. 输出
@@ -342,7 +402,7 @@ class OutputWatcher:
                     lines.append(f"      ansi_raw={sl.ansi_raw[:120]!r}")
                     lines.append(f"      ansi_render: {sl.ansi_indicator} {sl.ansi_raw[:120]}\x1b[0m")
                 else:
-                    lines.append(f"status_line: {sl.ansi_indicator} {sl.ansi_raw[:120]}\x1b[0m")
+                    lines.append(f"status_line: {sl.ansi_raw[:120]}\x1b[0m")
             else:
                 lines.append("status_line: None")
             # BottomBar
@@ -529,7 +589,7 @@ class ClientConnection:
             self.writer.write(data)
             await self.writer.drain()
         except Exception as e:
-            print(f"[Server] 发送消息失败 ({self.client_id}): {e}")
+            logger.warning(f"发送消息失败 ({self.client_id}): {e}")
 
     async def read_message(self) -> Optional[Message]:
         """读取一条消息"""
@@ -540,7 +600,7 @@ class ClientConnection:
                 try:
                     return decode_message(line)
                 except Exception as e:
-                    print(f"[Server] 解析消息失败: {e}")
+                    logger.warning(f"解析消息失败: {e}")
                     continue
 
             # 读取更多数据
@@ -608,6 +668,8 @@ class ProxyServer:
 
     async def start(self):
         """启动服务器"""
+        t0 = time.time()
+        logger.info(f"正在启动 (session={self.session_name})")
         ensure_socket_dir()
 
         # 清理旧的 socket 文件
@@ -615,12 +677,15 @@ class ProxyServer:
             self.socket_path.unlink()
 
         # 启动 PTY
+        t1 = time.time()
         self._start_pty()
+        logger.info(f"PTY 已启动 ({(time.time()-t1)*1000:.0f}ms)")
 
         # 写入 PID 文件
         self.pid_file.write_text(str(os.getpid()))
 
         # 启动 Unix Socket 服务器
+        t2 = time.time()
         self.server = await asyncio.start_unix_server(
             self._handle_client,
             path=str(self.socket_path)
@@ -628,11 +693,14 @@ class ProxyServer:
 
         self.running = True
         _track_stats('session', 'start', session_name=self.session_name)
-        print(f"[Server] 已启动: {self.socket_path}")
+        logger.info(f"已启动: {self.socket_path} (Socket {(time.time()-t2)*1000:.0f}ms, 总计 {(time.time()-t0)*1000:.0f}ms)")
 
         # 启动 PTY 读取任务
         asyncio.create_task(self._read_pty())
 
+        # 切换到运行阶段日志
+        self._switch_to_runtime_logging()
+
         # 等待服务器关闭
         async with self.server:
             await self.server.serve_forever()
@@ -648,6 +716,32 @@ class ProxyServer:
             return CodexParser()
         return ClaudeParser()
 
+    def _switch_to_runtime_logging(self):
+        """从启动日志切换到运行阶段日志"""
+        root_logger = logging.getLogger()
+
+        # 移除启动日志 handler（保留 stdout handler）
+        for handler in root_logger.handlers[:]:
+            if isinstance(handler, logging.FileHandler) and \
+               not hasattr(handler, '_runtime_handler') and \
+               not hasattr(handler, '_debug_handler'):
+                root_logger.removeHandler(handler)
+
+        # 添加运行阶段日志文件
+        safe_name = _safe_filename(self.session_name)
+        runtime_handler = logging.FileHandler(
+            f"{SOCKET_DIR}/{safe_name}_server.log",
+            encoding="utf-8"
+        )
+        runtime_handler.setFormatter(logging.Formatter(
+            "%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        ))
+        runtime_handler._runtime_handler = True  # 标记，方便后续清理
+        root_logger.addHandler(runtime_handler)
+
+        logger.info(f"日志已切换到运行阶段: {safe_name}_server.log")
+
     def _get_effective_cmd(self) -> str:
         """根据 cli_type 返回实际执行的命令（codex 时使用 'codex'，否则用 claude_cmd）"""
         if self.cli_type == "codex":
@@ -664,8 +758,14 @@ class ProxyServer:
         try:
             with open(env_snapshot_path) as _f:
                 _extra_env = _json.load(_f)
+            logger.info(f"环境快照已加载 ({len(_extra_env)} 个变量)")
         except Exception:
-            pass
+            logger.warning("环境快照加载失败，使用当前进程环境")
+
+        # 提前计算命令（fork 后父子进程共享，方便父进程打印和子进程执行）
+        import shlex as _shlex
+        _cmd_parts = _shlex.split(self._get_effective_cmd())
+        _full_cmd = ' '.join(_cmd_parts + self.claude_args)
 
         try:
             pid, fd = pty.fork()
@@ -688,10 +788,25 @@ class ProxyServer:
             # 清除 tmux 标识变量（PTY 数据不经过 tmux，不应让 Claude CLI 误判终端环境）
             child_env.pop('TMUX', None)
             child_env.pop('TMUX_PANE', None)
-            import shlex as _shlex
-            _cmd_parts = _shlex.split(self._get_effective_cmd())
-            os.execvpe(_cmd_parts[0], _cmd_parts + self.claude_args, child_env)
-            os._exit(1)  # execvpe 失败时兜底退出
+            try:
+                os.execvpe(_cmd_parts[0], _cmd_parts + self.claude_args, child_env)
+            except Exception as _e:
+                msg = f"启动失败: 命令 '{_cmd_parts[0]}' 无法执行: {_e}"
+                os.write(1, (msg + "\n").encode())  # 写到 PTY
+                # fork 后不能安全使用 logging，直接追加写日志文件
+                try:
+                    import time as _t
+                    _ts = _t.strftime("%Y-%m-%d %H:%M:%S")
+                    _ms = int((_t.time() % 1) * 1000)
+                    _log_line = f"{_ts}.{_ms:03d} [Server] ERROR {msg}\n"
+                    _home = os.path.expanduser("~")
+                    _log_file = os.path.join(_home, ".remote-claude", "startup.log")
+                    with open(_log_file, "a", encoding="utf-8") as _f:
+                        _f.write(_log_line)
+                except Exception:
+                    pass
+                os._exit(127)  # 127 = command not found (shell convention)
+            os._exit(1)  # 理论上不可达
         else:
             # 父进程
             self.master_fd = fd
@@ -706,7 +821,8 @@ class ProxyServer:
             fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
 
             cli_label = self.cli_type.capitalize()
-            print(f"[Server] {cli_label} 已启动 (PID: {pid}, PTY: {self.PTY_COLS}×{self.PTY_ROWS})")
+            logger.info(f"启动命令: {_full_cmd}")
+            logger.info(f"{cli_label} 已启动 (PID: {pid}, PTY: {self.PTY_COLS}×{self.PTY_ROWS})")
 
     _COALESCE_MAX = 64 * 1024  # 64KB，防止单次广播过大
 
@@ -744,11 +860,19 @@ class ProxyServer:
                     break
             except Exception as e:
                 if self.running:
-                    print(f"[Server] 读取 PTY 错误: {e}")
+                    logger.error(f"读取 PTY 错误: {e}")
                 break
 
-        # Claude 退出
-        print("[Server] Claude 已退出")
+        # Claude 退出，获取 exit code 以便诊断
+        try:
+            _, status = os.waitpid(self.child_pid, os.WNOHANG)
+            if status != 0:
+                exit_code = os.waitstatus_to_exitcode(status)
+                logger.error(f"CLI 进程异常退出 (exit_code={exit_code})")
+            else:
+                logger.info("Claude 已退出")
+        except Exception:
+            logger.info("Claude 已退出")
         await self._shutdown()
 
     def _read_pty_sync(self) -> Optional[bytes]:
@@ -766,7 +890,7 @@ class ProxyServer:
         client = ClientConnection(client_id, reader, writer)
         self.clients[client_id] = client
 
-        print(f"[Server] 客户端连接: {client_id}")
+        logger.info(f"客户端连接: {client_id}")
         _track_stats('session', 'attach', session_name=self.session_name)
 
         # 发送历史输出
@@ -782,12 +906,12 @@ class ProxyServer:
                     break
                 await self._handle_message(client_id, msg)
         except Exception as e:
-            print(f"[Server] 客户端处理错误 ({client_id}): {e}")
+            logger.error(f"客户端处理错误 ({client_id}): {e}")
         finally:
             # 清理
             del self.clients[client_id]
             client.close()
-            print(f"[Server] 客户端断开: {client_id}")
+            logger.info(f"客户端断开: {client_id}")
 
     async def _handle_message(self, client_id: str, msg: Message):
         """处理客户端消息"""
@@ -804,7 +928,7 @@ class ProxyServer:
             _track_stats('terminal', 'input', session_name=self.session_name,
                          value=len(data))
         except Exception as e:
-            print(f"[Server] 写入 PTY 错误: {e}")
+            logger.error(f"写入 PTY 错误: {e}")
 
         # 广播输入给其他客户端（飞书侧可以感知终端用户的输入内容）
         for cid, client in list(self.clients.items()):
@@ -824,7 +948,7 @@ class ProxyServer:
             winsize = struct.pack('HHHH', msg.rows, msg.cols, 0, 0)
             fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, winsize)
         except Exception as e:
-            print(f"[Server] 调整终端大小错误: {e}")
+            logger.error(f"调整终端大小错误: {e}")
 
     async def _broadcast_output(self, data: bytes):
         """广播输出给所有客户端，同时喂给 OutputWatcher 生成快照"""
@@ -863,7 +987,7 @@ class ProxyServer:
         # 清理文件
         cleanup_session(self.session_name)
 
-        print("[Server] 已关闭")
+        logger.info("已关闭")
 
 
 def run_server(session_name: str, claude_args: list = None,
@@ -903,7 +1027,29 @@ if __name__ == "__main__":
                         help="debug 日志输出完整诊断信息（indicator、repr 等）")
     args = parser.parse_args()
 
+    # 配置日志：启动阶段输出到 stdout + startup.log
+    from utils.session import USER_DATA_DIR, _safe_filename
+    USER_DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    # 先配置基本输出（stdout）
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+
+    # 添加启动日志 handler
+    startup_handler = logging.FileHandler(USER_DATA_DIR / "startup.log", encoding="utf-8")
+    startup_handler.setFormatter(logging.Formatter(
+        "%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    ))
+    startup_handler._startup_handler = True  # 标记为启动日志 handler
+    logging.getLogger().addHandler(startup_handler)
+
     claude_cmd = os.environ.get("CLAUDE_COMMAND", "claude")
+    logger.info(f"CLAUDE_COMMAND={claude_cmd!r}")
     run_server(args.session_name, args.claude_args, claude_cmd=claude_cmd,
                cli_type=args.cli_type,
                debug_screen=args.debug_screen, debug_verbose=args.debug_verbose)

package/server/shared_state.py

@@ -93,6 +93,7 @@ class SharedStateWriter:
     """写端：Server 进程持有，生命周期与 ProxyServer 相同"""
 
     def __init__(self, session_name: str):
+        self._session_name = session_name
         self._path = get_mq_path(session_name)
         self._path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -139,7 +140,7 @@ class SharedStateWriter:
                 "input_area_text": window.input_area_text,
                 "timestamp": window.timestamp,
                 "layout_mode": window.layout_mode,
-                "cli_type": getattr(window, "cli_type", "claude"),
+                "cli_type": getattr(window, "cli_type", "unknown"),
             }
             data = json.dumps(snapshot, ensure_ascii=False).encode('utf-8')
 
@@ -177,7 +178,7 @@ class SharedStateReader:
     反映跨进程写入更新的问题。每次 read() 打开文件读取后关闭，保证读到最新数据。
     """
 
-    _EMPTY = {"blocks": [], "status_line": None, "bottom_bar": None, "option_block": None}
+    _EMPTY = {"blocks": [], "status_line": None, "bottom_bar": None, "option_block": None, "cli_type": "claude"}
 
     def __init__(self, session_name: str):
         self._path = get_mq_path(session_name)

package/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Remote Claude 工具模块
+"""

package/utils/session.py

@@ -101,6 +101,8 @@ def tmux_create_session(session_name: str, command: str, detached: bool = True)
     args.extend(["-x", "200", "-y", "50"])  # 默认大小
     args.append(command)
 
+    import logging as _logging
+    _logging.getLogger('Start').info(f"tmux_cmd: {' '.join(args)}")
     result = subprocess.run(args, capture_output=True)
     if result.returncode == 0:
         # 启用鼠标支持，允许在 tmux 窗口内用鼠标滚轮查看历史输出
@@ -221,10 +223,30 @@ def list_active_sessions() -> List[dict]:
                 import datetime
                 try:
                     mtime = pid_file.stat().st_mtime
-                    start_time = datetime.datetime.fromtimestamp(mtime).strftime("%H:%M")
+                    start_time = datetime.datetime.fromtimestamp(mtime).strftime("%m-%d %H:%M")
                 except OSError:
                     mtime = 0
                     start_time = "?"
+
+                # 读取 .mq 文件获取 cli_type（避免循环导入，在函数内导入）
+                try:
+                    import sys
+                    from pathlib import Path
+                    import logging
+                    project_root = str(Path(__file__).parent.parent)
+                    if project_root not in sys.path:
+                        sys.path.insert(0, project_root)
+                    from server.shared_state import SharedStateReader
+                    reader = SharedStateReader(session_name)
+                    snapshot = reader.read()
+                    cli_type = snapshot.get("cli_type", "claude")
+                except Exception as e:
+                    # 添加详细日志记录，便于诊断问题
+                    import logging
+                    logger = logging.getLogger('Session')
+                    logger.warning(f"读取共享内存 cli_type 失败: session={session_name}, error={e}")
+                    cli_type = "claude"  # 读取失败时使用默认值
+
                 sessions.append({
                     "name": session_name,
                     "socket": str(sock_file),
@@ -232,7 +254,8 @@ def list_active_sessions() -> List[dict]:
                     "cwd": cwd or "",
                     "start_time": start_time,
                     "mtime": mtime,
-                    "tmux": tmux_session_exists(session_name)
+                    "tmux": tmux_session_exists(session_name),
+                    "cli_type": cli_type
                 })
             except (ProcessLookupError, ValueError, OSError):
                 # 进程不存在或文件被并发清理，清理残留文件