remote-claude 1.0.3 → 1.0.5

package/server/server.py

@@ -9,6 +9,7 @@ Proxy Server
 """
 
 import asyncio
+import atexit
 import logging
 import os
 import pty
@@ -35,8 +36,8 @@ from utils.protocol import (
     encode_message, decode_message
 )
 from utils.session import (
-    get_socket_path, get_pid_file, ensure_socket_dir,
-    generate_client_id, cleanup_session, _safe_filename, get_env_file,
+    get_socket_path, get_pid_file, get_name_file, ensure_socket_dir,
+    generate_client_id, cleanup_session, _safe_filename, _log_filename, get_env_file,
     SOCKET_DIR
 )
 
@@ -184,12 +185,12 @@ class OutputWatcher:
         self._on_snapshot = on_snapshot  # 回调：写共享内存
         self._debug_screen = debug_screen  # --debug-screen 开启后才写 _screen.log
         self._debug_verbose = debug_verbose  # --debug-verbose 开启后输出 indicator/repr 等诊断信息
-        safe_name = _safe_filename(session_name)
-        self._debug_file = f"/tmp/remote-claude/{safe_name}_messages.log"
+        log_name = _log_filename(session_name)
+        self._debug_file = f"/tmp/remote-claude/{log_name}_messages.log"
         # PTY 原始字节流日志（仅 --debug-screen 开启时使用）
         self._raw_log_fd = None
         if debug_screen:
-            raw_log_path = f"/tmp/remote-claude/{safe_name}_pty_raw.log"
+            raw_log_path = f"/tmp/remote-claude/{log_name}_pty_raw.log"
             try:
                 self._raw_log_fd = open(raw_log_path, "a", encoding="ascii", buffering=1)
             except Exception:
@@ -663,7 +664,7 @@ class OutputWatcher:
         每个字符的 fg/bg 颜色通过 ANSI SGR 序列直接嵌入，
         cat _screen.log 即可在终端看到与 pyte 渲染一致的着色效果。
         """
-        base = f"/tmp/remote-claude/{_safe_filename(self._session_name)}"
+        base = f"/tmp/remote-claude/{_log_filename(self._session_name)}"
         try:
             # pyte 屏幕快照（覆盖写，只保留最新一帧）
             screen_path = base + "_screen.log"
@@ -803,12 +804,13 @@ class ProxyServer:
     """Proxy Server"""
 
     def __init__(self, session_name: str, claude_args: list = None,
-                 claude_cmd: str = "claude",
+                 claude_cmd: str = "claude", codex_cmd: str = "codex",
                  cli_type: str = "claude",
                  debug_screen: bool = False, debug_verbose: bool = False):
         self.session_name = session_name
         self.claude_args = claude_args or []
         self.claude_cmd = claude_cmd
+        self.codex_cmd = codex_cmd
         self.cli_type = cli_type
         self.debug_screen = debug_screen
         self.debug_verbose = debug_verbose
@@ -863,6 +865,9 @@ class ProxyServer:
         # 写入 PID 文件
         self.pid_file.write_text(str(os.getpid()))
 
+        # 写入会话名映射文件（供 list_active_sessions 恢复原始显示名）
+        get_name_file(self.session_name).write_text(self.session_name)
+
         # 启动 Unix Socket 服务器
         t2 = time.time()
         self.server = await asyncio.start_unix_server(
@@ -915,9 +920,9 @@ class ProxyServer:
         logger.info(f"已重定向 stderr 到 {error_log_path}")
 
         # 添加运行阶段日志文件
-        safe_name = _safe_filename(self.session_name)
+        log_name = _log_filename(self.session_name)
         runtime_handler = logging.FileHandler(
-            f"{SOCKET_DIR}/{safe_name}_server.log",
+            f"{SOCKET_DIR}/{log_name}_server.log",
             encoding="utf-8"
         )
         runtime_handler.setFormatter(logging.Formatter(
@@ -930,7 +935,7 @@ class ProxyServer:
         # DEBUG 级别时额外记录调试日志到独立文件
         if SERVER_LOG_LEVEL_MAP == logging.DEBUG:
             debug_handler = logging.FileHandler(
-                f"{SOCKET_DIR}/{safe_name}_debug.log",
+                f"{SOCKET_DIR}/{log_name}_debug.log",
                 encoding="utf-8"
             )
             debug_handler.setLevel(logging.DEBUG)
@@ -940,14 +945,14 @@ class ProxyServer:
             ))
             debug_handler._debug_handler = True  # 标记，方便后续清理
             root_logger.addHandler(debug_handler)
-            logger.info(f"已启用 DEBUG 日志: {safe_name}_debug.log")
+            logger.info(f"已启用 DEBUG 日志: {log_name}_debug.log")
 
-        logger.info(f"日志已切换到运行阶段: {safe_name}_server.log")
+        logger.info(f"日志已切换到运行阶段: {log_name}_server.log")
 
     def _get_effective_cmd(self) -> str:
-        """根据 cli_type 返回实际执行的命令（codex 时使用 'codex'，否则用 claude_cmd）"""
+        """根据 cli_type 返回实际执行的命令"""
         if self.cli_type == "codex":
-            return "codex"
+            return self.codex_cmd
         return self.claude_cmd
 
     def _start_pty(self):
@@ -1193,21 +1198,27 @@ class ProxyServer:
 
 
 def run_server(session_name: str, claude_args: list = None,
-               claude_cmd: str = "claude",
+               claude_cmd: str = "claude", codex_cmd: str = "codex",
                cli_type: str = "claude",
                debug_screen: bool = False, debug_verbose: bool = False):
     """运行服务器"""
     server = ProxyServer(session_name, claude_args, claude_cmd=claude_cmd,
-                         cli_type=cli_type,
+                         codex_cmd=codex_cmd, cli_type=cli_type,
                          debug_screen=debug_screen, debug_verbose=debug_verbose)
 
+    # atexit 兜底：任何退出路径（包括被 SIGKILL 以外的信号强杀）都记录日志
+    atexit.register(lambda: logger.warning("server 进程退出（atexit）[session=%s]", session_name))
+
     # 信号处理
     def signal_handler(signum, frame):
-        print("\n[Server] 收到退出信号")
+        sig_name = signal.Signals(signum).name if hasattr(signal, 'Signals') else str(signum)
+        logger.warning("收到退出信号: %s (signum=%d)", sig_name, signum)
+        print(f"\n[Server] 收到退出信号: {sig_name}")
         asyncio.create_task(server._shutdown())
 
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGHUP, signal_handler)  # tmux 崩溃时也能优雅退出
 
     # 运行
     try:
@@ -1251,7 +1262,8 @@ if __name__ == "__main__":
     logging.getLogger().addHandler(startup_handler)
 
     claude_cmd = os.environ.get("CLAUDE_COMMAND", "claude")
-    logger.info(f"CLAUDE_COMMAND={claude_cmd!r}")
+    codex_cmd = os.environ.get("CODEX_COMMAND", "codex")
+    logger.info(f"CLAUDE_COMMAND={claude_cmd!r}, CODEX_COMMAND={codex_cmd!r}")
     run_server(args.session_name, args.claude_args, claude_cmd=claude_cmd,
-               cli_type=args.cli_type,
+               codex_cmd=codex_cmd, cli_type=args.cli_type,
                debug_screen=args.debug_screen, debug_verbose=args.debug_verbose)

package/utils/session.py

@@ -20,11 +20,6 @@ SOCKET_DIR = Path("/tmp/remote-claude")
 USER_DATA_DIR = Path.home() / ".remote-claude"
 TMUX_SESSION_PREFIX = "rc-"
 
-# macOS AF_UNIX sun_path 限制 104 字节
-# /tmp/remote-claude/ = 19 字节, .sock = 5 字节
-_MAX_SOCKET_PATH = 104
-_MAX_FILENAME = _MAX_SOCKET_PATH - len(str(SOCKET_DIR)) - 1 - len(".sock")
-
 
 def get_env_file() -> Path:
     """获取 .env 配置文件路径"""
@@ -47,14 +42,15 @@ def ensure_user_data_dir():
 
 
 def _safe_filename(session_name: str) -> str:
-    """将会话名转为安全文件名（/ 和 . 替换为 _），超长时用完整 MD5"""
-    name = session_name.replace('/', '_').replace('.', '_')
-    if len(name) <= _MAX_FILENAME:
-        return name
-    # 超长：直接用完整 32 字符 MD5，彻底避免路径超限
+    """将会话名转为安全文件名（MD5 hash）"""
     return hashlib.md5(session_name.encode()).hexdigest()
 
 
+def _log_filename(session_name: str) -> str:
+    """将会话名转为可读的安全文件名（用于日志文件，不受路径长度限制）"""
+    return session_name.replace("/", "_").replace(".", "_").replace(" ", "_")
+
+
 def get_socket_path(session_name: str) -> Path:
     """获取会话的 socket 路径"""
     return SOCKET_DIR / f"{_safe_filename(session_name)}.sock"
@@ -75,6 +71,11 @@ def get_env_snapshot_path(session_name: str) -> Path:
     return SOCKET_DIR / f"{_safe_filename(session_name)}_env.json"
 
 
+def get_name_file(session_name: str) -> Path:
+    """获取会话名映射文件路径（存储原始会话名，供 list 恢复显示名）"""
+    return SOCKET_DIR / f"{_safe_filename(session_name)}.name"
+
+
 def ensure_socket_dir():
     """确保 socket 目录存在"""
     SOCKET_DIR.mkdir(parents=True, exist_ok=True)
@@ -221,13 +222,19 @@ def get_process_cwd(pid: int) -> Optional[str]:
 
 
 def list_active_sessions() -> List[dict]:
-    """列出所有活跃会话"""
+    """列出所有活跃会话
+
+    注意：sock 文件的 stem 已经是 MD5 哈希（_safe_filename 的输出），
+    因此直接用 stem 构造 PID/MQ 文件路径，不再经过 get_pid_file 等函数
+    （否则会被 _safe_filename 二次哈希）。
+    """
     ensure_socket_dir()
     sessions = []
 
     for sock_file in SOCKET_DIR.glob("*.sock"):
-        session_name = sock_file.stem
-        pid_file = get_pid_file(session_name)
+        # stem 已经是 _safe_filename() 的输出（MD5 哈希）
+        safe_name = sock_file.stem
+        pid_file = SOCKET_DIR / f"{safe_name}.pid"
 
         # 检查 socket 文件是否有效（进程是否存在）
         if pid_file.exists():
@@ -237,6 +244,17 @@ def list_active_sessions() -> List[dict]:
                 os.kill(pid, 0)
                 # 获取进程 CWD
                 cwd = get_process_cwd(pid)
+
+                # 恢复原始会话名（从 .name 文件读取，不存在则回退到哈希值）
+                name_file = SOCKET_DIR / f"{safe_name}.name"
+                if name_file.exists():
+                    try:
+                        display_name = name_file.read_text().strip()
+                    except OSError:
+                        display_name = safe_name
+                else:
+                    display_name = safe_name
+
                 # 获取启动时间（PID 文件的修改时间，文件可能已被并发清理）
                 import datetime
                 try:
@@ -246,7 +264,7 @@ def list_active_sessions() -> List[dict]:
                     mtime = 0
                     start_time = "?"
 
-                # 读取 .mq 文件获取 cli_type（避免循环导入，在函数内导入）
+                # 读取 .mq 文件获取 cli_type
                 try:
                     import sys
                     from pathlib import Path
@@ -255,29 +273,38 @@ def list_active_sessions() -> List[dict]:
                     if project_root not in sys.path:
                         sys.path.insert(0, project_root)
                     from server.shared_state import SharedStateReader
-                    reader = SharedStateReader(session_name)
+                    # 用 _BypassHashReader 直接传入 safe_name 避免二次哈希
+                    mq_path = SOCKET_DIR / f"{safe_name}.mq"
+                    reader = SharedStateReader.__new__(SharedStateReader)
+                    reader._path = mq_path
                     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"  # 读取失败时使用默认值
+                    logger.warning(f"读取共享内存 cli_type 失败: session={display_name}, error={e}")
+                    cli_type = "claude"
+
+                # tmux 会话名也用 safe_name 直接构造
+                tmux_name = f"{TMUX_SESSION_PREFIX}{safe_name}"
+                tmux_exists = subprocess.run(
+                    ["tmux", "has-session", "-t", tmux_name],
+                    capture_output=True
+                ).returncode == 0
 
                 sessions.append({
-                    "name": session_name,
+                    "name": display_name,
                     "socket": str(sock_file),
                     "pid": pid,
                     "cwd": cwd or "",
                     "start_time": start_time,
                     "mtime": mtime,
-                    "tmux": tmux_session_exists(session_name),
+                    "tmux": tmux_exists,
                     "cli_type": cli_type
                 })
             except (ProcessLookupError, ValueError, OSError):
                 # 进程不存在或文件被并发清理，清理残留文件
-                cleanup_session(session_name)
+                _cleanup_by_safe_name(safe_name)
         else:
             # 没有 PID 文件，清理 socket
             sock_file.unlink(missing_ok=True)
@@ -287,14 +314,32 @@ def list_active_sessions() -> List[dict]:
 
 
 def cleanup_session(session_name: str):
-    """清理会话残留文件"""
-    sock_path = get_socket_path(session_name)
-    pid_file = get_pid_file(session_name)
+    """清理会话残留文件（传入原始会话名，经过 _safe_filename 转换）"""
+    safe = _safe_filename(session_name)
+    _cleanup_by_safe_name(safe, session_name)
 
-    sock_path.unlink(missing_ok=True)
-    pid_file.unlink(missing_ok=True)
-    get_mq_path(session_name).unlink(missing_ok=True)
-    get_env_snapshot_path(session_name).unlink(missing_ok=True)
+
+def _cleanup_by_safe_name(safe_name: str, session_name: Optional[str] = None):
+    """清理会话残留文件（传入已经是 MD5 哈希的 safe_name，不再二次哈希）"""
+    # 尝试从 .name 文件读取原始会话名（用于清理可读日志文件）
+    if session_name is None:
+        name_file = SOCKET_DIR / f"{safe_name}.name"
+        if name_file.exists():
+            try:
+                session_name = name_file.read_text().strip()
+            except OSError:
+                pass
+    for suffix in [".sock", ".pid", ".mq", ".name", "_env.json"]:
+        (SOCKET_DIR / f"{safe_name}{suffix}").unlink(missing_ok=True)
+    # 清理带后缀的日志文件（使用可读文件名）
+    log_suffixes = ["_messages.log", "_screen.log", "_server.log", "_debug.log", "_pty_raw.log"]
+    if session_name:
+        log_name = _log_filename(session_name)
+        for suffix in log_suffixes:
+            (SOCKET_DIR / f"{log_name}{suffix}").unlink(missing_ok=True)
+    # 兼容旧的 MD5 日志文件
+    for suffix in log_suffixes:
+        (SOCKET_DIR / f"{safe_name}{suffix}").unlink(missing_ok=True)
 
 
 def is_session_active(session_name: str) -> bool:
@@ -346,8 +391,14 @@ def is_lark_running() -> bool:
     try:
         pid = int(pid_file.read_text().strip())
         os.kill(pid, 0)
-        return True
-    except (ProcessLookupError, ValueError, OSError):
+        # 额外验证：确认进程确实是我们的 lark_client（防止 PID 复用误判）
+        import subprocess
+        result = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "command="],
+            capture_output=True, text=True, timeout=2
+        )
+        return "lark_client" in result.stdout
+    except (ProcessLookupError, ValueError, OSError, Exception):
         return False
 
 

package/scripts/check-env.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-# 检查 .env 中 FEISHU_APP_ID/APP_SECRET 是否已配置，未配置则交互引导
-# 用法: source scripts/check-env.sh "$INSTALL_DIR"
-
-INSTALL_DIR="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
-ENV_FILE="$HOME/.remote-claude/.env"
-mkdir -p "$HOME/.remote-claude"
-ENV_OK=false
-
-if [ -f "$ENV_FILE" ]; then
-    APP_ID=$(grep -E '^FEISHU_APP_ID=' "$ENV_FILE" | cut -d= -f2)
-    APP_SECRET=$(grep -E '^FEISHU_APP_SECRET=' "$ENV_FILE" | cut -d= -f2)
-    if [ -n "$APP_ID" ] && [ "$APP_ID" != "cli_xxxxx" ] && \
-       [ -n "$APP_SECRET" ] && [ "$APP_SECRET" != "xxxxx" ]; then
-        ENV_OK=true
-    fi
-fi
-
-if [ "$ENV_OK" = false ]; then
-    echo ""
-    echo "飞书客户端尚未配置，需要填写应用凭证。"
-    echo "（在飞书开发者后台创建应用获取: https://open.feishu.cn/app）"
-    echo ""
-    echo -e "\033[33m飞书机器人配置文档参考：https://github.com/yyzybb537/remote_claude\033[0m"
-    echo ""
-    read -p "FEISHU_APP_ID: " INPUT_APP_ID
-    read -p "FEISHU_APP_SECRET: " INPUT_APP_SECRET
-
-    if [ -z "$INPUT_APP_ID" ] || [ -z "$INPUT_APP_SECRET" ]; then
-        echo "错误: APP_ID 和 APP_SECRET 不能为空"
-        exit 1
-    fi
-
-    cp "$INSTALL_DIR/.env.example" "$ENV_FILE"
-    sed -i.bak "s/^FEISHU_APP_ID=.*/FEISHU_APP_ID=$INPUT_APP_ID/" "$ENV_FILE"
-    sed -i.bak "s/^FEISHU_APP_SECRET=.*/FEISHU_APP_SECRET=$INPUT_APP_SECRET/" "$ENV_FILE"
-    rm -f "$ENV_FILE.bak"
-
-    echo ""
-    echo "配置已保存到 $ENV_FILE"
-    echo "（可选配置, 如"白名单"等可稍后编辑该文件）"
-    echo ""
-fi