@xiaoqiong0v0/opencode-ssh-tool 0.5.1 → 0.6.1

package/dist/server.js

@@ -1,15 +1,15 @@
-// 本地 HTTP+WebSocket 服务：HTTP 提供页面/静态资源，WS 承载全部实时数据（会话列表 / transcript 快照 / 运行增量）
-// 前端页面为独立 web/ 工程（esbuild 打包到 dist/web/），本文件负责：i18n 占位替换 + 静态资源分发 + WS 协议实现
+// 独立 HTTP 服务：聚合多进程会话 + WebSocket 实时流
+// 协议（统一事件流）：agent 上报 cmdStart/out/cmdDone/raw，server 按订阅者 _mode 派发 diff/raw；
+// snapshot 仅订阅/模式切换时作为基线发送，日常由 diff 增量累积渲染。
 import { createServer } from "node:http";
-import { readFileSync, readdirSync, existsSync, rmSync } from "node:fs";
+import { readFileSync, readdirSync, existsSync, rmSync, statSync } from "node:fs";
 import { join, dirname, extname, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer, WebSocket } from "ws";
 import { listAllSessions, removeSessionState } from "./session-store.js";
 import { tr } from "./i18n.js";
-import { PTY_COLS } from "./constants.js";
+import { PTY_COLS, PTY_ROWS } from "./constants.js";
 import log from "./log.js";
-/** 前端模板中需要替换的 i18n 占位键 */
 const PAGE_KEYS = [
     "web_title",
     "web_loading",
@@ -20,40 +20,30 @@ const PAGE_KEYS = [
     "web_delete_terminal",
     "web_cmd_placeholder",
     "web_send_ctrlc",
+    "web_raw",
 ];
-/** 前端 JS 内 I18N 对象键 → i18n key */
 const JS_I18N_KEYS = {
-    run: "web_running",
     commands: "web_commands",
-    autoRefresh: "web_auto_refresh",
     sessionGone: "web_session_gone",
     noSession: "web_no_session",
-    loadFailed: "web_load_failed",
     local: "web_local",
     terminals: "web_terminals",
     cmdPlaceholder: "web_cmd_placeholder",
     sendCtrlC: "web_send_ctrlc",
 };
-/** WS 运行增量轮询间隔 */
-const STREAM_TICK_MS = 100;
-/** runEnd 后等待快照稳定（后台哨兵监听写入 history）的缓冲时间 */
-const SNAP_STABLE_MS = 400;
-/** 会话列表推送间隔（服务端主动推送，非浏览器轮询） */
 const STATUS_PUSH_MS = 2000;
-/**
- * 启动 HTTP + WebSocket 服务（监听 127.0.0.1）
- * @param port 端口，0 或未指定 → 系统随机分配（避免冲突）
- * @param getSessions 获取扁平会话条目列表的函数（供本进程页面展示与实时流）
- * @param dir 插件缓存根目录（跨进程状态文件/历史文件所在处）
- * @param lang Web 界面语言（默认 en）
- * @returns 服务句柄（含实际端口与 URL）
- */
-export function startServer(port, getSessions, dir, lang = "en") {
+const sessionKey = (sid, name) => `${sid}:${name}`;
+export function startServer(port, _getSessions, dir, lang = "en", _streamTickMs = 100) {
     let actualPort = port;
-    // 前端产物目录：dist/web（相对本模块 dist/server.js 的上一级）
     const webDir = join(dirname(fileURLToPath(import.meta.url)), "web");
-    // 模板只读一次（dist/web/index.html），每次请求做 i18n 占位替换
     const pageTemplate = readTemplate(webDir);
+    const agents = new Map();
+    const agentBySession = new Map();
+    const streamBuf = new Map();
+    const rawBuf = new Map();
+    const cmdCount = new Map();
+    /** 排队序列保持 busy 的 key（agent 报 more=true 加入，最后一条 done 移除） */
+    const seqHold = new Set();
     const server = createServer((req, res) => {
         const url = new URL(req.url ?? "/", "http://127.0.0.1");
         const path = url.pathname;
@@ -68,7 +58,6 @@ export function startServer(port, getSessions, dir, lang = "en") {
             res.end(html);
             return;
         }
-        // 静态资源：/web/* → dist/web/*（JS/CSS/字体）
         if (path.startsWith("/web/")) {
             serveStatic(res, webDir, decodeURIComponent(path.slice("/web/".length)));
             return;
@@ -76,7 +65,6 @@ export function startServer(port, getSessions, dir, lang = "en") {
         res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
         res.end("Not Found");
     });
-    // ===== WebSocket：会话列表 + transcript 快照 + 运行中增量 =====
     const wss = new WebSocketServer({ noServer: true });
     server.on("upgrade", (req, socket, head) => {
         const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -84,35 +72,79 @@ export function startServer(port, getSessions, dir, lang = "en") {
             socket.destroy();
             return;
         }
-        wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit("connection", ws, req);
-        });
+        wss.handleUpgrade(req, socket, head, (ws) => { wss.emit("connection", ws, req); });
     });
-    // 发送 JSON 消息给客户端（连接未开则忽略）
     const send = (ws, msg) => {
         if (ws.readyState === WebSocket.OPEN)
             ws.send(JSON.stringify(msg));
     };
-    /** 构建聚合会话列表（与旧 /api/status 同构，供 WS sessions 消息推送） */
+    /** 订阅指定会话的 transcript 客户端深拷贝 I/O 深处 */
+    const subscribersOf = (sid, name) => {
+        return [...wss.clients].filter((c) => c.readyState === WebSocket.OPEN && c._sub?.sid === sid && c._sub?.name === name);
+    };
     const buildSessions = () => {
         const states = listAllSessions(dir);
-        // 用 live 连接修正 stale 状态：进程复苏后旧状态文件里的 connected=true 实为已断开
-        const liveKey = new Set(getSessions().map((e) => `${e.sessionID}:${e.name}`));
-        // live 会话的实时 busy/connected（web 端 WS exec 不写状态文件，busy 需从内存读）
-        const liveStatus = new Map();
-        for (const e of getSessions()) {
-            const st = e.session.getStatus();
-            liveStatus.set(`${e.sessionID}:${e.name}`, { connected: st.connected, busy: st.busy });
+        // 补：state 文件可能被清理（重启/断线），但 history 目录仍在——扫描发现离线历史终端
+        const histTerms = [];
+        for (const sidDir of readdirSync(dir)) {
+            const sidPath = join(dir, sidDir);
+            let st = null;
+            try {
+                st = statSync(sidPath);
+            }
+            catch { /* 不存在 */ }
+            if (!st?.isDirectory())
+                continue; // 跳过 server.json 等根级文件
+            let subs;
+            try {
+                subs = readdirSync(sidPath);
+            }
+            catch {
+                continue;
+            }
+            if (!subs.length)
+                continue;
+            for (const sub of subs) {
+                try {
+                    const subPath = join(sidPath, sub);
+                    const subSt = statSync(subPath);
+                    if (subSt.isDirectory() && readdirSync(subPath).some((f) => f.endsWith(".json"))) {
+                        if (sub.startsWith("local-"))
+                            histTerms.push({ sessionID: sidDir, name: sub.slice(6), kind: "local" });
+                        else
+                            histTerms.push({ sessionID: sidDir, name: sub, kind: "ssh" });
+                    }
+                }
+                catch { /* 跳过 */ }
+            }
+        }
+        const seen = new Set();
+        const liveKey = new Set(agentBySession.keys());
+        const liveBusy = new Map();
+        const now = Date.now();
+        // 兜底：streamBuf 中 agent 连接已消失的 key 强制清 busy（agent 崩溃/退出防卡死）。
+        // 注意不能用"无 out 超时"判定——交互命令（sudo/read 等输入）等待期间无输出，
+        // 但 agent 仍在，命令未完成，busy 必须保持 true（完成由 agent 生命周期钩子兜底，含 watch 超时发 done）
+        for (const [key, b] of streamBuf) {
+            if (b && !b.done && !agentBySession.has(key)) {
+                b.done = true;
+                b.ts = now;
+                b.endTs = now;
+                finalizeCommand(key);
+            }
+            if (!agentBySession.has(key))
+                seqHold.delete(key); // agent 已消失：清排队序列 busy 保持
+            liveBusy.set(key, (!!b && !b.done) || seqHold.has(key));
         }
         for (const s of states) {
-            if (s.connected && !liveKey.has(`${s.sessionID}:${s.name}`)) {
+            if (s.connected && !liveKey.has(sessionKey(s.sessionID, s.name))) {
                 s.connected = false;
             }
-            const live = liveStatus.get(`${s.sessionID}:${s.name}`);
-            if (live) {
-                s.connected = live.connected;
-                s.busy = live.busy;
-            }
+            const lk = sessionKey(s.sessionID, s.name);
+            const busy = liveBusy.get(lk);
+            if (busy !== undefined)
+                s.busy = busy;
+            seen.add(sessionKey(s.sessionID, s.name));
         }
         const bySession = new Map();
         for (const s of states) {
@@ -120,114 +152,81 @@ export function startServer(port, getSessions, dir, lang = "en") {
                 bySession.set(s.sessionID, { title: s.title, directory: s.directory, terminals: [] });
             bySession.get(s.sessionID).terminals.push({ name: s.name, kind: s.kind, host: s.host, user: s.user, port: s.port, program: s.program, connected: s.connected, busy: s.busy, pending: s.pending });
         }
-        const sessions = [...bySession.entries()].map(([sessionID, v]) => ({
-            sessionID,
-            title: v.title,
-            directory: v.directory,
-            terminals: v.terminals,
-        }));
+        // 补：history 目录里存在但 state 缺失的历史终端（离线展示）
+        for (const h of histTerms) {
+            const k = sessionKey(h.sessionID, h.name);
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            if (!bySession.has(h.sessionID))
+                bySession.set(h.sessionID, { terminals: [] });
+            bySession.get(h.sessionID).terminals.push({ name: h.name, kind: h.kind, connected: false, busy: false, pending: 0 });
+        }
+        const sessions = [...bySession.entries()].map(([sessionID, v]) => ({ sessionID, title: v.title, directory: v.directory, terminals: v.terminals }));
         return { port: actualPort, sessions };
     };
-    /** 构建某终端的 transcript 快照（本进程句柄直读内存；跨进程回退读历史文件） */
-    const buildSnapshot = (sid, name, entry) => {
-        if (entry) {
-            const pairs = [];
-            for (const pair of entry.session.getHistory().getPairs()) {
-                if (pair.command === "__SSH_SEP__") {
-                    pairs.push({ type: "sep", ts: pair.ts, text: "" });
-                }
-                else {
-                    pairs.push({ type: "cmd", ts: pair.ts, endTs: pair.endTs, text: pair.command });
-                    pairs.push({ type: "out", text: entry.session.getHistory().readOutput(pair) });
-                }
-            }
-            // 运行中：命令文本 + 当前输出（前端可立即显示命令行，再跟动画）
-            if (entry.session.hasRunningStream()) {
-                const runningCmd = entry.session.getRunningCommand();
-                if (runningCmd)
-                    pairs.push({ type: "cmd", ts: Date.now(), text: runningCmd });
-                const running = entry.session.getRunningOutput();
-                if (running)
-                    pairs.push({ type: "run", text: running });
-            }
-            return { pairs };
+    /** 组装全量历史基线（snapshot）：文件历史 + 运行中命令转成 cmd+run 对 */
+    const resolveHistName = (sid, name) => {
+        // 不依赖 state 文件（断线/重启后 state 可能已清理）：直接探测 local 前缀目录
+        const base = join(dir, sid);
+        // local 终端历史存 `local-${name}`，ssh 存 `${name}`；两者目录名称不能并存取其一
+        const localDir = join(base, `local-${name}`);
+        const plainDir = join(base, name);
+        let hasLocal = false;
+        let hasPlain = false;
+        try {
+            hasLocal = readdirSync(localDir).some((f) => f.endsWith(".json"));
+        }
+        catch { /* 目录不存在 */ }
+        try {
+            hasPlain = readdirSync(plainDir).some((f) => f.endsWith(".json"));
         }
-        // 本进程无此会话句柄（跨进程会话/复用服务）→ 从历史文件读取
+        catch { /* 目录不存在 */ }
+        if (hasLocal && !hasPlain)
+            return `local-${name}`;
+        if (hasPlain && !hasLocal)
+            return name;
+        // 两者都不存在 → 沿用 state 判定（在线 local 会话刚建历史未落盘时）
         const state = listAllSessions(dir).find((s) => s.sessionID === sid && s.name === name);
-        const histName = state?.kind === "local" ? `local-${name}` : name;
+        return state?.kind === "local" ? `local-${name}` : name;
+    };
+    const buildSnapshot = (sid, name) => {
+        const state = listAllSessions(dir).find((s) => s.sessionID === sid && s.name === name);
+        const histName = resolveHistName(sid, name);
         const pairs = readHistoryFromFile(dir, sid, histName) ?? [];
-        if (pairs.length === 0 && !state) {
-            // 状态文件与历史都消失 = 会话真正删除，前端剔除该幽灵终端
-            return { pairs: [], notFound: true };
+        const sKey = sessionKey(sid, name);
+        const buf = streamBuf.get(sKey);
+        if (buf && !buf.done && buf.command) {
+            pairs.push({ type: "cmd", ts: buf.ts, text: buf.command });
+            if (buf.data)
+                pairs.push({ type: "run", text: buf.data });
         }
+        if (pairs.length === 0 && !state)
+            return { pairs: [], notFound: true };
         return { pairs };
     };
-    /** 会话历史指纹（含末对序号+字节数），用于判断是否需要重推快照 */
-    const historyKey = (session) => {
-        const hp = session.getHistory().getPairs();
-        const last = hp[hp.length - 1];
-        return `${hp.length}:${last ? `${last.seq}:${last.size}` : "-"}`;
-    };
-    // WS 定时推送：状态列表（低频）+ 订阅终端的运行增量/快照（高频）
-    const streamTimer = setInterval(() => {
-        for (const client of wss.clients) {
-            if (client.readyState !== WebSocket.OPEN)
-                continue;
-            const sub = client._sub;
-            if (!sub)
-                continue;
-            const entry = getSessions().find((e) => e.sessionID === sub.sid && e.name === sub.name);
-            const session = entry?.session;
-            if (!session) {
-                // 跨进程会话（无本进程句柄）：仅在有变化时推文件级快照（低频，退化无实时流）
-                const snap = buildSnapshot(sub.sid, sub.name);
-                const key = JSON.stringify(snap);
-                if (key !== client._lastKey) {
-                    client._lastKey = key;
-                    send(client, { type: "snapshot", sessionID: sub.sid, name: sub.name, ...snap });
-                }
-                continue;
-            }
-            // 命令开始运行：检测从空闲→运行切换，立即推送命令文本（前端先渲染命令行，动画紧跟其后）
-            const runActive = session.hasRunningStream();
-            if (runActive && !client._wasRunning) {
-                const cmd = session.getRunningCommand();
-                if (cmd)
-                    send(client, { type: "cmdStart", command: cmd });
-            }
-            client._wasRunning = runActive;
-            // 运行增量推送（cmdStart 之后，保证前端先建命令行再建 run 块）
-            const st = session.getRunningStream();
-            if (st.done) {
-                // 仅首次转 done 时发 runEnd，避免后续 tick 重复发送重置 snapBase
-                if (!client._forceSnap) {
-                    send(client, { type: "runEnd" });
-                    client._forceSnap = true;
-                    client._snapBase = Date.now();
-                }
-            }
-            else if (st.data) {
-                send(client, { type: "run", data: st.data });
-            }
-            // 快照推送：runEnd 后等后台写入稳定，或空闲期历史变化（exec 同步完成）
-            const key = historyKey(session);
-            const forceDone = client._forceSnap && (!runActive || (client._snapBase ?? 0) > 0 && Date.now() - client._snapBase >= SNAP_STABLE_MS);
-            if (forceDone || (!runActive && key !== client._lastKey)) {
-                client._forceSnap = false;
-                client._lastKey = key;
-                send(client, { type: "snapshot", sessionID: sub.sid, name: sub.name, ...buildSnapshot(sub.sid, sub.name, entry) });
+    /** cmdDone 收尾：cmd 计数 + 广播 diff{done}(transcript) / meta(raw) */
+    const finalizeCommand = (sKey) => {
+        const [sid, name] = splitKey(sKey);
+        const b = streamBuf.get(sKey);
+        if (!b || !b.done)
+            return;
+        cmdCount.set(sKey, (cmdCount.get(sKey) ?? 0) + 1);
+        for (const c of subscribersOf(sid, name)) {
+            if (c._mode === "raw") {
+                send(c, { type: "meta", sessionID: sid, name, commands: cmdCount.get(sKey) });
             }
-            // Raw 连续流增量推送（订阅时已发全量，此后只推新字节）
-            if (client._rawPos !== undefined) {
-                const r = session.readRawStream(client._rawPos);
-                if (r.data) {
-                    client._rawPos = r.pos;
-                    send(client, { type: "raw", data: r.data, pos: r.pos, reset: !!r.reset });
-                }
+            else {
+                send(c, { type: "diff", sessionID: sid, name, event: "done", exitCode: b.exitCode, endTs: b.endTs });
             }
         }
-    }, STREAM_TICK_MS);
-    const statusTimer = setInterval(() => {
+    };
+    const splitKey = (key) => {
+        const sep = key.indexOf(":");
+        return [key.slice(0, sep), key.slice(sep + 1)];
+    };
+    /** 广播 sessions（json 变化去重；busy 翻转必然变化） */
+    const pushSessions = () => {
         const payload = buildSessions();
         const json = JSON.stringify(payload);
         for (const client of wss.clients) {
@@ -238,7 +237,8 @@ export function startServer(port, getSessions, dir, lang = "en") {
             client._lastSessionsJson = json;
             send(client, { type: "sessions", ...payload });
         }
-    }, STATUS_PUSH_MS);
+    };
+    const statusTimer = setInterval(() => { pushSessions(); }, STATUS_PUSH_MS);
     wss.on("connection", (ws) => {
         ws.on("message", (raw) => {
             let msg;
@@ -248,118 +248,275 @@ export function startServer(port, getSessions, dir, lang = "en") {
             catch {
                 return;
             }
-            switch (msg.type) {
-                case "list": {
-                    const payload = buildSessions();
-                    ws._lastSessionsJson = JSON.stringify(payload);
-                    send(ws, { type: "sessions", ...payload });
-                    break;
+            const t = msg.type;
+            if (!t)
+                return;
+            // ===== agent 上报（唯一数据源） =====
+            if (t === "register") {
+                const sessions = msg.sessions;
+                if (!Array.isArray(sessions))
+                    return;
+                for (const old of agents.get(ws) ?? [])
+                    agentBySession.delete(old);
+                agents.set(ws, new Set());
+                for (const s of sessions) {
+                    const k = sessionKey(s.sessionID, s.name);
+                    agents.get(ws).add(k);
+                    agentBySession.set(k, ws);
                 }
-                case "subscribe": {
-                    const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
-                    const name = typeof msg.name === "string" ? msg.name : "default";
-                    if (!sid)
-                        return;
-                    ws._sub = { sid, name };
-                    ws._forceSnap = false;
-                    const entry = getSessions().find((e) => e.sessionID === sid && e.name === name);
-                    ws._wasRunning = entry?.session.hasRunningStream() ?? false;
-                    // 预置流指针：运行中订阅时先消费一次（丢弃），快照已含当前输出，后续增量不与快照重叠
-                    entry?.session.getRunningStream();
-                    const snap = buildSnapshot(sid, name, entry);
-                    ws._lastKey = entry ? historyKey(entry.session) : JSON.stringify(snap);
-                    send(ws, { type: "snapshot", sessionID: sid, name, ...snap });
-                    // Raw 连续流：仅客户端要求且本进程持有会话句柄时启用
-                    const wantRaw = msg.raw === true;
-                    if (wantRaw && entry) {
-                        const r = entry.session.readRawStream(0);
-                        ws._rawPos = r.pos;
-                        send(ws, { type: "raw", data: r.data, pos: r.pos, reset: true });
-                    }
-                    else {
-                        ws._rawPos = undefined;
+                return;
+            }
+            if (t === "cmdStart") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                const command = typeof msg.command === "string" ? msg.command : "";
+                if (!sid || !command)
+                    return;
+                const k = sessionKey(sid, name);
+                seqHold.delete(k); // 新命令开始：本条正在运行，busy 由 streamBuf 反映
+                const existing = streamBuf.get(k);
+                streamBuf.set(k, {
+                    data: existing && existing.done ? "" : existing?.data ?? "",
+                    done: false,
+                    ts: typeof msg.ts === "number" ? msg.ts : Date.now(),
+                    command,
+                });
+                for (const c of subscribersOf(sid, name)) {
+                    if (c._mode === "raw")
+                        continue;
+                    // 新命令：重置推送游标，通知命令开始
+                    c._txPos = 0;
+                    send(c, { type: "diff", sessionID: sid, name, event: "cmd", command, ts: streamBuf.get(k).ts });
+                }
+                pushSessions();
+                return;
+            }
+            if (t === "out") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                const data = typeof msg.data === "string" ? msg.data : "";
+                if (!sid || !data)
+                    return;
+                const k = sessionKey(sid, name);
+                const isFinal = msg.final === true;
+                const existing = streamBuf.get(k);
+                if (isFinal) {
+                    // 命令完成时 agent 补推的"处理后完整输出"：替换（而非追加）避免与已推增量重复，
+                    // 并强制推给所有 transcript 订阅者（重置游标 = 丢弃动画帧累积，用干净结果重建块）
+                    streamBuf.set(k, { data, done: false, ts: Date.now(), command: existing?.command ?? "" });
+                    for (const c of subscribersOf(sid, name)) {
+                        if (c._mode === "raw")
+                            continue;
+                        c._txPos = data.length;
+                        send(c, { type: "diff", sessionID: sid, name, event: "out", data, final: true });
                     }
-                    break;
                 }
-                case "unsubscribe": {
-                    ws._sub = undefined;
-                    break;
+                else if (existing) {
+                    existing.data = (existing.data || "") + data;
+                    existing.ts = Date.now();
                 }
-                case "ping": {
-                    send(ws, { type: "pong" });
-                    break;
+                else {
+                    streamBuf.set(k, { data, done: false, ts: Date.now(), command: "" });
                 }
-                case "exec": {
-                    const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
-                    const name = typeof msg.name === "string" ? msg.name : "";
-                    const command = typeof msg.command === "string" ? msg.command : "";
-                    if (!sid || !command)
-                        break;
-                    const entry = getSessions().find((e) => e.sessionID === sid && e.name === name);
-                    if (!entry)
-                        break;
-                    entry.session.exec(command).then(() => {
-                        // exec 完成后立即推送一次会话状态（busy 复位），不等 2s 定时器
-                        const payload = buildSessions();
-                        const json = JSON.stringify(payload);
-                        for (const client of wss.clients) {
-                            if (client.readyState !== WebSocket.OPEN)
-                                continue;
-                            client._lastSessionsJson = json;
-                            send(client, { type: "sessions", ...payload });
-                        }
-                    });
-                    // exec 前立即推送一次（busy 置位），让前端马上看到沙漏
-                    const payload = buildSessions();
-                    const json = JSON.stringify(payload);
-                    for (const client of wss.clients) {
-                        if (client.readyState !== WebSocket.OPEN)
-                            continue;
-                        client._lastSessionsJson = json;
-                        send(client, { type: "sessions", ...payload });
+                const len = streamBuf.get(k).data.length;
+                for (const c of subscribersOf(sid, name)) {
+                    if (c._mode === "raw")
+                        continue;
+                    const from = c._txPos ?? len;
+                    const newData = streamBuf.get(k).data.slice(from);
+                    if (newData) {
+                        c._txPos = len;
+                        send(c, { type: "diff", sessionID: sid, name, event: "out", data: newData });
                     }
-                    break;
                 }
-                case "send": {
-                    const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
-                    const name = typeof msg.name === "string" ? msg.name : "";
-                    const text = typeof msg.text === "string" ? msg.text : "";
-                    if (!sid || !text)
-                        break;
-                    const entry = getSessions().find((e) => e.sessionID === sid && e.name === name);
-                    if (!entry)
-                        break;
-                    entry.session.send(text);
-                    break;
+                return;
+            }
+            if (t === "cmdDone") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                if (!sid)
+                    return;
+                const k = sessionKey(sid, name);
+                // 排队序列：agent 报 more=true（队列还有后续命令）→ 保持 busy，直到最后一条 done
+                if (msg.more === true)
+                    seqHold.add(k);
+                else
+                    seqHold.delete(k);
+                const b = streamBuf.get(k);
+                if (b) {
+                    if (b.done)
+                        return; // 幂等：同一命令只收尾一次
+                    b.done = true;
+                    b.endTs = typeof msg.endTs === "number" ? msg.endTs : Date.now();
+                    // agent 上报退出码可能与六条退出路径不一致（无退出来源 null）
+                    if (typeof msg.exitCode === "number")
+                        b.exitCode = msg.exitCode;
+                }
+                else {
+                    streamBuf.set(k, { data: "", done: true, ts: Date.now(), endTs: typeof msg.endTs === "number" ? msg.endTs : Date.now(), command: "" });
+                }
+                finalizeCommand(k);
+                pushSessions();
+                return;
+            }
+            if (t === "raw") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                const data = typeof msg.data === "string" ? msg.data : "";
+                const pos = typeof msg.pos === "number" ? msg.pos : 0;
+                if (!sid)
+                    return;
+                const k = sessionKey(sid, name);
+                const existing = rawBuf.get(k);
+                if (msg.reset === true || !existing)
+                    rawBuf.set(k, { data, pos });
+                else if (data)
+                    rawBuf.set(k, { data: existing.data + data, pos });
+                // 直接转发给 raw 订阅者（agent 推的已是增量、WS 保序）
+                for (const c of subscribersOf(sid, name)) {
+                    if (c._mode !== "raw")
+                        continue;
+                    send(c, { type: "raw", data, pos, reset: msg.reset === true });
+                }
+                return;
+            }
+            // ===== web 请求 =====
+            if (t === "subscribe") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                if (!sid)
+                    return;
+                ws._sub = { sid, name };
+                const sKey = sessionKey(sid, name);
+                const snap = buildSnapshot(sid, name);
+                if (snap.notFound) {
+                    send(ws, { type: "snapshot", sessionID: sid, name, ...snap });
+                    ws._mode = "transcript";
+                    return;
                 }
-                case "deleteTerminal": {
-                    const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
-                    const name = typeof msg.name === "string" ? msg.name : "";
-                    if (!sid || !name)
-                        break;
-                    const entry = getSessions().find((e) => e.sessionID === sid && e.name === name);
-                    if (entry) {
-                        // 有活动句柄：close() 已含 history.dispose() 删除历史目录
-                        entry.session.close();
+                const wantRaw = msg.mode === "raw" || msg.raw === true;
+                if (wantRaw) {
+                    // raw：不重发 pairs 全量，raw 全量(reset) 已含画面 + 轻量命令计数
+                    if (!cmdCount.has(sKey))
+                        cmdCount.set(sKey, snap.pairs.filter((p) => p.type === "cmd").length);
+                    send(ws, { type: "meta", sessionID: sid, name, commands: cmdCount.get(sKey) });
+                    const r = rawBuf.get(sKey);
+                    if (r?.data)
+                        send(ws, { type: "raw", data: r.data, pos: r.pos, reset: true });
+                    else {
+                        // 离线历史会话无实时 rawBuf：用 history 重建原始流供 raw 视图（rawActive 后画面即它）
+                        const hist = buildRawFromHistory(snap.pairs);
+                        if (hist)
+                            send(ws, { type: "raw", data: hist, pos: hist.length, reset: true });
                     }
+                    ws._mode = "raw";
+                }
+                else {
+                    // transcript：发完整基线，游标对齐缓冲末尾（基线已含全部缓冲内容，后续 out 只推增量）
+                    send(ws, { type: "snapshot", sessionID: sid, name, ...snap });
+                    ws._txPos = streamBuf.get(sKey)?.data.length ?? 0;
+                    ws._mode = "transcript";
+                }
+                return;
+            }
+            if (t === "setMode") {
+                if (!ws._sub)
+                    return;
+                const on = msg.mode === "raw";
+                const { sid, name } = ws._sub;
+                const sKey = sessionKey(sid, name);
+                if (on) {
+                    ws._mode = "raw";
+                    const snap = buildSnapshot(sid, name);
+                    cmdCount.set(sKey, snap.pairs.filter((p) => p.type === "cmd").length);
+                    send(ws, { type: "meta", sessionID: sid, name, commands: cmdCount.get(sKey) });
+                    const r = rawBuf.get(sKey);
+                    if (r?.data)
+                        send(ws, { type: "raw", data: r.data, pos: r.pos, reset: true });
                     else {
-                        // 跨进程/陈旧终端：无句柄，直接删除历史目录（历史文件 + 会话记录）
-                        const histName = `local-${name}`;
-                        const histDir = join(dir, sid, histName);
-                        const sshDir = join(dir, sid, name);
-                        try {
-                            rmSync(histDir, { recursive: true, force: true });
-                        }
-                        catch { /* 忽略 */ }
-                        try {
-                            rmSync(sshDir, { recursive: true, force: true });
-                        }
-                        catch { /* 忽略 */ }
+                        // 离线历史会话无实时 rawBuf：用 history 重建原始流供 raw 视图
+                        const hist = buildRawFromHistory(snap.pairs);
+                        if (hist)
+                            send(ws, { type: "raw", data: hist, pos: hist.length, reset: true });
                     }
-                    removeSessionState(dir, sid, name);
-                    log.info(`Web 页删除终端 ${sid}/${name}`);
-                    break;
                 }
+                else {
+                    // raw→transcript：补发完整快照基线，游标对齐（raw 期间未收 diff）
+                    ws._mode = "transcript";
+                    const snap = buildSnapshot(sid, name);
+                    ws._txPos = streamBuf.get(sKey)?.data.length ?? 0;
+                    send(ws, { type: "snapshot", sessionID: sid, name, ...snap });
+                }
+                return;
+            }
+            if (t === "unsubscribe") {
+                ws._sub = undefined;
+                ws._mode = undefined;
+                return;
+            }
+            if (t === "ping") {
+                send(ws, { type: "pong" });
+                return;
+            }
+            if (t === "exec") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                const command = typeof msg.command === "string" ? msg.command : "";
+                if (!sid || !command)
+                    return;
+                const agent = agentBySession.get(sessionKey(sid, name));
+                if (!agent)
+                    return;
+                // 保留运行中流的累积输出：REPL 交互场景下 web 每次回车仍发 exec（非独立命令，无 cmdStart 重置游标），
+                // 无条件清空 streamBuf 会让订阅者 _txPos 超出新流长度，后续增量 slice 为空 → transcript 输出丢失。
+                // 与 cmdStart 语义一致：仅上一条已完成时清空，进行中（REPL 交互等待）保留累积。
+                const k = sessionKey(sid, name);
+                const existing = streamBuf.get(k);
+                streamBuf.set(k, { data: existing && existing.done ? "" : existing?.data ?? "", done: false, ts: Date.now(), command });
+                pushSessions();
+                send(agent, { type: "run-exec", reqId: `${sid}:${name}:${Date.now()}`, sessionID: sid, name, command });
+                return;
+            }
+            if (t === "send") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                const text = typeof msg.text === "string" ? msg.text : "";
+                if (!sid || !text)
+                    return;
+                const agent = agentBySession.get(sessionKey(sid, name));
+                if (agent)
+                    send(agent, { type: "run-send", sessionID: sid, name, text });
+                return;
+            }
+            if (t === "deleteTerminal") {
+                const sid = typeof msg.sessionID === "string" ? msg.sessionID : "";
+                const name = typeof msg.name === "string" ? msg.name : "";
+                if (!sid || !name)
+                    return;
+                const agent = agentBySession.get(sessionKey(sid, name));
+                if (agent)
+                    send(agent, { type: "run-delete", sessionID: sid, name });
+                removeSessionState(dir, sid, name);
+                // 删除该终端的 history 目录：buildSessions 会按 history 目录兜底列出离线历史终端，
+                // 只删 state 文件不清目录会导致"删除后页面仍在"（残留被兜底扫描重新发现）
+                try {
+                    const histName = resolveHistName(sid, name);
+                    rmSync(join(dir, sid, histName), { recursive: true, force: true });
+                }
+                catch { /* 目录不存在忽略 */ }
+                streamBuf.delete(sessionKey(sid, name));
+                rawBuf.delete(sessionKey(sid, name));
+                log.info(`Web 页删除终端 ${sid}/${name}`);
+                pushSessions();
+                return;
+            }
+        });
+        ws.on("close", () => {
+            const reg = agents.get(ws);
+            if (reg) {
+                for (const k of reg)
+                    agentBySession.delete(k);
+                agents.delete(ws);
             }
         });
     });
@@ -373,41 +530,26 @@ export function startServer(port, getSessions, dir, lang = "en") {
                 server,
                 port: actualPort,
                 url: `http://127.0.0.1:${actualPort}`,
-                close: () => {
-                    clearInterval(streamTimer);
-                    clearInterval(statusTimer);
-                    server.close();
-                    wss.close();
-                },
+                close: () => { clearInterval(statusTimer); server.close(); wss.close(); },
             });
         });
     });
 }
-/**
- * 渲染终端记录页面：读取编译后的 index.html，替换 i18n 占位符与前端 I18N 对象
- * @param lang 界面语言
- * @param template index.html 模板文本（启动时已读）
- * @returns 最终 HTML 文本
- */
 function renderPage(lang, template) {
     let out = template;
-    // 语言占位
     out = out.replaceAll("{{lang}}", lang);
-    // 文本占位（{{web_xxx}}）
     for (const key of PAGE_KEYS) {
         out = out.replaceAll(`{{${key}}}`, tr(key, lang));
     }
-    // 前端 JS I18N 对象（window.__I18N__ = ...）
     const i18nObj = {};
     for (const [jsKey, i18nKey] of Object.entries(JS_I18N_KEYS)) {
         i18nObj[jsKey] = tr(i18nKey, lang);
     }
     out = out.replaceAll("__I18N_JSON__", JSON.stringify(i18nObj));
-    // PTY 列宽注入（前端 TermScreen 按此列宽渲染，与后端生成 ANSI 的列宽一致，避免错行）
     out = out.replaceAll("__PTY_COLS_VAL__", String(PTY_COLS));
+    out = out.replaceAll("__PTY_ROWS_VAL__", String(PTY_ROWS));
     return out;
 }
-/** 读取前端模板（dist/web/index.html）；缺失时返回引导构建的提示页 */
 function readTemplate(webDir) {
     const file = join(webDir, "index.html");
     if (!existsSync(file)) {
@@ -415,7 +557,6 @@ function readTemplate(webDir) {
     }
     return readFileSync(file, "utf8");
 }
-/** 静态文件类型映射 */
 const MIME = {
     ".html": "text/html; charset=utf-8",
     ".js": "application/javascript; charset=utf-8",
@@ -427,12 +568,6 @@ const MIME = {
     ".png": "image/png",
     ".ico": "image/x-icon",
 };
-/**
- * 分发静态资源（防目录穿越：归一化后校验目标在 webDir 内）
- * @param res 响应对象
- * @param webDir 前端产物根目录
- * @param rel 相对路径（已去 /web/ 前缀）
- */
 function serveStatic(res, webDir, rel) {
     if (rel.includes("\0")) {
         res.writeHead(400);
@@ -454,13 +589,6 @@ function serveStatic(res, webDir, rel) {
     res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
     res.end(readFileSync(file));
 }
-/**
- * 从历史文件读取某终端记录（跨进程场景：本进程无该会话句柄时用）
- * @param dir 插件缓存根目录
- * @param sessionID opencode 会话 ID
- * @param name 终端名（已含 local- 前缀则按本地目录）
- * @returns 结构化消息对（保留 ANSI）；目录不存在返回 null
- */
 function readHistoryFromFile(dir, sessionID, name) {
     const hdir = join(dir, sessionID, name);
     let files;
@@ -485,9 +613,35 @@ function readHistoryFromFile(dir, sessionID, name) {
                 out.push({ type: "out", text: data.output });
         }
         catch {
-            /* 跳过损坏文件 */
+            /* skip */
         }
     }
     return out;
 }
+/**
+ * 从历史消息对重建原始字节流（raw 视图）：拼接所有命令对为 `命令\r\n输出` 流。
+ * 离线历史会话无实时 rawBuf 时供 raw 模式显示。
+ * 注意：命令文本（`command` 字段）换行是裸 `\n`，须规范成 `\r\n`，否则 xterm 只换行不复位、渲染成阶梯错位；
+ * 输出（`output` 字段）是原始字节本就带 `\r\n`，保持保真不改写。
+ * @param pairs 历史命令/输出对（snapshot 基线）
+ * @returns 重建的原始流
+ */
+function buildRawFromHistory(pairs) {
+    let raw = "";
+    for (const p of pairs) {
+        if (p.type === "cmd") {
+            raw += p.text.replace(/\r?\n/g, "\r\n") + "\r\n";
+        }
+        else if (p.type === "out" || p.type === "run") {
+            raw += p.text;
+            // 输出末段若未换行则补一个换行，分隔下一条命令
+            if (!p.text.endsWith("\n") && !p.text.endsWith("\r"))
+                raw += "\r\n";
+        }
+        else if (p.type === "sep") {
+            raw += "\r\n";
+        }
+    }
+    return raw;
+}
 //# sourceMappingURL=server.js.map