// Web 终端后端 —— 安全敏感模块：终端 = RCE 级攻击面。
// 安全措施：
// 1. 专用终端密码二次确认：PBKDF2-SHA256 600k（与密码箱 routes/passwords.js 同参数，异步版不阻塞事件循环）；
//    首次调用（未设置密码）即完成设置（needs_setup 流程），强度要求 8 位以上
// 2. 短 TTL token（5 分钟）：jwt 带 terminal:true 声明，普通登录 token 不可直接连终端；
//    认证成功后种 HttpOnly SameSite=Strict 短 TTL cookie（terminal_token），WS upgrade 优先取 cookie，
//    ?token= query 仅为旧前端回退（不推荐，会落 access log）；带失败限流 + 请求级限流防 PBKDF2 DoS
// 3. WS handshake Origin 校验（须与站点域名一致；仅 NODE_ENV=development 时放行 localhost）——纵深防御，非认证边界
// 4. 并发会话上限（MAX_SESSIONS=3）：handleUpgrade 内同步预占槽位，杜绝升级回调前的竞态突破
// 5. pty.spawn 使用参数数组传参（防命令注入）；kill 时连进程组一起终止（forkpty 子进程为 session leader，
//    负 PID 即杀整组），杜绝 & 后台任务变孤儿进程
// 6. 审计：会话开始/结束/密码失败等写审计日志（console.log 带时间戳 + audit_logs 表）；
//    拒绝类事件（Origin/token/超限）降频落审计防日志洪泛；audit_logs 按 90 天保留策略惰性清理
// 7. 空闲超时（15 分钟无输入）自动断开
// 8. ws close/error → pty.kill() + 进程组清理 + 监听器/计时器全量销毁
//    流控：pty 输出缓冲超限时 pause（仅在 onData 暂停），恢复检查放在 ws 消息处理 + 兜底轮询
//
// 部署注意：
// - node-pty 是原生模块，需要服务器编译环境（build-essential / python3），
//   安装失败时先 rm -rf node_modules 再 npm install（项目已有此重装先例）。
// - sudoers 配置（把 rainweb 换成实际运行用户）：
//   ⚠️ 实测 NOPASSWD: /usr/bin/sudo -i 写法匹配不到（sudo 匹配规则时 -i 会被规范化
//      为实际执行的 login shell 命令，精确命令规则失效），必须放宽为：
//     echo "rainweb ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/rainweb-terminal
//     sudo chmod 440 /etc/sudoers.d/rainweb-terminal && sudo visudo -c
//   验证：以运行用户执行 `sudo -n -i id` 应直接输出 root 身份且不询问密码。
//   注意：NOPASSWD: ALL 等同把运行用户提权为免密 root，务必确认运行用户无交互登录面。
// - 后端若置于反向代理之后并希望审计 IP 取真实来源 IP，需设置环境变量 TRUST_PROXY=1
//   （否则一律用 socket 直连地址，避免伪造 X-Forwarded-For）。
const express = require('express');
const crypto = require('crypto');
const jwt = require('jsonwebtoken');
const rateLimit = require('express-rate-limit');
const { WebSocketServer, WebSocket } = require('ws');
const db = require('../db');
const { authMiddleware, adminOnly, SECRET } = require('../middleware/auth');

const router = express.Router();

// ---------- 常量 ----------
const TOKEN_TTL = '5m';                 // 短 TTL token 有效期
const TOKEN_COOKIE = 'terminal_token';  // HttpOnly 短 TTL cookie 名
const TOKEN_COOKIE_MAX_AGE = 300;       // cookie 有效期（秒），与 TOKEN_TTL 一致
const MAX_SESSIONS = 3;                 // 最大并发终端会话数
const IDLE_TIMEOUT = 15 * 60 * 1000;    // 空闲超时：15 分钟无输入自动断开
const PIN_MIN_LEN = 8;                  // 终端=root shell，PIN 强度要求 8 位以上
const PBKDF2_ITERATIONS = 600000;       // 与 routes/passwords.js 一致（OWASP 2023 建议）
const MAX_PTY_BUFFER = 1024 * 1024;     // pty 输出缓冲上限（超过则暂停 pty 做流控）
const WS_MAX_PAYLOAD = 1024 * 1024;     // ws 单帧消息上限，超限立即断开
const RESUME_POLL_MS = 2000;            // 流控恢复兜底轮询间隔
const WS_CLOSE_BAD_TOKEN = 4001;        // token 无效
const WS_CLOSE_OVERLOAD = 1013;         // 会话数超限
const WS_CLOSE_IDLE = 4000;             // 空闲超时
const WS_CLOSE_BAD_MSG = 4002;          // 非法消息

// PIN 失败限流（与 passwords.js unlock 同模式）：5 分钟 3 次失败锁定 5 分钟
const authFails = new Map();
const FAIL_LIMIT = 3;
const FAIL_WINDOW = 5 * 60 * 1000;
const LOCK_DURATION = 5 * 60 * 1000;

// /auth 请求级限流：防止异步 PBKDF2 被并发滥用造成 CPU DoS
// （失败锁定只在校验之后生效，无法挡住每请求一次的 600k 迭代计算）
const authRateLimit = rateLimit({
  windowMs: 5 * 60 * 1000,
  max: 20,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: '尝试次数过多，请稍后再试' },
});

// 拒绝类事件审计降频：同一来源 IP 在窗口内最多记一条（防日志洪泛）
const REJECT_AUDIT_INTERVAL = 10 * 1000;
const rejectAudit = new Map(); // ip -> lastTs

// 并发终端会话集合（计数与统一清理）
const activeSessions = new Set();

// node-pty 懒加载：未安装时 REST 接口（status/auth）仍可用，仅 WS 会话被拒绝
let ptyModule = null;
try { ptyModule = require('node-pty'); } catch (e) { /* 未安装：连接时提示 */ }

// 审计写入计数：每 50 条惰性清理一次过期记录（保留策略，见 db.js）
let auditWriteCount = 0;

// ---------- 审计 ----------
// ctx: { user, ip }（user 为 JWT payload）
function audit(action, detail, ctx) {
  const userId = ctx && ctx.user ? ctx.user.id : 0;
  const username = ctx && ctx.user ? ctx.user.username : '';
  const ip = ctx && ctx.ip ? ctx.ip : '';
  console.log(`[${new Date().toISOString()}] [TERMINAL] ${action} user=${username}(${userId}) ip=${ip} ${detail}`);
  // 审计落库（audit_logs 表由 db.js initTables 建表；db.run 内部已容错）
  db.run('INSERT INTO audit_logs (action, user_id, username, detail, ip) VALUES (?, ?, ?, ?, ?)',
    [action, userId, username, detail, ip]);
  // 保留策略：每 50 条写入惰性清理 90 天前的记录（created_at 为 UTC datetime，与建表一致）
  if (++auditWriteCount % 50 === 0) {
    db.run("DELETE FROM audit_logs WHERE created_at < datetime('now','-90 day')");
  }
}

// 客户端真实 IP：仅当 TRUST_PROXY=1 时信任 X-Forwarded-For（否则客户端可任意伪造该头）
function getClientIp(request) {
  if (process.env.TRUST_PROXY === '1' && request.headers['x-forwarded-for']) {
    return String(request.headers['x-forwarded-for']).split(',')[0].trim() || '';
  }
  return (request.socket.remoteAddress || '').toString();
}

// 拒绝事件降频审计：同 IP 10 秒内只记一条
function auditRejectOnce(ip, action, detail) {
  const now = Date.now();
  if ((rejectAudit.get(ip) || 0) > now - REJECT_AUDIT_INTERVAL) return;
  rejectAudit.set(ip, now);
  audit(action, detail, { ip });
}

// ---------- PIN（终端专用密码）----------
const PIN_SALT_KEY = 'terminal_pin_salt';
const PIN_ITER_KEY = 'terminal_pin_iter';
const PIN_HASH_KEY = 'terminal_pin_hash';

function getPinRecord() {
  const salt = db.getSetting(PIN_SALT_KEY);
  const hash = db.getSetting(PIN_HASH_KEY);
  if (!salt || !hash) return null;
  const iter = parseInt(db.getSetting(PIN_ITER_KEY), 10) || PBKDF2_ITERATIONS;
  return { salt: Buffer.from(salt, 'hex'), hash: Buffer.from(hash, 'hex'), iter };
}

// 异步 PBKDF2：不阻塞事件循环（600k 迭代约几十毫秒，同步版会卡住所有请求）
function derivePinHash(pin, salt, iter) {
  return new Promise((resolve, reject) => {
    crypto.pbkdf2(pin, salt, iter, 32, 'sha256', (err, key) => {
      if (err) reject(err); else resolve(key);
    });
  });
}

async function setPin(pin) {
  const salt = crypto.randomBytes(16);
  const hash = await derivePinHash(pin, salt, PBKDF2_ITERATIONS);
  db.setSetting(PIN_SALT_KEY, salt.toString('hex'));
  db.setSetting(PIN_ITER_KEY, String(PBKDF2_ITERATIONS));
  db.setSetting(PIN_HASH_KEY, hash.toString('hex'));
}

async function verifyPin(pin) {
  const rec = getPinRecord();
  if (!rec) return false;
  const derived = await derivePinHash(pin, rec.salt, rec.iter);
  // 常数时间比较，防时序侧信道
  return crypto.timingSafeEqual(derived, rec.hash);
}

// ---------- PIN 失败限流 ----------
function isLocked() {
  const rec = authFails.get('global');
  return !!(rec && rec.lockedUntil && Date.now() < rec.lockedUntil);
}

function recordFail() {
  const now = Date.now();
  let rec = authFails.get('global');
  if (!rec || now - rec.firstTs > FAIL_WINDOW) rec = { count: 0, firstTs: now, lockedUntil: 0 };
  rec.count += 1;
  if (rec.count >= FAIL_LIMIT) { rec.lockedUntil = now + LOCK_DURATION; rec.count = 0; }
  authFails.set('global', rec);
}

// ---------- 短 TTL token（参考 proxy.js）----------
function issueToken(user) {
  // terminal:true 声明：只有本接口签发的 token 才能连接终端，普通登录 token 无效
  return jwt.sign(
    { id: user.id, username: user.username, role: user.role, terminal: true },
    SECRET,
    { expiresIn: TOKEN_TTL }
  );
}

function verifyToken(token) {
  if (!token || typeof token !== 'string') return null;
  try {
    const payload = jwt.verify(token, SECRET);
    if (!payload.terminal) return null;          // 必须为终端专用 token
    if (payload.role !== 'admin') return null;   // 防篡改
    const u = db.get('SELECT role FROM users WHERE id = ?', [payload.id]);
    if (!u || u.role !== 'admin') return null;   // 复查角色（用户被删/降权立即失效）
    return payload;
  } catch { return null; }
}

// 认证成功 → 种 HttpOnly 短 TTL cookie：WS 握手（同源 GET /ws/terminal）自动携带，
// root shell 凭证不再进 URL / access log。Path 精确限定 /ws/terminal，HttpOnly 防 XSS 读取，
// SameSite=Strict 防跨站发送。Secure 按连接是否 HTTPS 条件附加。
function setTerminalCookie(res, token) {
  // L7：HTTPS 判定补 x-forwarded-proto（适配 nginx/Cloudflare 等反代场景——
  // 反代 TLS 终结时 req.secure 可能为 false，但 X-Forwarded-Proto: https 表明真实协议为 HTTPS）
  const isSecure = res.req && (
    res.req.secure ||
    String(res.req.headers['x-forwarded-proto'] || '').toLowerCase().startsWith('https')
  );
  res.setHeader('Set-Cookie',
    `terminal_token=${token}; Path=/ws/terminal; HttpOnly; SameSite=Strict; Max-Age=${TOKEN_COOKIE_MAX_AGE}` +
    (isSecure ? '; Secure' : ''));
}

// 极简 Cookie 解析（upgrade 事件不经 Express，无 cookie-parser）
function parseCookies(header) {
  const out = {};
  if (!header) return out;
  for (const part of String(header).split(';')) {
    const idx = part.indexOf('=');
    if (idx === -1) continue;
    const name = part.slice(0, idx).trim();
    const value = part.slice(idx + 1).trim();
    if (name) { try { out[name] = decodeURIComponent(value); } catch { out[name] = value; } }
  }
  return out;
}

// ---------- REST API ----------
// GET /api/terminal/status —— 是否已设置密码 + 当前会话数
router.get('/status', authMiddleware, adminOnly, (req, res) => {
  res.json({
    hasPin: !!getPinRecord(),
    sessions: activeSessions.size,
    maxSessions: MAX_SESSIONS,
    idleTimeoutMs: IDLE_TIMEOUT,
  });
});

// POST /api/terminal/auth —— 设置/校验终端专用密码，通过后发放 5 分钟短 TTL token
// 并种 HttpOnly cookie（terminal_token）。
// 首次（未设置密码）调用即完成设置（前端按 /status 的 hasPin 决定显示设置表单或密码输入框），
// 响应带 setup:true 标记。响应仍含 token 字段（保持 API 契约），前端无需再从 URL 传递。
router.post('/auth', authRateLimit, authMiddleware, adminOnly, async (req, res) => {
  const pin = req.body && req.body.pin;
  if (!pin || typeof pin !== 'string') return res.status(400).json({ error: '请输入终端密码' });
  if (pin.length > 128) return res.status(400).json({ error: '终端密码过长' });
  if (isLocked()) return res.status(429).json({ error: '尝试次数过多，请稍后再试' });

  const rec = getPinRecord();
  const ctx = { user: req.user, ip: getClientIp(req) };

  if (!rec) {
    // 首次设置：无密码 → 设置并发放 token
    if (pin.length < PIN_MIN_LEN) {
      return res.status(400).json({ error: `终端密码至少 ${PIN_MIN_LEN} 位` });
    }
    try {
      await setPin(pin);
    } catch (e) {
      return res.status(500).json({ error: '密码处理失败' });
    }
    authFails.delete('global');
    audit('PIN_SETUP', '终端专用密码已设置', ctx);
    const token = issueToken(req.user);
    setTerminalCookie(res, token);
    return res.json({
      needs_setup: false,
      setup: true,
      token,
      expiresIn: TOKEN_TTL,
      message: '终端密码已设置',
    });
  }

  let pinOk = false;
  try { pinOk = await verifyPin(pin); } catch { pinOk = false; }
  if (!pinOk) {
    recordFail();
    audit('PIN_FAIL', '终端密码校验失败', ctx);
    if (isLocked()) return res.status(429).json({ error: '尝试次数过多，请稍后再试' });
    return res.status(401).json({ error: '终端密码错误' });
  }

  authFails.delete('global');
  audit('PIN_OK', '终端密码校验通过，发放短 TTL token', ctx);
  const token = issueToken(req.user);
  setTerminalCookie(res, token);
  res.json({ token, expiresIn: TOKEN_TTL });
});

// ---------- WS /ws/terminal ----------
const isDev = process.env.NODE_ENV === 'development';

// Origin 校验：必须与站点域名一致（site_url 或请求 Host 头）。
// localhost 豁免仅 NODE_ENV=development 时生效（生产环境非浏览器客户端无法借 localhost 绕过）。
// 注意：这是纵深防御，不是认证边界——真正把关的是 token/cookie 校验。
function originAllowed(request) {
  const origin = request.headers.origin;
  if (!origin) return false;
  try {
    const o = new URL(origin);
    const allowed = [];
    const siteUrl = db.getSetting('site_url');
    if (siteUrl) { try { allowed.push(new URL(siteUrl).host); } catch {} }
    if (request.headers.host) allowed.push(request.headers.host);
    if (isDev && ['127.0.0.1', 'localhost', '::1'].includes(o.hostname)) return true;
    return allowed.includes(o.host);
  } catch { return false; }
}

// pty 安全：参数数组传参（防命令注入），禁止字符串拼接；sudo -i 获得 root shell。
// cwd 必须用运行用户可访问的目录：直接给 '/root' 时 spawn 不抛错，
// 而是 shell 启动后 chdir(2) 失败（Permission denied）——sudo -i 本身会把
// 工作目录与 HOME 切到 /root，所以这里给运行用户当前目录即可。
function spawnPty(cols, rows) {
  if (!ptyModule) return null; // node-pty 未安装
  const opts = { name: 'xterm-color', cols, rows, cwd: process.cwd() };
  return ptyModule.spawn('sudo', ['-i'], opts);
}

// 终止 pty：先杀 shell，再连进程组一起杀（forkpty 子进程是 session leader，pgid == pid，
// 负 PID 即杀整组），500ms 后兜底 SIGKILL，杜绝 `&` 后台任务变孤儿进程。
function killPty(pty) {
  if (!pty) return;
  const pid = pty.pid;
  try { pty.kill(); } catch {} // 标准接口：向 shell 发 SIGKILL
  if (pid && Number.isInteger(pid)) {
    try { process.kill(-pid, 'SIGTERM'); } catch {}
    const t = setTimeout(() => {
      try { process.kill(-pid, 'SIGKILL'); } catch {}
    }, 500);
    if (t.unref) t.unref();
  }
}

// WS 服务：noServer 模式，由 server.js 的 http server 'upgrade' 事件转交；
// maxPayload 限制单帧大小，超限由 ws 自动关闭（1009）。
const wss = new WebSocketServer({ noServer: true, maxPayload: WS_MAX_PAYLOAD });

// server.js 调用：返回 true 表示已接管该 upgrade 请求（含拒绝），false 表示非终端路径
function handleUpgrade(request, socket, head) {
  let pathname = null;
  try { pathname = new URL(request.url, 'http://localhost').pathname; } catch {}
  if (pathname !== '/ws/terminal') return false;

  const ip = getClientIp(request);

  // 1) Origin 校验（纵深防御；拒绝事件降频落审计）
  if (!originAllowed(request)) {
    auditRejectOnce(ip, 'WS_ORIGIN_REJECT', 'Origin 校验失败');
    socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
    socket.destroy();
    return true;
  }
  // 2) token 校验：优先 HttpOnly cookie（推荐），?token= query 仅作旧前端回退（不推荐，落 access log）
  const cookies = parseCookies(request.headers.cookie);
  let token = cookies[TOKEN_COOKIE];
  if (!token) {
    try { token = new URL(request.url, 'http://localhost').searchParams.get('token'); } catch {}
  }
  const payload = verifyToken(token);
  if (!payload) {
    auditRejectOnce(ip, 'WS_TOKEN_REJECT', 'token 无效或过期');
    socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
    socket.destroy();
    return true;
  }
  // 3) 并发会话上限：同步预占槽位再检查（升级回调前执行，杜绝并发竞态突破上限）
  const slot = { pending: true };
  activeSessions.add(slot);
  if (activeSessions.size > MAX_SESSIONS) {
    activeSessions.delete(slot);
    auditRejectOnce(ip, 'WS_OVERLOAD', '并发会话数超限被拒绝');
    socket.write('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
    socket.destroy();
    return true;
  }
  // 升级中途失败（socket 断开等）时释放预占槽位，防止泄漏
  const releaseSlot = () => { activeSessions.delete(slot); };
  socket.once('close', releaseSlot);
  socket.once('error', releaseSlot);

  // 4) 升级并触发连接处理（槽位随会话移交）
  wss.handleUpgrade(request, socket, head, (ws) => {
    socket.removeListener('close', releaseSlot);
    socket.removeListener('error', releaseSlot);
    if (ws.readyState !== WebSocket.OPEN) { // 升级异常：释放槽位
      activeSessions.delete(slot);
      return;
    }
    wss.emit('connection', ws, request, payload, slot);
  });
  return true;
}

wss.on('connection', (ws, request, payload, slot) => {
  // 复用 handleUpgrade 预占的槽位（已在 activeSessions 中，幂等 add），
  // 升级失败路径已由 releaseSlot/readyState 检查负责释放。
  const session = slot || {};
  session.id = session.id || crypto.randomBytes(4).toString('hex');
  session.startedAt = session.startedAt || Date.now();
  activeSessions.add(session);

  let ptyProc = null;
  let idleTimer = null;
  let resumeTimer = null;
  let closed = false;
  const ctx = { user: payload, ip: getClientIp(request) };

  audit('SESSION_START', `终端会话 ${session.id} 建立`, ctx);

  function cleanup() {
    if (closed) return;
    closed = true;
    clearTimeout(idleTimer);
    clearInterval(resumeTimer);
    // 销毁 pty：kill() + 进程组清理（含后台任务），事件回调为一次性注册随对象失效
    killPty(ptyProc);
    ptyProc = null;
    activeSessions.delete(session);
  }

  function scheduleIdle() {
    clearTimeout(idleTimer);
    idleTimer = setTimeout(() => {
      if (closed) return;
      audit('SESSION_IDLE_TIMEOUT', `终端会话 ${session.id} 空闲 ${IDLE_TIMEOUT / 60000} 分钟无输入，自动断开`, ctx);
      try { ws.close(WS_CLOSE_IDLE, 'idle timeout'); } catch {}
      cleanup();
    }, IDLE_TIMEOUT);
    if (idleTimer.unref) idleTimer.unref(); // 不阻止进程退出
  }

  // 流控恢复：onData 暂停后不再触发回调，恢复检查必须在消息路径/轮询中执行
  function maybeResume() {
    if (closed || !session._paused || !ptyProc) return;
    if (ws.readyState === WebSocket.OPEN && ws.bufferedAmount < MAX_PTY_BUFFER / 2) {
      session._paused = false;
      try { ptyProc.resume(); } catch {}
    }
  }

  ws.on('message', (data, isBinary) => {
    if (closed) return;
    maybeResume(); // 任意帧到达即尝试恢复（resize/输入/控制消息均可）
    // 二进制帧 = pty 输入（触发空闲计时刷新）
    if (isBinary) {
      if (!ptyProc) return;
      scheduleIdle();
      try { ptyProc.write(data); } catch {}
      return;
    }
    // 文本帧 = JSON 控制消息
    let msg;
    try { msg = JSON.parse(data.toString('utf8')); } catch {
      try { ws.close(WS_CLOSE_BAD_MSG, 'invalid json'); } catch {}
      cleanup(); return;
    }
    if (!msg || typeof msg.type !== 'string') {
      try { ws.close(WS_CLOSE_BAD_MSG, 'bad message'); } catch {}
      cleanup(); return;
    }
    switch (msg.type) {
      case 'auth':
        // 连接后可选再发 token 二次认证；无效立即断开（4001）
        if (!verifyToken(msg.token)) {
          audit('SESSION_AUTH_FAIL', `终端会话 ${session.id} 二次认证失败`, ctx);
          try { ws.close(WS_CLOSE_BAD_TOKEN, 'bad token'); } catch {}
          cleanup();
        }
        break;
      case 'resize': {
        const cols = Math.min(Math.max(parseInt(msg.cols, 10) || 80, 2), 500);
        const rows = Math.min(Math.max(parseInt(msg.rows, 10) || 24, 2), 200);
        if (ptyProc) { try { ptyProc.resize(cols, rows); } catch {} }
        break;
      }
      case 'ping':
        try { ws.send(JSON.stringify({ type: 'pong' })); } catch {}
        break;
      case 'bye':
        audit('SESSION_BYE', `终端会话 ${session.id} 主动退出`, ctx);
        try { ws.close(1000, 'bye'); } catch {}
        cleanup();
        break;
      default:
        break; // 未知控制消息忽略
    }
  });

  ws.on('error', (err) => {
    audit('SESSION_ERROR', `终端会话 ${session.id} WebSocket 错误: ${err.message}`, ctx);
    cleanup();
  });

  ws.on('close', () => {
    audit('SESSION_END', `终端会话 ${session.id} 连接关闭`, ctx);
    cleanup();
  });

  // 启动 pty（sudo -i → root shell）
  try {
    ptyProc = spawnPty(80, 24);
  } catch (e) {
    audit('SESSION_SPAWN_FAIL', `终端会话 ${session.id} pty 启动失败: ${e.message}`, ctx);
    try { ws.close(1011, 'pty spawn failed'); } catch {}
    cleanup(); return;
  }
  if (!ptyProc) {
    audit('SESSION_SPAWN_FAIL', `终端会话 ${session.id} 拒绝：node-pty 未安装或无法加载`, ctx);
    try { ws.close(1011, 'node-pty not installed'); } catch {}
    cleanup(); return;
  }

  // 兜底恢复轮询：即使客户端不再发任何帧，也能在缓冲排空后恢复 pty
  resumeTimer = setInterval(() => maybeResume(), RESUME_POLL_MS);
  if (resumeTimer.unref) resumeTimer.unref();

  // pty 输出 → ws 二进制帧（binaryType=arraybuffer）
  ptyProc.onData((data) => {
    if (closed || ws.readyState !== WebSocket.OPEN) return;
    // 仅做暂停判断（数据流动时天然触发）；恢复由 maybeResume（消息/轮询）负责
    if (!session._paused && ws.bufferedAmount > MAX_PTY_BUFFER) {
      session._paused = true;
      try { ptyProc.pause(); } catch {}
    }
    try { ws.send(data, { binary: true }); } catch {}
  });

  ptyProc.onExit(({ exitCode, signal }) => {
    audit('SESSION_EXIT', `终端会话 ${session.id} 进程退出 code=${exitCode} signal=${signal}`, ctx);
    cleanup();
    if (ws.readyState === WebSocket.OPEN) { try { ws.close(1000, 'pty exited'); } catch {} }
  });

  scheduleIdle();
  audit('SESSION_READY', `终端会话 ${session.id} pty 就绪`, ctx);
});

module.exports = router;
module.exports.handleUpgrade = handleUpgrade;