remote-claude 0.2.13 → 0.2.15

package/server/server.py

@@ -68,6 +68,63 @@ except Exception:
 HISTORY_BUFFER_SIZE = 100 * 1024  # 100KB
 
 
+# ── VirtualScreen：将 HistoryScreen.history.top + buffer 合并为统一视图 ──────
+
+class _VirtualBuffer:
+    """统一访问接口：history rows [0..offset) + screen.buffer [offset..offset+lines)"""
+    __slots__ = ('_history', '_buffer', '_offset')
+
+    def __init__(self, history, buffer, offset):
+        self._history = history   # list[dict]，来自 list(screen.history.top)
+        self._buffer = buffer     # pyte screen.buffer
+        self._offset = offset     # len(history)
+
+    def __getitem__(self, row):
+        if row < self._offset:
+            return self._history[row]
+        return self._buffer[row - self._offset]
+
+
+class _VirtualCursor:
+    """模拟 pyte cursor，y 偏移 history 行数"""
+    __slots__ = ('y',)
+
+    def __init__(self, y: int):
+        self.y = y
+
+
+class VirtualScreen:
+    """HistoryScreen wrapper：将 history.top + buffer 合并为 parser 可直接读取的统一屏幕视图。
+
+    parser 无需任何修改：
+    - _split_regions 从 cursor.y+5 向上扫描找分割线，先找到当前屏幕中的分割线就停了
+    - output_rows 自然包含 history 中的行号（0 到 offset-1）
+    - _get_row_text/buffer[row] 通过 VirtualBuffer 透明返回对应行
+    """
+    __slots__ = ('_screen', '_history', '_offset')
+
+    def __init__(self, screen):
+        self._screen = screen
+        self._history = list(screen.history.top) if hasattr(screen, 'history') else []
+        self._offset = len(self._history)
+
+    @property
+    def columns(self):
+        return self._screen.columns
+
+    @property
+    def lines(self):
+        return self._offset + self._screen.lines
+
+    @property
+    def cursor(self):
+        return _VirtualCursor(self._offset + self._screen.cursor.y)
+
+    @property
+    def buffer(self):
+        return _VirtualBuffer(self._history, self._screen.buffer, self._offset)
+
+
 # ── 全量快照架构 ─────────────────────────────────────────────────────────────
 
 @dataclass
@@ -129,9 +186,17 @@ class OutputWatcher:
         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"
+        # PTY 原始字节流日志（仅 --debug-screen 开启时使用）
+        self._raw_log_fd = None
+        if debug_screen:
+            raw_log_path = f"/tmp/remote-claude/{safe_name}_pty_raw.log"
+            try:
+                self._raw_log_fd = open(raw_log_path, "a", encoding="ascii", buffering=1)
+            except Exception:
+                pass
         # 持久化 pyte 渲染器：PTY 数据直接实时喂入，flush 时直接读 screen
         from rich_text_renderer import RichTextRenderer
-        self._renderer = RichTextRenderer(columns=cols, lines=rows)
+        self._renderer = RichTextRenderer(columns=cols, lines=rows, debug_stream=debug_screen)
         # 持久化解析器（跨帧保留 dot_row_cache）；由调用方注入（可插拔架构）
         import logging as _logging
         _logging.getLogger('ComponentParser').setLevel(_logging.DEBUG)
@@ -175,6 +240,15 @@ class OutputWatcher:
         # 诊断日志：记录 PTY 数据到达
         if data:
             logger.debug(f"[diag-feed] len={len(data)} data={data[:50]!r}")
+        # 改动3：--debug-screen 开启时追加原始字节到 _pty_raw.log（base64 编码）
+        if self._raw_log_fd is not None and data:
+            try:
+                import base64 as _b64
+                ts = time.strftime('%H:%M:%S') + f'.{int(time.time() * 1000) % 1000:03d}'
+                encoded = _b64.b64encode(data).decode('ascii')
+                self._raw_log_fd.write(f"{ts} len={len(data)} {encoded}\n")
+            except Exception:
+                pass
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
@@ -217,8 +291,10 @@ class OutputWatcher:
                 self._write_screen_debug(self._renderer.screen)
             t1 = time.time()
 
-            # 1. 解析（ScreenParser 不改；pyte 已在 feed() 里实时更新）
-            components = self._parser.parse(self._renderer.screen)
+            # 1. 构建 VirtualScreen（history.top + buffer）并解析
+            # _write_screen_debug 仍用原始 screen（只写当前帧快照，不含 history）
+            vscreen = VirtualScreen(self._renderer.screen)
+            components = self._parser.parse(vscreen)
             input_text = self._parser.last_input_text
             input_ansi_text = self._parser.last_input_ansi_text
 
@@ -256,10 +332,10 @@ class OutputWatcher:
                     last_ob_blink = b.is_streaming
                     last_ob_content = b.content[:40]
                     last_ob_start_row = b.start_row
-                    # 直接读 pyte screen buffer 获取原始字符属性（用于变化检测）
+                    # 读 vscreen.buffer 获取原始字符属性（支持 history 行）
                     if b.start_row >= 0:
                         try:
-                            char = self._renderer.screen.buffer[b.start_row][0]
+                            char = vscreen.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))
@@ -329,7 +405,7 @@ class OutputWatcher:
                         b.is_streaming = True
                         break
 
-            # 5. 直接使用 visible_blocks（pyte 2000 行已保留全部历史）
+            # 5. 直接使用 visible_blocks（VirtualScreen 已包含 history.top + 当前屏幕）
             all_blocks = visible_blocks
 
             # 5b. 后台 agent 摘要：BottomBar 有 agent 信息但面板未展开时，
@@ -513,8 +589,80 @@ class OutputWatcher:
         except Exception:
             pass
 
+    @staticmethod
+    def _char_to_ansi(char) -> str:
+        """将 pyte Char 的颜色/样式属性转为 ANSI SGR 前缀序列。
+
+        返回带 ANSI 转义的字符字符串，调用方需在行尾追加 \\033[0m 重置。
+        仅在属性非默认时才输出对应 SGR，降低输出体积。
+        """
+        # 标准颜色名到 ANSI 码
+        _FG_NAMES = {
+            'black': 30, 'red': 31, 'green': 32, 'yellow': 33,
+            'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37,
+            'brown': 33,  # pyte 把 ANSI 33 解析为 brown
+        }
+        _BG_NAMES = {
+            'black': 40, 'red': 41, 'green': 42, 'yellow': 43,
+            'blue': 44, 'magenta': 45, 'cyan': 46, 'white': 47,
+            'brown': 43,
+        }
+        _BRIGHT_FG = {
+            'brightblack': 90, 'brightred': 91, 'brightgreen': 92, 'brightyellow': 93,
+            'brightblue': 94, 'brightmagenta': 95, 'brightcyan': 96, 'brightwhite': 97,
+        }
+        _BRIGHT_BG = {
+            'brightblack': 100, 'brightred': 101, 'brightgreen': 102, 'brightyellow': 103,
+            'brightblue': 104, 'brightmagenta': 105, 'brightcyan': 106, 'brightwhite': 107,
+        }
+
+        sgr = []
+
+        # bold / blink
+        if getattr(char, 'bold', False):
+            sgr.append('1')
+        if getattr(char, 'blink', False):
+            sgr.append('5')
+
+        # 前景色
+        fg = getattr(char, 'fg', 'default')
+        if fg and fg != 'default':
+            fg_low = str(fg).lower()
+            if fg_low in _FG_NAMES:
+                sgr.append(str(_FG_NAMES[fg_low]))
+            elif fg_low in _BRIGHT_FG:
+                sgr.append(str(_BRIGHT_FG[fg_low]))
+            elif len(fg_low) == 6 and all(c in '0123456789abcdef' for c in fg_low):
+                # 24-bit true color
+                r = int(fg_low[0:2], 16)
+                g = int(fg_low[2:4], 16)
+                b = int(fg_low[4:6], 16)
+                sgr.append(f'38;2;{r};{g};{b}')
+
+        # 背景色
+        bg = getattr(char, 'bg', 'default')
+        if bg and bg != 'default':
+            bg_low = str(bg).lower()
+            if bg_low in _BG_NAMES:
+                sgr.append(str(_BG_NAMES[bg_low]))
+            elif bg_low in _BRIGHT_BG:
+                sgr.append(str(_BRIGHT_BG[bg_low]))
+            elif len(bg_low) == 6 and all(c in '0123456789abcdef' for c in bg_low):
+                r = int(bg_low[0:2], 16)
+                g = int(bg_low[2:4], 16)
+                b = int(bg_low[4:6], 16)
+                sgr.append(f'48;2;{r};{g};{b}')
+
+        if sgr:
+            return f'\033[{";".join(sgr)}m{char.data}\033[0m'
+        return char.data
+
     def _write_screen_debug(self, screen):
-        """将 pyte 屏幕内容写入调试文件（_screen.log）"""
+        """将 pyte 屏幕内容写入调试文件（_screen.log）
+
+        每个字符的 fg/bg 颜色通过 ANSI SGR 序列直接嵌入，
+        cat _screen.log 即可在终端看到与 pyte 渲染一致的着色效果。
+        """
         base = f"/tmp/remote-claude/{_safe_filename(self._session_name)}"
         try:
             # pyte 屏幕快照（覆盖写，只保留最新一帧）
@@ -526,20 +674,51 @@ class OutputWatcher:
                 "",
             ]
             for row in range(scan_limit + 1):
-                buf = [' '] * screen.columns
-                for col, char in screen.buffer[row].items():
-                    buf[col] = char.data
-                rstripped = ''.join(buf).rstrip()
-                if not rstripped:
-                    lines.append(f"{row:3d} |")
+                # 构建带颜色的行内容（用于终端直接 cat 显示）
+                colored_buf = []
+                plain_buf = [' '] * screen.columns
+                for col in range(screen.columns):
+                    char = screen.buffer[row].get(col)
+                    if char is None:
+                        colored_buf.append(' ')
+                        continue
+                    plain_buf[col] = char.data
+                    colored_buf.append(self._char_to_ansi(char))
+
+                rstripped_plain = ''.join(plain_buf).rstrip()
+                if not rstripped_plain:
+                    # 检查是否有背景色（对 Codex 背景色分割线很重要）
+                    row_bgs = set()
+                    for col in range(screen.columns):
+                        char = screen.buffer[row].get(col)
+                        if char is not None:
+                            bg = getattr(char, 'bg', 'default')
+                            if bg and bg != 'default':
+                                row_bgs.add(str(bg))
+                    if row_bgs:
+                        bg_str = ','.join(sorted(row_bgs))
+                        lines.append(f"{row:3d} |[bg:{bg_str} ···]")
+                    else:
+                        lines.append(f"{row:3d} |")
                     continue
+
                 try:
                     c0 = screen.buffer[row][0]
                     col0_blink = getattr(c0, "blink", False)
                 except (KeyError, IndexError):
                     col0_blink = False
+
                 blink_mark = "B" if col0_blink else " "
-                lines.append(f"{row:3d}{blink_mark}|{rstripped}")
+                # rstrip 着色内容：找最后一个有内容的列号（正确处理 CJK 占 2 列的情况）
+                # plain_buf 按列号索引，len(rstripped_plain) 会因 CJK 字符导致列数偏小
+                last_col = 0
+                for col in range(screen.columns - 1, -1, -1):
+                    if plain_buf[col] != ' ':
+                        last_col = col + 1
+                        break
+                colored_line = ''.join(colored_buf[:last_col])
+                lines.append(f"{row:3d}{blink_mark}|{colored_line}")
+
             with open(screen_path, "w", encoding="utf-8") as f:
                 f.write("\n".join(lines))
         except Exception:
@@ -707,7 +886,7 @@ class ProxyServer:
 
     # PTY 终端尺寸：与 lark_client 的 pyte 渲染器保持一致
     PTY_COLS = 220
-    PTY_ROWS = 2000
+    PTY_ROWS = 100  # 行数缩减至 100，历史内容通过 HistoryScreen.history.top 保存（5000 行容量）
 
     def _get_parser(self):
         """根据 cli_type 返回对应的解析器实例"""
@@ -965,7 +1144,7 @@ class ProxyServer:
         """处理终端大小变化：同步更新 PTY 和 pyte 渲染尺寸，清空 raw buffer。
         Claude 收到 SIGWINCH 后会全屏重绘，buffer 清空后自然恢复为新尺寸的完整屏幕数据。"""
         try:
-            # output_watcher 的 rows 固定为 PTY_ROWS（2000），不跟随客户端终端尺寸变化
+            # output_watcher 的 rows 固定为 PTY_ROWS（100），不跟随客户端终端尺寸变化
             # terminal client 直接渲染 PTY 原始输出，不依赖 output_watcher，无需同步 rows
             self.output_watcher.resize(msg.cols, self.PTY_ROWS)
             winsize = struct.pack('HHHH', msg.rows, msg.cols, 0, 0)