remote-claude 0.2.10 → 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/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.10",
+  "version": "0.2.11",
   "description": "双端共享 Claude CLI 工具",
   "bin": {
     "remote-claude": "bin/remote-claude",

package/remote_claude.py

@@ -3,11 +3,14 @@
 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
@@ -183,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
@@ -483,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                启动飞书客户端
@@ -508,6 +526,9 @@ def main():
   %(prog)s stats --detail            详细分类
   %(prog)s stats --session mywork    按会话筛选
   %(prog)s stats --reset             清空数据
+
+更新:
+  %(prog)s update                    更新到最新版本
 """
     )
 
@@ -615,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

@@ -698,6 +698,9 @@ class ProxyServer:
         # 启动 PTY 读取任务
         asyncio.create_task(self._read_pty())
 
+        # 切换到运行阶段日志
+        self._switch_to_runtime_logging()
+
         # 等待服务器关闭
         async with self.server:
             await self.server.serve_forever()
@@ -713,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":
@@ -998,20 +1027,27 @@ if __name__ == "__main__":
                         help="debug 日志输出完整诊断信息（indicator、repr 等）")
     args = parser.parse_args()
 
-    # 配置日志：写文件（供故障诊断）+ stdout（供 tmux attach 时查看）
-    from utils.session import USER_DATA_DIR
+    # 配置日志：启动阶段输出到 stdout + startup.log
+    from utils.session import USER_DATA_DIR, _safe_filename
     USER_DATA_DIR.mkdir(parents=True, exist_ok=True)
-    _log_path = USER_DATA_DIR / "startup.log"
+
+    # 先配置基本输出（stdout）
     logging.basicConfig(
-        level=logging.DEBUG,
+        level=logging.INFO,
         format="%(asctime)s.%(msecs)03d [%(name)s] %(levelname)s %(message)s",
         datefmt="%Y-%m-%d %H:%M:%S",
-        handlers=[
-            logging.FileHandler(_log_path, encoding="utf-8"),
-            logging.StreamHandler(sys.stdout),
-        ],
+        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,

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

@@ -223,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),
@@ -234,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):
                 # 进程不存在或文件被并发清理，清理残留文件