codex-market-app/electron/lib/voice_cdp.js

// voice_cdp.js —— ChatGPT/Codex 语音输入注入：主进程侧。
// 用 CDP（Chrome DevTools Protocol）连接带 --remote-debugging-port 的 ChatGPT/Codex 桌面版，
// 往其页面注入麦克风按钮脚本，录音经 binding 回传 → 调中转站 Whisper 转写 → 文字回填 composer。
// 不改 Codex 源码、不写补丁文件。无第三方依赖：CDP over WebSocket 用 Node 内置 net 手写最小 WS 客户端
// （Electron 34 主进程的 Node 无全局 WebSocket）；HTTP 用全局 fetch；multipart 用全局 FormData/Blob。
//
// 机制参考 CodexPlusPlus 的 bridge.rs：Runtime.evaluate / Page.addScriptToEvaluateOnNewDocument /
// Runtime.addBinding + Runtime.bindingCalled。
const { execFile, spawn } = require("child_process");
const fs = require("fs");
const net = require("net");
const crypto = require("crypto");
const os = require("os");
const path = require("path");

function dlog(...a) { try { console.log("[voice]", ...a); } catch {} }
const router = require("./router");
const codexDesktop = require("./codex_desktop");
const { INJECT_SCRIPT } = require("./voice_inject");
const { TOKEN_INJECT_SCRIPT } = require("./token_inject");
const tokenUsage = require("./token_usage");

const DEFAULT_PORT = 19222; // Codex 调试端口（避开 Chrome 默认 9222）
const BINDING_NAME = "__voiceBridge"; // 页面 → 主进程 的 CDP binding
const CDP_HTTP_TIMEOUT = 3000; // GET /json 超时
const CDP_WS_TIMEOUT = 5000; // WebSocket 握手超时
const CDP_CMD_TIMEOUT = 5000; // 单条 CDP 命令超时
const READY_POLL_INTERVAL = 500; // 轮询就绪间隔
const READY_POLL_MAX_MS = 180000; // 轮询就绪最长等待：Windows 冷启动可能要 2～3 分钟
const PACKAGED_READY_POLL_MAX_MS = 180000; // Store/MSIX 版 AppID 启动后也要给足白屏加载时间
const WINDOWS_LAUNCH_TIMEOUT_MS = 4500;
const WINDOWS_APPID_ACTIVATE_TIMEOUT_MS = 10000;
const RECORD_MAX_MS = 60000; // 单次录音上限（注入脚本侧也限）

// —— 状态机 ——
// unknown / checking / not_running / running_no_port / restarting / waiting_debug_port /
// unsupported_packaged / connecting / injecting / connected / disconnected / error
let state = {
  phase: "unknown",
  port: DEFAULT_PORT,
  codexPath: "",
  codexPackaged: false,
  codexLaunchType: "exe",
  codexAppId: "",
  launchWarning: "",
  portDiagnostic: "",
  lastError: "",
  discovery: null,
  target: null, // { id, url, title }
};
let session = null; // 当前 CdpSession
let voiceScriptIdentifier = ""; // 用于断开时撤销后续页面的语音自动注入
let networkSessions = []; // worker 等附加 target 的 Network 监听 session
let networkAttachGeneration = 0;
let onStatusCb = null;
let onSessionDeleteCb = null;
let tokenSyncTimer = null;

function snapshot() {
  const { phase, port, codexPath, codexPackaged, codexLaunchType, codexAppId, launchWarning, portDiagnostic, lastError, model, target, discovery } = state;
  return { phase, port, codexPath, codexPackaged, codexLaunchType, codexAppId, launchWarning, portDiagnostic, lastError, model, target, discovery };
}
function setPhase(phase, extra = {}) {
  state = { ...state, phase, ...extra };
  if (onStatusCb) {
    try {
      onStatusCb(snapshot());
    } catch {}
  }
}

async function syncTokenUsage() {
  if (!session) return;
  const usage = await tokenUsage.readDaily();
  if (!usage || !usage.available) return;
  try {
    await session.send("Runtime.evaluate", {
      expression: "window.__tdTokenSet && window.__tdTokenSet(" + JSON.stringify(usage) + ")",
      awaitPromise: false,
    });
  } catch {}
}

function startTokenSync() {
  if (tokenSyncTimer) clearInterval(tokenSyncTimer);
  tokenSyncTimer = setInterval(() => { syncTokenUsage().catch(() => {}); }, 2500);
  syncTokenUsage().catch(() => {});
}

function stopTokenSync() {
  if (tokenSyncTimer) clearInterval(tokenSyncTimer);
  tokenSyncTimer = null;
}

// —— 探测 Codex 可执行路径 ——
function scanCodexExecutable() {
  const candidates = codexDesktop.desktopExecutableCandidates();
  const candidate = candidates.find((item) => item && item.path && !item.packaged) ||
    candidates.find((item) => item && item.path && item.packaged);
  const exe = candidate && candidate.path ? candidate.path : "";
  state.codexPath = exe;
  state.codexPackaged = !!(candidate && candidate.packaged);
  state.codexLaunchType = (candidate && candidate.launchType) || "exe";
  state.codexAppId = (candidate && candidate.appId) || "";
  state.discovery = codexDesktop.discoveryReport ? codexDesktop.discoveryReport() : null;
  return exe;
}

function desktopNotFoundError() {
  const summary = codexDesktop.discoverySummary ? codexDesktop.discoverySummary() : "";
  const discovery = state.discovery || {};
  const hasPackaged = Array.isArray(discovery.candidates) && discovery.candidates.some((item) => item && item.packaged);
  if (process.platform === "win32") {
    return "未找到可直接启动的 ChatGPT/Codex 桌面程序。" +
      (summary ? "扫描结果：" + summary + "。" : "") +
      (hasPackaged ? "检测到 WindowsApps/Store 受保护入口，但它不能直接附加调试端口。" : "") +
      "请安装官网下载的桌面版后重试。";
  }
  return "未找到 ChatGPT/Codex 桌面程序。" + (summary ? "扫描结果：" + summary + "。" : "");
}

function desktopLaunchError(exePath, err) {
  const msg = String((err && err.message) || err || "");
  if (process.platform === "win32" && /eperm/i.test(msg)) {
    return "Windows 拒绝启动 ChatGPT/Codex 调试模式（EPERM）。路径：" + exePath +
      "。如果这是 Microsoft Store/WindowsApps 版本，请改装官网下载的桌面版；如果是普通 exe，请用管理员权限启动工具箱后再试。";
  }
  return "启动 ChatGPT/Codex 失败：" + msg + (exePath ? "。路径：" + exePath : "");
}

function compactError(err, fallback = "未知错误") {
  const parts = [
    err && err.stderr,
    err && err.stdout,
    err && err.message,
    err,
  ].filter(Boolean).map((v) => String(v));
  const raw = parts.find((v) => v.trim()) || fallback;
  return raw
    .replace(/Command failed:[\s\S]*?(?=(\r?\n|$))/i, "")
    .replace(/\s+/g, " ")
    .trim()
    .slice(0, 220) || fallback;
}

function compactCommandLine(cmd) {
  const text = String(cmd || "").replace(/\s+/g, " ").trim();
  if (!text) return "";
  const hasWindowsApps = /WindowsApps/i.test(text);
  const hasDebugArg = /--remote-debugging-port/i.test(text);
  const exe = (text.match(/(?:^|[ "])([A-Z]:\\[^"]*?(?:ChatGPT|Codex)[^"\\]*\.exe)/i) || [])[1] || "";
  const pidPart = exe ? exe.replace(/^.*[\\/]/, "") : "";
  const tags = [];
  if (hasWindowsApps) tags.push("WindowsApps");
  tags.push(hasDebugArg ? "含调试参数" : "无调试参数");
  return [pidPart, tags.join("/")].filter(Boolean).join(" ");
}

function updateWindowsProcessDiagnostic(port) {
  if (process.platform !== "win32" || !codexDesktop.windowsProcessDiagnostics) return null;
  try {
    const d = codexDesktop.windowsProcessDiagnostics(port);
    if (!d || !Array.isArray(d.rows) || !d.rows.length) {
      state.portDiagnostic = "未检测到 ChatGPT/Codex 进程";
      return d;
    }
    state.portDiagnostic = d.hasDebugArg
      ? "进程命令行已包含调试端口参数"
      : "进程命令行未包含 --remote-debugging-port=" + port + "，调试端口不会打开";
    const rowsSummary = d.rows.map((row) => {
      const name = (row && row.Name) || "process";
      const pid = (row && row.ProcessId) || "?";
      const cmd = compactCommandLine((row && row.CommandLine) || "");
      return `${name}#${pid}${cmd ? " " + cmd : ""}`;
    }).join(" | ");
    if (rowsSummary) state.portDiagnostic += "；" + rowsSummary;
    state.portDiagnostic = state.portDiagnostic.slice(0, 260);
    return d;
  } catch (e) {
    state.portDiagnostic = "读取进程命令行失败：" + compactError(e);
    return null;
  }
}

function debugPortFailureMessage(action, port) {
  const diag = updateWindowsProcessDiagnostic(port);
  if (state.codexPackaged) {
    const reason = diag && diag.rows && diag.rows.length && !diag.hasDebugArg
      ? "当前 Store/MSIX 启动参数没有进入 Codex 进程，无法打开调试端口。"
      : "当前 Store/MSIX 启动方式未开放调试端口。";
    return "已尝试通过 Windows AppID " + action + " ChatGPT/Codex，但未检测到调试端口。" +
      reason + "建议改装官网下载桌面版。";
  }
  return action === "重启" ? "重启 ChatGPT 后未开放调试端口" : "Codex 启动后未开放调试端口，请重试";
}

function isPackagedDebugArgMissing(port) {
  if (!state.codexPackaged || process.platform !== "win32") return false;
  const d = updateWindowsProcessDiagnostic(port);
  return !!(d && Array.isArray(d.rows) && d.rows.length && !d.hasDebugArg);
}

function setDebugPortFailure(action, port) {
  const unsupported = isPackagedDebugArgMissing(port);
  setPhase(unsupported ? "unsupported_packaged" : "error", {
    lastError: debugPortFailureMessage(action, port) + (state.launchWarning ? "（" + state.launchWarning + "）" : ""),
    portDiagnostic: state.portDiagnostic,
  });
}

function windowsLaunchArgs(port) {
  return [
    `--remote-debugging-port=${port}`,
    `--remote-allow-origins=http://127.0.0.1:${port}`,
  ];
}

function quoteWindowsArgument(arg) {
  const text = String(arg || "");
  if (text && !/[ \t"]/.test(text)) return text;
  let out = "\"";
  let backslashes = 0;
  for (const ch of text) {
    if (ch === "\\") {
      backslashes += 1;
      continue;
    }
    if (ch === "\"") {
      out += "\\".repeat(backslashes * 2 + 1) + "\"";
      backslashes = 0;
      continue;
    }
    out += "\\".repeat(backslashes) + ch;
    backslashes = 0;
  }
  out += "\\".repeat(backslashes * 2) + "\"";
  return out;
}

function windowsCommandLineArguments(args) {
  return args.map(quoteWindowsArgument).join(" ");
}

function windowsActivateAppId(appId, port) {
  return new Promise((resolve, reject) => {
    if (process.platform !== "win32") {
      reject(new Error("AppID activation only supports Windows"));
      return;
    }
    const script = [
      "$ErrorActionPreference='Stop'",
      "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
      "$OutputEncoding=[System.Text.Encoding]::UTF8",
      "$code = @'",
      "using System;",
      "using System.Runtime.InteropServices;",
      "namespace TdCodexAppActivation {",
      "[ComImport, Guid(\"45BA127D-10A8-46EA-8AB7-56EA9078943C\")]",
      "public class ApplicationActivationManager {}",
      "[ComImport, Guid(\"2e941141-7f97-4756-ba1d-9decde894a3d\"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]",
      "public interface IApplicationActivationManager {",
      "  [PreserveSig]",
      "  int ActivateApplication([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, [MarshalAs(UnmanagedType.LPWStr)] string arguments, int options, out uint processId);",
      "  [PreserveSig]",
      "  int ActivateForFile([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, IntPtr itemArray, [MarshalAs(UnmanagedType.LPWStr)] string verb, out uint processId);",
      "  [PreserveSig]",
      "  int ActivateForProtocol([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, IntPtr itemArray, out uint processId);",
      "}",
      "public static class Launcher {",
      "  const int COINIT_APARTMENTTHREADED = 0x2;",
      "  const int RPC_E_CHANGED_MODE = unchecked((int)0x80010106);",
      "  [DllImport(\"ole32.dll\")] static extern int CoInitializeEx(IntPtr pvReserved, int dwCoInit);",
      "  [DllImport(\"ole32.dll\")] static extern void CoUninitialize();",
      "  public static uint Activate(string appUserModelId, string arguments) {",
      "    int coinit = CoInitializeEx(IntPtr.Zero, COINIT_APARTMENTTHREADED);",
      "    bool shouldUninitialize = coinit >= 0;",
      "    if (coinit < 0 && coinit != RPC_E_CHANGED_MODE) Marshal.ThrowExceptionForHR(coinit);",
      "    try {",
      "      var manager = (IApplicationActivationManager)new ApplicationActivationManager();",
      "      uint processId = 0;",
      "      int hr = manager.ActivateApplication(appUserModelId, arguments, 0, out processId);",
      "      if (hr != 0) throw new COMException(\"ActivateApplication failed\", hr);",
      "      return processId;",
      "    } finally {",
      "      if (shouldUninitialize) CoUninitialize();",
      "    }",
      "  }",
      "}",
      "}",
      "'@",
      "Add-Type -TypeDefinition $code -ErrorAction Stop",
      "$activatedProcessId=[TdCodexAppActivation.Launcher]::Activate($env:TD_CODEX_APPID, $env:TD_CODEX_LAUNCH_ARGS)",
      "[pscustomobject]@{ok=$true;pid=$activatedProcessId;args=$env:TD_CODEX_LAUNCH_ARGS}|ConvertTo-Json -Compress",
    ].join("\n");
    const scriptPath = path.join(os.tmpdir(), "td-codex-appid-activate-" + process.pid + "-" + Date.now() + ".ps1");
    try {
      fs.writeFileSync(scriptPath, script, "utf8");
    } catch (e) {
      reject(e);
      return;
    }
    execFile("powershell.exe", ["-NoProfile", "-Sta", "-ExecutionPolicy", "Bypass", "-File", scriptPath], {
      env: {
        ...process.env,
        TD_CODEX_APPID: String(appId || ""),
        TD_CODEX_LAUNCH_PORT: String(port),
        TD_CODEX_LAUNCH_ARGS: windowsCommandLineArguments(windowsLaunchArgs(port)),
      },
      windowsHide: true,
      timeout: WINDOWS_APPID_ACTIVATE_TIMEOUT_MS,
    }, (err, stdout) => {
      try { fs.rmSync(scriptPath, { force: true }); } catch {}
      if (err) {
        reject(err);
        return;
      }
      let data = null;
      try {
        data = JSON.parse(String(stdout || "").trim());
      } catch {}
      resolve(data || { ok: true });
    });
  });
}

function windowsShellStart(exePath, port) {
  return new Promise((resolve, reject) => {
    if (process.platform !== "win32") {
      reject(new Error("shell start only supports Windows"));
      return;
    }
    const launchType = state.codexLaunchType || "exe";
    const target = launchType === "appId"
      ? "shell:AppsFolder\\" + String(state.codexAppId || exePath || "").trim()
      : String(exePath || "").replace(/^\\\\\?\\/, "");
    if (launchType === "appId") {
      windowsActivateAppId(state.codexAppId || exePath, port).then((data) => {
        const pid = data && data.pid ? `，PID ${data.pid}` : "";
        state.launchWarning = "已通过 Windows AppID 激活 Store/MSIX 版 Codex" + pid;
        resolve(true);
      }).catch((activateErr) => {
        execFile("explorer.exe", [target], { windowsHide: true, timeout: WINDOWS_LAUNCH_TIMEOUT_MS }, (err) => {
          const first = "COM 激活提示：" + compactError(activateErr, "AppID 激活失败");
          if (err) {
            // explorer.exe often returns a failure code for shell:AppsFolder
            // even after Windows has already handed off and launched the app.
            const second = "explorer 提示：" + compactError(err, "explorer 启动失败");
            state.launchWarning = (first + "；" + second).slice(0, 220);
            resolve(false);
            return;
          }
          state.launchWarning = (first + "；已通过 explorer 兜底拉起 Store/MSIX 版 Codex").slice(0, 220);
          resolve(true);
        });
      });
      return;
    }
    const script = [
      "$target=$env:TD_CODEX_LAUNCH_TARGET",
      "$args=@('--remote-debugging-port=' + $env:TD_CODEX_LAUNCH_PORT, '--remote-allow-origins=http://127.0.0.1:' + $env:TD_CODEX_LAUNCH_PORT)",
      "Start-Process -FilePath $target -ArgumentList $args",
    ].join(";");
    execFile("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
      env: {
        ...process.env,
        TD_CODEX_LAUNCH_TARGET: target,
        TD_CODEX_LAUNCH_PORT: String(port),
      },
      windowsHide: true,
      timeout: WINDOWS_LAUNCH_TIMEOUT_MS,
    }, (err) => {
      if (err) {
        reject(err);
        return;
      }
      state.launchWarning = "";
      resolve(true);
    });
  });
}

// —— HTTP：GET /json 取 targets ——
async function listTargets(port) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), CDP_HTTP_TIMEOUT);
  try {
    const res = await fetch(`http://127.0.0.1:${port}/json`, { signal: ctrl.signal });
    if (!res.ok) return [];
    const arr = await res.json();
    return Array.isArray(arr) ? arr : [];
  } catch {
    return [];
  } finally {
    clearTimeout(t);
  }
}

// —— 挑可注入的 Codex 主页面 target ——
// Codex 可能有多个 page：主对话页 app://-/index.html，以及 avatar-overlay / global-dictation
// 等带 ?initialRoute= 的子路由覆盖层。优先选「无 query 的主入口」，次选普通 codex 页，排除覆盖层。
function pickTarget(targets) {
  let main = null; // url 恰为 app://-/index.html（无 query）
  let fallback = null; // 其它非覆盖层 codex 页
  for (const t of targets) {
    if (t.type !== "page") continue;
    const ws = t.webSocketDebuggerUrl;
    if (!ws) continue;
    const url = (t.url || "").toLowerCase();
    const title = (t.title || "").toLowerCase();
    // 覆盖层：带 initialRoute 的子路由（avatar-overlay / global-dictation 等）
    const isOverlayRoute = url.includes("initialroute=");
    const isCodex =
      url.startsWith("app://-/index.html") || url.includes("index.html") || title.includes("codex");
    if (!isCodex) continue;
    if (isOverlayRoute) continue; // 覆盖层不注入
    if (url === "app://-/index.html" || url === "app://-/index.html/") {
      main = main || t;
    } else {
      fallback = fallback || t;
    }
  }
  return main || fallback;
}

// —— 最小 WebSocket 客户端（Node 内置 net，无需依赖；仅支持 CDP 需要的文本帧）——
// 解析 ws://host:port/path，TCP 连接 → HTTP 升级握手（带 Sec-WebSocket-Key）→ 文本帧收发。
// 客户端发送必须掩码；CDP 服务端发送不掩码。帧可能分片到达，用缓冲区拼。
function wsConnect(wsUrl) {
  const u = new URL(wsUrl);
  const host = u.hostname;
  const port = u.port || (u.protocol === "wss:" ? "443" : "80");
  const pathStr = u.pathname + u.search;
  const key = crypto.randomBytes(16).toString("base64");

  const socket = net.connect({ host, port: Number(port) });
  const events = { open: [], message: [], close: [], error: [] };
  const emit = (name, arg) => (events[name] || []).forEach((cb) => cb(arg));
  socket.setTimeout(CDP_WS_TIMEOUT, () => {
    if (!handshakeDone) emit("error", new Error("WS 连接超时"));
    try { socket.destroy(); } catch {}
  });

  // —— 发送一帧文本（客户端必须掩码）——
  function sendFrame(str) {
    const payload = Buffer.from(str, "utf8");
    const len = payload.length;
    // opcode 1 = 文本；FIN=1
    let header;
    const mask = crypto.randomBytes(4);
    if (len < 126) {
      header = Buffer.alloc(6);
      header[0] = 0x81;
      header[1] = 0x80 | len;
      mask.copy(header, 2);
    } else if (len < 65536) {
      header = Buffer.alloc(8);
      header[0] = 0x81;
      header[1] = 0x80 | 126;
      header.writeUInt16BE(len, 2);
      mask.copy(header, 4);
    } else {
      header = Buffer.alloc(14);
      header[0] = 0x81;
      header[1] = 0x80 | 127;
      header.writeUInt32BE(0, 2);
      header.writeUInt32BE(len, 6);
      mask.copy(header, 10);
    }
    const masked = Buffer.alloc(len);
    for (let i = 0; i < len; i++) masked[i] = payload[i] ^ mask[i & 3];
    socket.write(Buffer.concat([header, masked]));
  }

  // —— 接收缓冲 + 帧解析 ——
  let buf = Buffer.alloc(0);
  let handshakeDone = false;
  function parseFrames() {
    while (true) {
      if (buf.length < 2) return;
      const b0 = buf[0];
      const b1 = buf[1];
      const opcode = b0 & 0x0f;
      const masked = (b1 & 0x80) !== 0;
      let payloadLen = b1 & 0x7f;
      let offset = 2;
      if (payloadLen === 126) {
        if (buf.length < 4) return;
        payloadLen = buf.readUInt16BE(2);
        offset = 4;
      } else if (payloadLen === 127) {
        if (buf.length < 10) return;
        // 高 32 位忽略（CDP 帧不会那么大）
        payloadLen = Number(buf.readUInt32BE(6));
        offset = 10;
      }
      let maskKey = null;
      if (masked) {
        if (buf.length < offset + 4) return;
        maskKey = buf.slice(offset, offset + 4);
        offset += 4;
      }
      if (buf.length < offset + payloadLen) return;
      let payload = buf.slice(offset, offset + payloadLen);
      if (masked) {
        const un = Buffer.alloc(payload.length);
        for (let i = 0; i < payload.length; i++) un[i] = payload[i] ^ maskKey[i & 3];
        payload = un;
      }
      buf = buf.slice(offset + payloadLen);
      // 只处理文本(1)/ping(9)/pong(10)/关闭(8)
      if (opcode === 0x8) {
        // 关闭帧
        emit("close");
        try {
          socket.end();
        } catch {}
        return;
      } else if (opcode === 0x9) {
        // ping → 回 pong（无掩码服务端不要求，但回时按服务端→客户端本可不掩码；此处回文本帧不规范，CDP 不发 ping）
        continue;
      } else if (opcode === 0xa) {
        continue; // pong，忽略
      } else {
        // 文本帧（含分片首帧 opcode 0 也按文本拼；CDP 单帧文本足够，简单按单帧处理）
        emit("message", payload.toString("utf8"));
      }
    }
  }

  socket.on("connect", () => {
    const req =
      `GET ${pathStr} HTTP/1.1\r\n` +
      `Host: ${host}:${port}\r\n` +
      `Upgrade: websocket\r\n` +
      `Connection: Upgrade\r\n` +
      `Sec-WebSocket-Key: ${key}\r\n` +
      `Sec-WebSocket-Version: 13\r\n\r\n`;
    socket.write(req);
  });
  socket.on("data", (chunk) => {
    buf = Buffer.concat([buf, chunk]);
    if (!handshakeDone) {
      const idx = buf.indexOf("\r\n\r\n");
      if (idx < 0) return;
      const head = buf.slice(0, idx).toString("utf8");
      buf = buf.slice(idx + 4);
      if (!/101/.test(head.split("\r\n")[0])) {
        emit("error", new Error("WS 握手失败: " + head.split("\r\n")[0]));
        try {
          socket.destroy();
        } catch {}
        return;
      }
      handshakeDone = true;
      try { socket.setTimeout(0); } catch {}
      emit("open");
      parseFrames();
    } else {
      parseFrames();
    }
  });
  socket.on("close", () => emit("close"));
  socket.on("error", (e) => emit("error", e));

  return {
    send: sendFrame,
    close: () => {
      try {
        socket.destroy();
      } catch {}
    },
    on: (name, cb) => {
      (events[name] = events[name] || []).push(cb);
    },
    _socket: socket,
  };
}

// —— CDP WebSocket 会话 ——
function openSession(wsUrl, onBindingCalled) {
  const pending = new Map(); // id → {resolve, reject}
  const handlers = new Map(); // method → Set<cb>
  let nextId = 1;
  let closed = false;
  const ws = wsConnect(wsUrl);

  function send(method, params = {}) {
    return new Promise((resolve, reject) => {
      if (closed) return reject(new Error("CDP 会话已关闭"));
      const id = nextId++;
      const timer = setTimeout(() => {
        pending.delete(id);
        reject(new Error("CDP 命令超时: " + method));
      }, CDP_CMD_TIMEOUT);
      pending.set(id, {
        resolve: (value) => {
          clearTimeout(timer);
          resolve(value);
        },
        reject: (err) => {
          clearTimeout(timer);
          reject(err);
        },
      });
      ws.send(JSON.stringify({ id, method, params }));
    });
  }
  function on(method, cb) {
    if (!handlers.has(method)) handlers.set(method, new Set());
    handlers.get(method).add(cb);
  }
  function close() {
    closed = true;
    try {
      ws.close();
    } catch {}
  }

  ws.on("message", (data) => {
    let msg;
    try {
      msg = JSON.parse(data);
    } catch {
      return;
    }
    if (msg.id != null) {
      const p = pending.get(msg.id);
      if (!p) return;
      pending.delete(msg.id);
      if (msg.error) p.reject(new Error(msg.error.message || "CDP error"));
      else p.resolve(msg.result);
      return;
    }
    if (msg.method) {
      if (msg.method === "Runtime.bindingCalled" && onBindingCalled) {
        try {
          onBindingCalled(msg.params);
        } catch {}
      }
      const set = handlers.get(msg.method);
      if (set) for (const cb of set) cb(msg.params);
    }
  });
  ws.on("close", () => {
    closed = true;
    for (const { reject } of pending.values()) {
      try {
        reject(new Error("CDP 会话关闭"));
      } catch {}
    }
    pending.clear();
  });

  return new Promise((resolve, reject) => {
    ws.on("open", () => resolve({ send, on, close, ws }));
    ws.on("error", (e) => reject(new Error("CDP 连接失败：" + (e && e.message ? e.message : "ws error"))));
  });
}

// —— 转写：中转站 /v1/audio/transcriptions（用 sttGroup：勾选了 STT 的分组）——
async function runStt(audioB64, mime) {
  const g = router.sttGroup();
  if (!g || !g.baseUrl || !g.key) throw new Error("未配置支持语音转文字的中转分组（在路由中转里勾选「支持语音转文字」）");
  const base = (g.baseUrl || "").replace(/\/+$/, "");
  const model = g.sttModel || "whisper-1";
  const buf = Buffer.from(audioB64, "base64");
  const ext = mime && mime.includes("webm") ? "webm" : mime && mime.includes("mp4") ? "mp4" : "wav";
  const form = new FormData();
  form.append("file", new Blob([buf], { type: mime || "audio/webm" }), `voice.${ext}`);
  form.append("model", model);
  form.append("response_format", "json");
  const res = await fetch(base + "/v1/audio/transcriptions", {
    method: "POST",
    headers: { Authorization: "Bearer " + g.key },
    body: form,
  });
  dlog("转写请求 →", base + "/v1/audio/transcriptions", "model=" + model, "size=" + buf.length, "HTTP " + res.status);
  if (!res.ok) {
    const detail = await res.text().catch(() => "");
    throw new Error(`转写接口 HTTP ${res.status}：${detail.slice(0, 300)}`);
  }
  const j = await res.json();
  return (j && (j.text || "")).trim();
}

// —— 主进程收到页面 binding 回传：处理转写并把文字送回页面 ——
async function handleBinding(params) {
  const name = params && params.name;
  if (name !== BINDING_NAME) return;
  let payload;
  try {
    payload = JSON.parse(params.payload);
  } catch {
    return;
  }
  if (!payload) return;
  if (
    payload.kind === "delete-session" ||
    payload.kind === "delete-session-clipboard-prepare" ||
    payload.kind === "delete-session-clipboard-read"
  ) {
    if (onSessionDeleteCb) {
      try { await onSessionDeleteCb(payload); } catch (e) { dlog("永久删除会话请求失败:", e && e.message); }
    }
    return;
  }
  if (payload.kind === "debug-sidebar-dump") {
    dlog("侧边栏诊断:", JSON.stringify(payload.info || {}));
    return;
  }
  if (payload.kind !== "transcribe") return;
  const { id, audioB64, mime } = payload;
  dlog("binding 收到转写请求 id=" + id, "mime=" + mime, "audioB64长度=" + (audioB64?audioB64.length:0));
  setPhase("transcribing");
  let text = "";
  let err = "";
  try {
    text = await runStt(audioB64, mime);
    dlog("转写结果:", JSON.stringify(text).slice(0, 120));
  } catch (e) {
    err = String((e && e.message) || e);
    dlog("转写失败:", err);
  }
  setPhase(connectedPhase());
  // 把结果回调给页面
  const expr = `window.__voiceInjectHandle && window.__voiceInjectHandle(${JSON.stringify(
    { id, text, err }
  )})`;
  try {
    if (session) await session.send("Runtime.evaluate", { expression: expr, awaitPromise: false });
  } catch {}
}

function connectedPhase() {
  return session ? "connected" : "disconnected";
}

// —— 注入：addBinding + addScriptToEvaluateOnNewDocument + 立即 evaluate + Network 监听 ——
async function inject(sessionObj) {
  // 清除 require 缓存，使 voice_inject.js 的修改能在重连时生效，无需重启整个应用
  delete require.cache[require.resolve("./voice_inject")];
  delete require.cache[require.resolve("./token_inject")];
  const { INJECT_SCRIPT: FRESH_INJECT } = require("./voice_inject");
  const { TOKEN_INJECT_SCRIPT: FRESH_TOKEN } = require("./token_inject");
  await sessionObj.send("Runtime.enable");
  try {
    await sessionObj.send("Runtime.removeBinding", { name: BINDING_NAME });
  } catch {}
  await sessionObj.send("Runtime.addBinding", { name: BINDING_NAME });
  await sessionObj.send("Page.enable");
  // 语音注入脚本
  const voiceScript = await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: FRESH_INJECT });
  voiceScriptIdentifier = (voiceScript && voiceScript.identifier) || "";
  await sessionObj.send("Runtime.evaluate", { expression: FRESH_INJECT, awaitPromise: false });
  // Token 用量 UI 注入脚本（只负责 UI + localStorage，不管网络抓取）
  await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: FRESH_TOKEN });
  await sessionObj.send("Runtime.evaluate", { expression: FRESH_TOKEN, awaitPromise: false });
  // 启用 Network 域，在 CDP 层面拦截 LLM 响应抓 token 用量
  await sessionObj.send("Network.enable");
}

// ============================================================================
//  Token 用量：CDP Network 域拦截 LLM 响应抓 usage（不受页面 CSP 限制）
// ============================================================================
// 待完成的请求：requestId → { url, mimeType }
const pendingNetworkReqs = new Map();
let nextNetworkSessionId = 1;
const tokenNet = {
  matchedCount: 0,
  usageCount: 0,
  noUsageCount: 0,
  lastMatchedUrl: "",
  lastUsageUrl: "",
  lastNoUsageUrl: "",
  lastUsageTotal: 0,
  lastError: "",
  attachedWorkers: 0,
};
const LLM_URL_RE = /\/(chat\/completions|v1\/messages|messages|generateContent|streamGenerateContent|completions|responses|backend-api\/(?:codex|conversation|responses)|codex|conversation)(\/|$|\?)/i;

function networkReqKey(ownerSession, requestId) {
  if (!ownerSession._tdTokenNetId) ownerSession._tdTokenNetId = nextNetworkSessionId++;
  return ownerSession._tdTokenNetId + ":" + requestId;
}

function bindNetworkHandlers(ownerSession) {
  if (!ownerSession) return;
  if (!ownerSession._tdTokenNetId) ownerSession._tdTokenNetId = nextNetworkSessionId++;
  ownerSession.on("Network.responseReceived", (params) => handleNetworkResponse(params, ownerSession));
  ownerSession.on("Network.loadingFinished", (params) => handleNetworkLoadingFinished(params, ownerSession));
  ownerSession.on("Network.loadingFailed", (params) => handleNetworkLoadingFailed(params, ownerSession));
}

function handleNetworkResponse(params, ownerSession) {
  const { requestId, response } = params || {};
  if (!requestId || !response || !ownerSession) return;
  const url = response.url || "";
  if (!LLM_URL_RE.test(url)) return;
  // 只处理 JSON 响应
  const mime = (response.mimeType || "").toLowerCase();
  if (!mime.includes("json") && !mime.includes("text")) return;
  tokenNet.matchedCount += 1;
  tokenNet.lastMatchedUrl = url;
  pendingNetworkReqs.set(networkReqKey(ownerSession, requestId), { url, mimeType: mime });
}

function handleNetworkLoadingFailed(params, ownerSession) {
  const { requestId } = params || {};
  if (requestId && ownerSession) pendingNetworkReqs.delete(networkReqKey(ownerSession, requestId));
}

async function handleNetworkLoadingFinished(params, ownerSession) {
  const { requestId } = params || {};
  if (!requestId || !ownerSession) return;
  const key = networkReqKey(ownerSession, requestId);
  if (!pendingNetworkReqs.has(key)) return;
  const reqInfo = pendingNetworkReqs.get(key) || {};
  pendingNetworkReqs.delete(key);
  if (!session || !ownerSession) return;
  try {
    const r = await ownerSession.send("Network.getResponseBody", { requestId });
    const body = (r && r.body) || "";
    if (!body || body.length < 10) return;
    // 可能被 base64 编码
    let text = body;
    if (r && r.base64Encoded) {
      try { text = Buffer.from(body, "base64").toString("utf8"); } catch { return; }
    }
    // 解析 JSON 提取 usage
    const usage = extractUsageFromText(text);
    if (usage && usage.total > 0) {
      tokenNet.usageCount += 1;
      tokenNet.lastUsageUrl = reqInfo.url || "";
      tokenNet.lastUsageTotal = usage.total || 0;
      tokenNet.lastError = "";
      dlog(
        "token: +" + usage.total +
          " input=" + (usage.input || 0) +
          " output=" + (usage.output || 0) +
          " cached=" + (usage.cached || 0) +
          " from",
        reqInfo.url || "?"
      );
      // 通过 Runtime.evaluate 调注入脚本更新 UI
      try {
        await session.send("Runtime.evaluate", {
          expression: "window.__tdTokenAdd && window.__tdTokenAdd(" + JSON.stringify(usage) + ", 'network')",
          awaitPromise: false,
        });
      } catch {}
    } else {
      tokenNet.noUsageCount += 1;
      tokenNet.lastNoUsageUrl = reqInfo.url || "";
    }
  } catch (e) {
    tokenNet.lastError = String((e && e.message) || e || "getResponseBody failed").slice(0, 160);
    // getResponseBody 可能失败（响应体已被清掉或太大），静默跳过
  }
}

function extractUsageFromText(text) {
  let best = null;
  const take = (obj) => {
    best = betterUsage(best, extractUsageFromObject(obj));
  };
  try {
    take(JSON.parse(text));
  } catch {}
  if (usageTotal(best) > 0) return best;

  // Stream/SSE: data: {"usage":...}\n\n or data: [DONE]
  const lines = String(text || "").split(/\r?\n/);
  for (const line of lines) {
    const s = line.trim();
    const payload = s.startsWith("data:") ? s.slice(5).trim() : s;
    if (!payload || payload === "[DONE]") continue;
    try { take(JSON.parse(payload)); } catch {}
  }
  return best;
}

function cleanTokenNumber(n) {
  n = Number(n);
  return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
}

function usageTotal(u) {
  return u ? cleanTokenNumber(u.total) : 0;
}

function betterUsage(a, b) {
  return usageTotal(b) > usageTotal(a) ? b : a;
}

function hasOwn(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}

function looksLikeUsage(usage) {
  if (!usage || typeof usage !== "object") return false;
  const keys = [
    "input_tokens", "prompt_tokens", "output_tokens", "completion_tokens", "total_tokens",
    "promptTokenCount", "prompt_token_count", "inputTokenCount", "outputTokenCount",
    "candidatesTokenCount", "candidates_token_count", "totalTokenCount", "total_token_count",
    "token_count", "cache_creation_input_tokens", "cache_read_input_tokens",
    "cachedContentTokenCount", "cached_content_token_count", "reasoning_tokens",
    "thoughtsTokenCount", "thoughts_token_count",
  ];
  if (keys.some((key) => hasOwn(usage, key))) return true;
  return hasOwn(usage, "total") && (hasOwn(usage, "input") || hasOwn(usage, "output") || hasOwn(usage, "cached"));
}

function extractUsageFromRawUsage(usage) {
  if (!usage || typeof usage !== "object") return null;
  if (!looksLikeUsage(usage)) return null;
  const input = cleanTokenNumber(
    usage.input_tokens ||
      usage.prompt_tokens ||
      usage.promptTokenCount ||
      usage.prompt_token_count ||
      usage.inputTokenCount
  );
  const output = cleanTokenNumber(
    usage.output_tokens ||
      usage.completion_tokens ||
      usage.candidatesTokenCount ||
      usage.candidates_token_count ||
      usage.outputTokenCount
  );
  const reasoning = cleanTokenNumber(usage.reasoning_tokens || usage.thoughtsTokenCount || usage.thoughts_token_count);
  const details = usage.input_tokens_details || usage.prompt_tokens_details || usage.inputTokenDetails || usage.promptTokenDetails || {};
  const cached =
    cleanTokenNumber(details.cached_tokens) +
    cleanTokenNumber(usage.cache_creation_input_tokens) +
    cleanTokenNumber(usage.cache_read_input_tokens) +
    cleanTokenNumber(usage.cachedContentTokenCount) +
    cleanTokenNumber(usage.cached_content_token_count);
  const total = cleanTokenNumber(
    usage.total_tokens ||
      usage.totalTokenCount ||
      usage.total_token_count ||
      usage.token_count ||
      usage.total
  ) || input + output + reasoning + cached;
  if (!total) return null;
  return { total, input, output: output + reasoning, cached };
}

function extractUsageFromObject(obj) {
  if (!obj || typeof obj !== "object") return null;
  const direct =
    extractUsageFromRawUsage(obj.usage) ||
    extractUsageFromRawUsage(obj.usage_metadata) ||
    extractUsageFromRawUsage(obj.usageMetadata) ||
    extractUsageFromRawUsage(obj);
  if (direct) return direct;
  let best = null;
  for (const val of Object.values(obj)) {
    if (!val || typeof val !== "object") continue;
    if (Array.isArray(val)) {
      for (const item of val) best = betterUsage(best, extractUsageFromObject(item));
    } else {
      best = betterUsage(best, extractUsageFromObject(val));
    }
  }
  return best;
}

async function attachNetworkSession(target, generation) {
  if (!target || !target.webSocketDebuggerUrl) return;
  let netSession = null;
  try {
    netSession = await openSession(target.webSocketDebuggerUrl, null);
    bindNetworkHandlers(netSession);
    await netSession.send("Network.enable");
    if (!session || generation !== networkAttachGeneration) {
      try { netSession.close(); } catch {}
      return false;
    }
    networkSessions.push(netSession);
    dlog("token network attached:", target.type || "target", target.id || "", target.url || "");
    return true;
  } catch (e) {
    if (netSession) {
      try { netSession.close(); } catch {}
    }
    tokenNet.lastError = String((e && e.message) || e || "attach network failed").slice(0, 160);
    return false;
  }
}

async function attachWorkerNetworkTargets(port, parentId) {
  const targets = await listTargets(port);
  const workers = targets.filter((t) =>
    t &&
    t.webSocketDebuggerUrl &&
    (t.type === "worker" || t.type === "service_worker" || t.type === "shared_worker") &&
    (!parentId || t.parentId === parentId)
  );
  const generation = networkAttachGeneration;
  const results = await Promise.all(workers.map((worker) => attachNetworkSession(worker, generation)));
  tokenNet.attachedWorkers = results.filter(Boolean).length;
}

function closeNetworkSessions() {
  networkAttachGeneration += 1;
  for (const s of networkSessions) {
    try { s.close(); } catch {}
  }
  networkSessions = [];
  pendingNetworkReqs.clear();
}

// —— 连接到已带端口的 Codex ——
async function connectToTarget(port) {
  const targets = await listTargets(port);
  const tgt = pickTarget(targets);
  if (!tgt) return false;
  closeNetworkSessions();
  state.target = { id: tgt.id, url: tgt.url, title: tgt.title };
  setPhase("connecting");
  const ownedSession = await openSession(tgt.webSocketDebuggerUrl, handleBinding);
  session = ownedSession;
  // Token 用量：Network 层拦截 LLM 响应
  bindNetworkHandlers(ownedSession);
  ownedSession.ws.on("close", () => {
    if (session !== ownedSession) return;
    stopTokenSync();
    closeNetworkSessions();
    session = null;
    setPhase("disconnected");
  });
  setPhase("injecting");
  await inject(ownedSession);
  startTokenSync();
  setPhase("connected", { target: state.target });
  attachWorkerNetworkTargets(port, tgt.id).catch((e) => {
    tokenNet.lastError = String((e && e.message) || e || "attach workers failed").slice(0, 160);
  });
  return true;
}

// —— 轮询直到出现 page target（重启后用）——
async function waitForReady(port) {
  const t0 = Date.now();
  const maxMs = state.codexPackaged ? PACKAGED_READY_POLL_MAX_MS : READY_POLL_MAX_MS;
  let diagnosed = false;
  while (Date.now() - t0 < maxMs) {
    const targets = await listTargets(port);
    const tgt = pickTarget(targets);
    if (tgt) return tgt;
    if (!diagnosed && process.platform === "win32" && Date.now() - t0 >= 5000) {
      diagnosed = true;
      const d = updateWindowsProcessDiagnostic(port);
      setPhase("waiting_debug_port", { portDiagnostic: state.portDiagnostic });
      if (state.codexPackaged && d && Array.isArray(d.rows) && d.rows.length && !d.hasDebugArg) {
        return null;
      }
    }
    await new Promise((r) => setTimeout(r, READY_POLL_INTERVAL));
  }
  updateWindowsProcessDiagnostic(port);
  return null;
}

function spawnCodex(exePath, port) {
  if (state.codexPackaged && process.platform === "win32") {
    return windowsShellStart(exePath, port);
  }
  return new Promise((resolve, reject) => {
    let child = null;
    try {
      const args = process.platform === "win32" ? windowsLaunchArgs(port) : [`--remote-debugging-port=${port}`];
      child = spawn(exePath, args, {
        detached: true,
        stdio: "ignore",
        windowsHide: false,
      });
    } catch (e) {
      reject(e);
      return;
    }
    state.launchWarning = "";
    let settled = false;
    const finish = (err) => {
      if (settled) return;
      settled = true;
      if (err) {
        reject(err);
        return;
      }
      try {
        child.unref();
      } catch {}
      resolve(true);
    };
    child.once("error", (err) => {
      if (process.platform === "win32" && /eperm/i.test(String((err && err.message) || err || ""))) {
        windowsShellStart(exePath, port).then(() => finish(null)).catch(finish);
        return;
      }
      finish(err);
    });
    child.once("spawn", () => finish(null));
  });
}

// —— 对外：status / connect / disconnect ——
function status() {
  return snapshot();
}
function onStatus(cb) {
  onStatusCb = cb;
}
function onSessionDelete(cb) {
  onSessionDeleteCb = cb;
}

// connect(onStatusCb)：流程见计划。forceRestart=true 时直接重启（前端已确认）。
async function connect(cb, opts = {}) {
  if (cb) onStatusCb = cb;
  const port = opts.port || DEFAULT_PORT;
  state.port = port;
  setPhase("checking", { lastError: "", launchWarning: "", portDiagnostic: "" });
  const exe = scanCodexExecutable();
  // 1. 端口已开？
  const ok = await connectToTarget(port);
  if (ok) return snapshot();
  // 2. 判断 Codex 是否在跑
  const running = codexDesktop.codexRunning();
  if (!running && !opts.forceRestart) {
    // 没在跑也没开端口：直接尝试拉起带端口的实例（无需杀进程）
    if (!exe) {
      setPhase("error", { lastError: desktopNotFoundError(), discovery: state.discovery });
      return snapshot();
    }
    setPhase("restarting", { codexPath: exe });
    try {
      await spawnCodex(exe, port);
    } catch (e) {
      setPhase("error", { lastError: desktopLaunchError(exe, e), discovery: state.discovery });
      return snapshot();
    }
    setPhase("waiting_debug_port", { codexPath: exe, lastError: "" });
    const tgt = await waitForReady(port);
    if (!tgt) {
      setDebugPortFailure("启动", port);
      return snapshot();
    }
    const ok2 = await connectToTarget(port);
    if (!ok2) setPhase("error", { lastError: "已启动但未找到可注入页面" });
    return snapshot();
  }
  // 3. 在跑但没端口：需用户在前端确认后 forceRestart 重启
  if (running && !opts.forceRestart) {
    setPhase("running_no_port", { codexPath: state.codexPath });
    return snapshot(); // 前端据此弹"重启确认"
  }
  // 4. forceRestart：杀进程 → 重启
  if (!exe) {
    setPhase("error", { lastError: desktopNotFoundError(), discovery: state.discovery });
    return snapshot();
  }
  state.codexPath = exe;
  setPhase("restarting");
  await codexDesktop.killCodex();
  try {
    await spawnCodex(exe, port);
  } catch (e) {
    setPhase("error", { lastError: desktopLaunchError(exe, e), discovery: state.discovery });
    return snapshot();
  }
  setPhase("waiting_debug_port", { codexPath: exe, lastError: "" });
  const tgt = await waitForReady(port);
  if (!tgt) {
    setDebugPortFailure("重启", port);
    return snapshot();
  }
  const ok3 = await connectToTarget(port);
  if (!ok3) setPhase("error", { lastError: "已启动但未找到可注入页面" });
  return snapshot();
}

async function disconnect() {
  stopTokenSync();
  closeNetworkSessions();
  if (session) {
    const ownedSession = session;
    // 先让页面停止录音并删除已挂载按钮，再关闭 CDP；关闭后无法清理前台 DOM。
    try {
      await ownedSession.send("Runtime.evaluate", {
        expression: "window.__voiceInjectDispose && window.__voiceInjectDispose()",
        awaitPromise: false,
      });
    } catch {}
    if (voiceScriptIdentifier) {
      try {
        await ownedSession.send("Page.removeScriptToEvaluateOnNewDocument", { identifier: voiceScriptIdentifier });
      } catch {}
      voiceScriptIdentifier = "";
    }
    session = null;
    try {
      ownedSession.close();
    } catch {}
  }
  setPhase("disconnected");
  return snapshot();
}

// 当前语音转写配置（来自路由里勾选 STT 的分组），供前端只读展示。
function sttInfo() {
  const g = router.sttGroup();
  if (!g) return { ready: false, groupName: "", model: "" };
  return {
    ready: true,
    groupName: g.name || "",
    model: g.sttModel || "whisper-1",
    baseUrl: (g.baseUrl || "").replace(/\/+$/, ""),
  };
}

// 诊断：用每个非默认分组的真 key 探测 /v1/audio/transcriptions 是否存在。
// 404 = 路径不存在(不支持STT)；400/401/4xx-body非404/200 = 路径存在(支持，鉴权/参数问题另算)。
async function probeStt() {
  const groups = router.usableGroups ? router.usableGroups() : [];
  const out = [];
  const body = Buffer.from([0x1a, 0x45, 0xdf, 0xa3]); // 假 webm 头，只为触发路径判断
  for (const g of groups) {
    const base = (g.baseUrl || "").replace(/\/+$/, "");
    if (!base || !g.key) { out.push({ name: g.name, baseUrl: base, status: 0, note: "缺地址或密钥" }); continue; }
    try {
      const form = new FormData();
      form.append("file", new Blob([body], { type: "audio/webm" }), "v.webm");
      form.append("model", g.sttModel || "whisper-1");
      const res = await fetch(base + "/v1/audio/transcriptions", {
        method: "POST",
        headers: { Authorization: "Bearer " + g.key },
        body: form,
      });
      const text = await res.text().catch(() => "");
      const notFound = res.status === 404 || /404 page not found|not found/i.test(text.slice(0, 60));
      out.push({
        name: g.name,
        baseUrl: base,
        status: res.status,
        supported: !notFound,
        note: text.slice(0, 120).replace(/\s+/g, " "),
      });
    } catch (e) {
      out.push({ name: g.name, baseUrl: base, status: 0, supported: false, note: String((e && e.message) || e).slice(0, 120) });
    }
  }
  return out;
}

// —— Token 用量读取 / 重置（通过 CDP Runtime.evaluate 调注入脚本的 window API）——
async function tokenStatus() {
  if (!session) return { date: "", total: 0 };
  try {
    const r = await session.send("Runtime.evaluate", {
      expression: "window.__tdTokenGet ? window.__tdTokenGet() : JSON.stringify({date:'',total:0})",
      awaitPromise: false,
    });
    const raw = (r && r.result && r.result.value) || "";
    const parsed = (() => { try { return JSON.parse(raw); } catch { return { date: "", total: 0 }; } })();
    return {
      date: parsed.date || "",
      total: Number(parsed.total) || 0,
      input: Number(parsed.input) || 0,
      output: Number(parsed.output) || 0,
      cached: Number(parsed.cached) || 0,
      estimate: Number(parsed.estimate || parsed.estimated) || 0,
      unknown: Number(parsed.unknown) || 0,
      lastSource: parsed.lastSource || parsed.source || "",
      network: { ...tokenNet },
    };
  } catch {
    return { date: "", total: 0 };
  }
}
async function tokenSet(usage) {
  if (!session) return false;
  try {
    await session.send("Runtime.evaluate", {
      expression: "window.__tdTokenSet && window.__tdTokenSet(" + JSON.stringify(usage || {}) + ")",
      awaitPromise: false,
    });
    return true;
  } catch {
    return false;
  }
}
async function tokenReset() {
  if (!session) return false;
  try {
    await session.send("Runtime.evaluate", {
      expression: "window.__tdTokenReset ? window.__tdTokenReset() : 'no'",
      awaitPromise: false,
    });
    return true;
  } catch {
    return false;
  }
}

module.exports = {
  status,
  connect,
  disconnect,
  onStatus,
  onSessionDelete,
  sttInfo,
  probeStt,
  tokenStatus,
  tokenSet,
  tokenReset,
  // 供临时实测脚本复用
  _listTargets: listTargets,
  _pickTarget: pickTarget,
  _openSession: openSession,
  _inject: inject,
  DEFAULT_PORT,
};