mac
988 lines
33 KiB
JavaScript
988 lines
33 KiB
JavaScript
// voice_cdp.js —— Codex 语音输入注入：主进程侧。
|
||
// 用 CDP（Chrome DevTools Protocol）连接带 --remote-debugging-port 的 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 { spawn, execFile } = require("child_process");
|
||
const os = require("os");
|
||
const path = require("path");
|
||
const net = require("net");
|
||
const crypto = require("crypto");
|
||
|
||
function dlog(...a) { try { console.log("[voice]", ...a); } catch {} }
|
||
const router = require("./router");
|
||
const providerSync = require("./provider_sync");
|
||
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 = 20000; // 轮询就绪最长等待
|
||
const RECORD_MAX_MS = 60000; // 单次录音上限（注入脚本侧也限）
|
||
|
||
// —— 状态机 ——
|
||
// unknown / checking / not_running / running_no_port / restarting / connecting /
|
||
// injecting / connected / disconnected / error
|
||
let state = {
|
||
phase: "unknown",
|
||
port: DEFAULT_PORT,
|
||
codexPath: "",
|
||
lastError: "",
|
||
target: null, // { id, url, title }
|
||
};
|
||
let session = null; // 当前 CdpSession
|
||
let networkSessions = []; // worker 等附加 target 的 Network 监听 session
|
||
let networkAttachGeneration = 0;
|
||
let onStatusCb = null;
|
||
let tokenSyncTimer = null;
|
||
|
||
function snapshot() {
|
||
const { phase, port, codexPath, lastError, model, target } = state;
|
||
return { phase, port, codexPath, lastError, model, target };
|
||
}
|
||
function setPhase(phase, extra = {}) {
|
||
state = { ...state, phase, ...extra };
|
||
if (onStatusCb) {
|
||
try {
|
||
onStatusCb(snapshot());
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
async function syncTokenUsage() {
|
||
if (!session) return;
|
||
const usage = 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 codexExecutable() {
|
||
const home = os.homedir();
|
||
if (process.platform === "darwin") {
|
||
const cands = [
|
||
path.join(home, "Applications/ChatGPT.app/Contents/MacOS/ChatGPT"),
|
||
"/Applications/ChatGPT.app/Contents/MacOS/ChatGPT",
|
||
"/Applications/Codex.app/Contents/MacOS/Codex",
|
||
];
|
||
for (const p of cands) {
|
||
try {
|
||
if (require("fs").existsSync(p)) return p;
|
||
} catch {}
|
||
}
|
||
return "";
|
||
}
|
||
if (process.platform === "win32") {
|
||
const local = process.env.LOCALAPPDATA || "";
|
||
const pf = process.env["ProgramFiles"] || "C:\\Program Files";
|
||
const cands = [
|
||
local && path.join(local, "Programs\\ChatGPT\\ChatGPT.exe"),
|
||
path.join(pf, "ChatGPT\\ChatGPT.exe"),
|
||
].filter(Boolean);
|
||
for (const p of cands) {
|
||
try {
|
||
if (require("fs").existsSync(p)) return p;
|
||
} catch {}
|
||
}
|
||
return "";
|
||
}
|
||
return "";
|
||
}
|
||
|
||
// —— 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 || 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) {
|
||
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");
|
||
// 语音注入脚本
|
||
await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: INJECT_SCRIPT });
|
||
await sessionObj.send("Runtime.evaluate", { expression: INJECT_SCRIPT, awaitPromise: false });
|
||
// Token 用量 UI 注入脚本（只负责 UI + localStorage，不管网络抓取）
|
||
await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: TOKEN_INJECT_SCRIPT });
|
||
await sessionObj.send("Runtime.evaluate", { expression: TOKEN_INJECT_SCRIPT, 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");
|
||
session = await openSession(tgt.webSocketDebuggerUrl, handleBinding);
|
||
session.on("Runtime.bindingCalled", handleBinding);
|
||
// Token 用量：Network 层拦截 LLM 响应
|
||
bindNetworkHandlers(session);
|
||
session.ws.on("close", () => {
|
||
stopTokenSync();
|
||
closeNetworkSessions();
|
||
session = null;
|
||
setPhase("disconnected");
|
||
});
|
||
setPhase("injecting");
|
||
await inject(session);
|
||
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();
|
||
while (Date.now() - t0 < READY_POLL_MAX_MS) {
|
||
const targets = await listTargets(port);
|
||
const tgt = pickTarget(targets);
|
||
if (tgt) return tgt;
|
||
await new Promise((r) => setTimeout(r, READY_POLL_INTERVAL));
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// —— 启动接管：杀当前 Codex → 带端口重启 ——
|
||
function killCodex() {
|
||
return new Promise((resolve) => {
|
||
if (process.platform === "darwin") {
|
||
execFile("osascript", ["-e", 'tell application "ChatGPT" to quit'], () => {
|
||
// 兜底：osascript 没杀掉就 pkill
|
||
execFile("pgrep", ["-f", "ChatGPT.app/Contents/MacOS/ChatGPT"], (_e, out) => {
|
||
if (out && out.trim()) {
|
||
execFile("pkill", ["-f", "ChatGPT.app/Contents/MacOS/ChatGPT"], () =>
|
||
setTimeout(resolve, 800)
|
||
);
|
||
} else resolve();
|
||
});
|
||
});
|
||
} else if (process.platform === "win32") {
|
||
execFile("taskkill", ["/IM", "ChatGPT.exe", "/F"], () =>
|
||
setTimeout(resolve, 800)
|
||
);
|
||
} else resolve();
|
||
});
|
||
}
|
||
function spawnCodex(exePath, port) {
|
||
const child = spawn(exePath, [`--remote-debugging-port=${port}`], {
|
||
detached: true,
|
||
stdio: "ignore",
|
||
});
|
||
try {
|
||
child.unref();
|
||
} catch {}
|
||
}
|
||
|
||
// —— 对外：status / connect / disconnect ——
|
||
function status() {
|
||
return snapshot();
|
||
}
|
||
function onStatus(cb) {
|
||
onStatusCb = 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");
|
||
// 1. 端口已开？
|
||
const ok = await connectToTarget(port);
|
||
if (ok) return snapshot();
|
||
// 2. 判断 Codex 是否在跑
|
||
const running = providerSync.codexRunning ? providerSync.codexRunning() : false;
|
||
if (!running && !opts.forceRestart) {
|
||
// 没在跑也没开端口：直接尝试拉起带端口的实例（无需杀进程）
|
||
const exe = codexExecutable();
|
||
if (!exe) {
|
||
setPhase("error", { lastError: "未找到 Codex 可执行文件" });
|
||
return snapshot();
|
||
}
|
||
state.codexPath = exe;
|
||
setPhase("restarting", { codexPath: exe });
|
||
spawnCodex(exe, port);
|
||
const tgt = await waitForReady(port);
|
||
if (!tgt) {
|
||
setPhase("error", { lastError: "Codex 启动后未开放调试端口，请重试" });
|
||
return snapshot();
|
||
}
|
||
const ok2 = await connectToTarget(port);
|
||
if (!ok2) setPhase("error", { lastError: "已启动但未找到可注入页面" });
|
||
return snapshot();
|
||
}
|
||
// 3. 在跑但没端口：需用户在前端确认后 forceRestart 重启
|
||
if (running && !opts.forceRestart) {
|
||
state.codexPath = codexExecutable();
|
||
setPhase("running_no_port", { codexPath: state.codexPath });
|
||
return snapshot(); // 前端据此弹"重启确认"
|
||
}
|
||
// 4. forceRestart：杀进程 → 重启
|
||
const exe = codexExecutable();
|
||
if (!exe) {
|
||
setPhase("error", { lastError: "未找到 Codex 可执行文件" });
|
||
return snapshot();
|
||
}
|
||
state.codexPath = exe;
|
||
setPhase("restarting");
|
||
await killCodex();
|
||
spawnCodex(exe, port);
|
||
const tgt = await waitForReady(port);
|
||
if (!tgt) {
|
||
setPhase("error", { lastError: "重启 Codex 后未开放调试端口" });
|
||
return snapshot();
|
||
}
|
||
const ok3 = await connectToTarget(port);
|
||
if (!ok3) setPhase("error", { lastError: "已启动但未找到可注入页面" });
|
||
return snapshot();
|
||
}
|
||
|
||
function disconnect() {
|
||
stopTokenSync();
|
||
closeNetworkSessions();
|
||
if (session) {
|
||
try {
|
||
session.close();
|
||
} catch {}
|
||
session = null;
|
||
}
|
||
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,
|
||
sttInfo,
|
||
probeStt,
|
||
tokenStatus,
|
||
tokenSet,
|
||
tokenReset,
|
||
// 供临时实测脚本复用
|
||
_listTargets: listTargets,
|
||
_pickTarget: pickTarget,
|
||
_openSession: openSession,
|
||
_inject: inject,
|
||
DEFAULT_PORT,
|
||
};
|