${esc(t.failTitle)}
${esc(hint)}
${esc(detail)}
${esc(t.gpuTip1)}"disable_gpu": true${esc(t.gpuTip2)}${esc(CFG)}${esc(t.gpuTip3)}server${esc(t.gpuTip4)}
${esc(t.bootLogForIssue)}${esc(BOOT_LOG || t.logUnwritable)}
${esc(t.versionLabel)} ${esc(require("./package.json").version)} · ${esc(t.openIssue)}
`;
// 连窗口都没有，就退到系统级报错框，别把原因吞掉——「双击没反应」就是这么来的
if (!win || win.isDestroyed()) return fatal("启动", err);
FATAL_SHOWN = true;
win.loadURL("data:text/html;charset=utf-8," + encodeURIComponent(html));
win.show();
win.focus();
}
/**
* 设置页存的键 → Electron 认的加速键写法。两边不是一套词：
* · 设置页（app-02.js 的 SHORTCUT_DEFS / accelFromEvent）：Mod = 这台机器的主修饰键，Meta = ⌘ / Win 键，
* 键名照抄 KeyboardEvent.code 去掉 Key/Digit 前缀（Comma、BracketLeft、ArrowUp、Numpad1……），
* 默认键还可能写成「mac 那份|其他平台那份」；
* · Electron：CommandOrControl / Command / Super / Control，键名是 "," "[" "Up" "num1"。
* 对不上的那个键 register 会直接抛，被 catch 吞掉，用户看到的就是「改了键、按了没反应」。
* 以前这里只换了 Meta→Command、Ctrl→Control：Windows 上 Meta 换成 Command 是个不存在的键，
* 默认键哪天用上 Mod 也会整条注册不上。
*/
function electronAccel(a, mac) {
let s = String(a || "");
if (s.includes("|")) s = s.split("|")[mac ? 0 : 1] || "";
const MOD = { mod: "CommandOrControl", meta: mac ? "Command" : "Super", cmd: "Command", command: "Command", super: "Super",
ctrl: "Control", control: "Control", alt: "Alt", option: "Alt", shift: "Shift", commandorcontrol: "CommandOrControl", cmdorctrl: "CommandOrControl" };
const KEY = { Comma: ",", Period: ".", Slash: "/", Backslash: "\\", Semicolon: ";", Quote: "'", Backquote: "`",
BracketLeft: "[", BracketRight: "]", Minus: "-", Equal: "=", ArrowUp: "Up", ArrowDown: "Down", ArrowLeft: "Left", ArrowRight: "Right",
NumpadAdd: "numadd", NumpadSubtract: "numsub", NumpadMultiply: "nummult", NumpadDivide: "numdiv", NumpadDecimal: "numdec", NumpadEnter: "Enter" };
const out = [];
for (const p of s.split("+").map((x) => x.trim()).filter(Boolean)) {
const m = MOD[p.toLowerCase()];
const k = m || KEY[p] || p.replace(/^Numpad(\d)$/, "num$1");
if (!out.includes(k)) out.push(k);
}
return out.join("+");
}
/** 全局快捷键（系统级，仅「唤起/隐藏主窗口」需要）；设置页改绑后由 server.js 调用热更新 */
function registerShortcuts(shortcuts) {
try {
globalShortcut.unregisterAll();
const accel = electronAccel((shortcuts || {})["toggle-window"] || "Shift+Alt+W", process.platform === "darwin");
const ok = globalShortcut.register(accel, () => {
if (!win) return;
if (win.isVisible() && win.isFocused()) win.hide();
else {
win.show();
win.focus();
}
});
// 返回 false 不抛：这个组合键系统没给。记一笔，不然日志里看不出按了没反应是为什么
if (!ok) bootLog(`▲ 全局快捷键 ${accel} 没注册上，系统没接这个组合键`);
} catch (e) {
console.warn("[快捷键] 全局快捷键注册失败:", e.message);
}
}
// ---------- 退出：先问、再收尾、最后才放行 ----------
const SHUTDOWN_WAIT_MS = 3000; // 叫停任务之后最多等这么久让它们自己收尾，过了就直接杀子进程
const SYS_QUIT_REARM_MS = 60000; // 系统说要关机之后这么久还活着，就当关机被取消了（见 letSystemQuit）
/**
* 以用户本人的身份问服务端一句。服务端就跑在这个进程里，但任务表（server.js 的 activeRuns）
* 是它模块里的局部变量，壳够不着，只能走 HTTP。登录令牌是界面那个 session 上的 HttpOnly cookie，
* 从 cookie 罐里取出来带上。问不到（没登录、服务端没起来、端口上是别的实例、超时）一律回 null：
* 退出这条路不许因为这一问卡住。
*/
async function apiCall(method, pathname, body) {
if (!SERVER_OWN) return null;
try {
const base = `http://127.0.0.1:${PORT}`;
const jar = await session.defaultSession.cookies.get({ url: base });
const headers = {};
const cookie = jar.map((c) => `${c.name}=${c.value}`).join("; ");
if (cookie) headers.cookie = cookie;
if (body) headers["content-type"] = "application/json";
const r = await fetch(base + pathname, {
method, headers, body: body ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(1500),
});
return r.ok ? await r.json() : null;
} catch {
return null;
}
}
/** 正在跑的任务（会话 id）。口径跟页面刷新后接回任务那份一样：只算当前登录的这个人的 */
async function runningTasks() {
const ids = await apiCall("GET", "/api/chat/running");
return Array.isArray(ids) ? ids : [];
}
/**
* `ps -A -ww -o pid=,ppid=,pgid=,args=` 的输出 → 这个进程底下该送走的那些。
* 刨掉 Electron 自己的进程（GPU / 渲染 / 网络，连同它们底下的，得留给 Electron 自己收）：
* · 命令行带 --type= 的——Chromium 的子进程都这么起，这条最准；
* 光靠 keep（getAppMetrics）不够：真 Electron 43 实测刚启动那一阵 GPU 进程还没进 metrics 表；
* · keep 里的，和崩溃上报进程。
* 不能按「跟主进程同一个可执行文件」刨：服务端用 ELECTRON_RUN_AS_NODE 拿 Electron 二进制跑脚本，
* 那些正是要收的。groups 是子孙里自立门户（detached）的进程组组长：按组杀才能把
* 已经过继给 init 的孙子一起带走——模型跑的 `npm run dev` 就是这么脱钩的。
*/
function childTree(psOut, root, keep) {
const rows = [];
for (const line of String(psOut || "").split(/\r?\n/)) { // PowerShell 吐的是 \r\n，行尾那个 \r 会让下面的 $ 对不上
const m = /^\s*(\d+)\s+(\d+)\s+(\d+)\s*(.*)$/.exec(line);
if (m) rows.push({ pid: +m[1], ppid: +m[2], pgid: +m[3], cmd: m[4] });
}
const skip = new Set(keep || []);
const mine = new Set([root]);
for (let grew = true; grew;) {
grew = false;
for (const r of rows) {
if (mine.has(r.pid) || !mine.has(r.ppid) || skip.has(r.pid)) continue;
if (/\s--type=[a-z-]+/.test(r.cmd) || /crashpad/i.test(r.cmd)) continue;
mine.add(r.pid);
grew = true;
}
}
mine.delete(root);
const groups = rows.filter((r) => mine.has(r.pid) && r.pgid === r.pid).map((r) => r.pid);
return { pids: [...mine], groups };
}
/**
* 把还挂在这个进程底下的子进程送走：MCP 服务、叫停时没跟着走的命令、评测、ffmpeg……
* 任务被叫停时各自已经在杀自己那棵树了，这一步收的是漏网的——不收的话应用退了，
* 它们还在后台占着端口和 CPU，下次启动 MCP 还会撞上自己的上一辈。返回送走了几个，只为记日志。
*/
// 独立服务进程（2026-09-29 起默认）自己带 --type=utility，扫主进程这棵树时它连同底下的 MCP、模型起的
// 开发服务器会被整枝刨掉——所以它的 pid 另算一个根（extra），它底下的照样收
function killChildren(sig, extra = typeof serverRoots === "function" ? serverRoots() : []) {
const cp = require("child_process");
const keep = [];
try { for (const m of app.getAppMetrics()) keep.push(m.pid); } catch {}
const roots = [process.pid, ...extra];
try {
if (process.platform === "win32") {
// Windows 没有进程组、也没有 ps：PowerShell 列出直接子进程（带命令行，好认出 --type= 的 Electron 自家进程），
// taskkill /T 连孙子一起带走。不分先礼后兵，一律 /F：走到这一步已经给过它们 3 秒了。
// 退出收尾走的是下面的异步版 killChildrenWin；这里只剩关机、重启应用那两条来不及等的路
const r = cp.spawnSync("powershell.exe", winChildArgs(roots), { encoding: "utf8", timeout: 5000, windowsHide: true });
const pids = winTargets(r.stdout, roots, keep.concat(r.pid || []));
if (pids.length) {
try { cp.spawnSync("taskkill", winKillArgs(pids), { timeout: 5000, windowsHide: true, stdio: "ignore" }); } catch {}
}
return pids.length;
}
// -ww：不截断命令行，--type= 在很长的一串参数后面。不加 windowsHide：Windows 在上面那段就 return 了
const r = cp.spawnSync("ps", ["-A", "-ww", "-o", "pid=,ppid=,pgid=,args="], { encoding: "utf8", timeout: 5000, maxBuffer: 64 * 1024 * 1024 });
let n = 0;
for (const root of roots) {
const { pids, groups } = childTree(r.stdout, root, keep.concat(r.pid || []));
for (const g of groups) { try { process.kill(-g, sig); } catch {} }
for (const p of pids) { try { process.kill(p, sig); } catch {} }
n += pids.length;
}
return n;
} catch (e) {
bootLog("▲ 清子进程出错：" + String((e && e.message) || e));
return 0;
}
}
/** Windows：一次 PowerShell 列出这几个根底下的直接子进程。它冷启动就要一两秒，别每个根起一次 */
function winChildArgs(roots) {
const filter = roots.map((r) => `ParentProcessId=${Number(r)}`).join(" OR ");
return ["-NoProfile", "-NonInteractive", "-Command",
`Get-CimInstance Win32_Process -Filter '${filter}' | ForEach-Object { [string]$_.ProcessId + ' ' + [string]$_.ParentProcessId + ' 0 ' + $_.Name + ' ' + $_.CommandLine }`];
}
/** 上面列出来的 → 各根底下要送走的 pid，合在一起 */
function winTargets(out, roots, keep) {
const all = new Set();
for (const root of roots) for (const p of childTree(out, root, keep).pids) all.add(p);
return [...all];
}
/** 一条 taskkill 带走全部：每个 pid 起一次 taskkill 也是一次进程启动 */
function winKillArgs(pids) {
return ["/T", "/F", ...pids.flatMap((p) => ["/PID", String(p)])];
}
/**
* killChildren 的 Windows 异步版，退出收尾用。同步那版要干等 PowerShell 冷启动，
* 这一两秒主线程卡住，窗口标题栏挂上「未响应」，人以为退出卡死了，再点一下就成了强制结束。
*/
async function killChildrenWin(extra = typeof serverRoots === "function" ? serverRoots() : []) {
const cp = require("child_process");
const keep = [];
try { for (const m of app.getAppMetrics()) keep.push(m.pid); } catch {}
const roots = [process.pid, ...extra];
const run = (bin, args) => new Promise((resolve) => {
/** @type {any} */
let child = null;
try {
child = cp.execFile(bin, args, { encoding: "utf8", timeout: 5000, windowsHide: true, maxBuffer: 16 << 20 },
(_e, out) => resolve({ out: String(out || ""), pid: (child && child.pid) || 0 }));
} catch { resolve({ out: "", pid: 0 }); }
});
try {
const r = await run("powershell.exe", winChildArgs(roots));
const pids = winTargets(r.out, roots, keep.concat(r.pid || []));
if (pids.length) await run("taskkill", winKillArgs(pids));
return pids.length;
} catch (e) {
bootLog("▲ 清子进程出错：" + String((e && e.message) || e));
return 0;
}
}
/**
* 统一的收尾，谁要退都走它，而且只走一遍（第二次来要的拿到的是同一个 Promise）：
* 1. 叫服务端停掉在跑的任务（跟用户点「让我停下」同一条路：/api/chat/stop）；
* 2. 等它们收尾，最多 SHUTDOWN_WAIT_MS；
* 3. 不管等没等完，把还挂着的子进程送走：先 SIGTERM，半秒后还在的 SIGKILL。
* 以前关窗就是 app.quit()：任务停在半截，写到一半的文件、跑到一半的命令都没人收，
* MCP 服务和模型起的开发服务器在后台接着跑，下次打开端口还被自己占着。
*/
function shutdown() {
if (SHUTDOWN) return SHUTDOWN;
SHUTDOWN = (async () => {
const t0 = Date.now();
const onWin = process.platform === "win32";
// Windows 上收尾要几秒（等任务停、PowerShell 列进程），窗口先收起来：点了关闭窗口还杵着，人会再点、会去任务管理器结束
if (onWin && win && !win.isDestroyed()) win.hide();
let gaveUp = false;
const settle = (async () => {
const ids = await runningTasks();
if (!ids.length) return;
bootLog(`退出：叫停 ${ids.length} 个在跑的任务`);
await Promise.all(ids.map((id) => apiCall("POST", "/api/chat/stop", { sessionId: id })));
while (!gaveUp) {
if (!(await runningTasks()).length) return;
await new Promise((r) => setTimeout(r, 150));
}
})().catch(() => {});
let timer = null;
const late = await Promise.race([
settle.then(() => false),
new Promise((r) => { timer = setTimeout(() => r(true), SHUTDOWN_WAIT_MS); }),
]);
clearTimeout(timer);
gaveUp = true;
if (late) bootLog(`▲ 退出：等了 ${SHUTDOWN_WAIT_MS}ms 任务还没收完，不等了`);
// Windows 那版一律 taskkill /F，一遍就够，不补第二遍
const termed = onWin ? await killChildrenWin() : killChildren("SIGTERM");
let killed = 0;
if (termed && !onWin) {
await new Promise((r) => setTimeout(r, 500));
killed = killChildren("SIGKILL"); // 重新列一遍：半秒里走掉的不会再挨一下，pid 被别人复用了也伤不着
}
// 独立服务进程最后才停：先停它的话，它底下没收走的子孙立刻过继给 init，上面那两遍就扫不到了
if (typeof stopServer === "function") await stopServer();
bootLog(`退出收尾完：用时 ${Date.now() - t0}ms，子进程 ${termed} 个${killed ? `（其中 ${killed} 个不肯走，硬杀）` : ""}`);
})().catch((e) => bootLog("▲ 退出收尾出错：" + String((e && e.message) || e)));
return SHUTDOWN;
}
/**
* 所有「要退出」的入口都走这一个：关主窗口、⌘Q / Alt+F4、Dock 右键退出、托盘「退出」。
* 有任务在跑就先问一句——关窗和退出是顺手一点的事，而中断的是跑了半小时的活儿。
* 回车默认是「先不退」：不丢东西的那条。没有任务就不打扰，直接收尾退出。
* 框挂着的时候再点一次关闭 / 再按一次 ⌘Q 不叠第二个框。
*/
async function requestQuit() {
if (QUIT_STATE === "done") return app.quit();
if (QUIT_STATE) return;
QUIT_STATE = "asking";
try {
const n = (await runningTasks()).length;
if (n > 0) {
const t = T(LAST_UI_LANG || osLang());
const w = win && !win.isDestroyed() ? win : null;
if (w) { if (w.isMinimized()) w.restore(); w.show(); } // 框挂在窗口上：窗口收着的话框也跟着看不见
const opts = { type: "warning", title: "OpenWorkBuddy", message: t.quitBusy(n), buttons: [t.quitBtn, t.stayBtn], defaultId: 1, cancelId: 1, noLink: true };
const { response } = await (w ? dialog.showMessageBox(w, opts) : dialog.showMessageBox(opts));
if (response !== 0) {
QUIT_STATE = "";
bootLog(`退出：${n} 个任务在跑，用户选了先不退`);
return;
}
}
QUIT_STATE = "closing";
await shutdown();
} catch (e) {
bootLog("▲ 退出前的确认 / 收尾出错，照样退：" + String((e && e.message) || e));
}
QUIT_STATE = "done";
app.quit();
}
// ⌘Q、Dock 右键退出、系统菜单的退出，都先到这儿。只注册这一次：两个 before-quit 各拦各的，
// 一个放行了另一个还在拦，退出就成了死循环
app.on("before-quit", (e) => {
if (QUIT_STATE === "done") return;
e.preventDefault();
requestQuit();
});
// ---------- 托盘 ----------
/** 托盘菜单就三条：显示窗口 / 新建任务 / 退出。字从 SHELL_TEXT 来 */
function trayMenuItems(t, act) {
return [
{ label: t.trayShow, click: act.show },
{ label: t.trayNewTask, click: act.newTask },
{ type: "separator" },
{ label: t.trayQuit, click: act.quit },
];
}
function showMainWindow() {
if (!win || win.isDestroyed()) return false;
if (win.isMinimized()) win.restore();
win.show();
win.focus();
return true;
}
function refreshTray(lang) {
if (!tray || tray.isDestroyed()) return;
// 语言没变就不动：窗口失焦、鼠标划过托盘都会来问一次，而 Windows 上右键托盘的那一下主窗口正好失焦——
// 菜单开着的时候把它整个换掉，开着的那份点下去可能落空
const lng = (lang || LAST_UI_LANG || osLang()) === "en" ? "en" : "zh";
if (lng === trayLang) return;
const t = T(lng);
tray.setToolTip(t.trayTip);
tray.setContextMenu(Menu.buildFromTemplate(trayMenuItems(t, {
show: showMainWindow,
// 跟页面里 ⌘N 按的是同一颗「新建任务」按钮：新建要清哪些状态由页面说了算，这里不另抄一份
newTask: () => {
if (!showMainWindow()) return;
win.webContents.executeJavaScript('(function(){var b=document.getElementById("new-task");if(b)b.click();})()', true).catch(() => {});
},
quit: () => requestQuit(),
})));
trayLang = lng; // 换成了才记：中途抛了的话下回还会再换
}
/** 托盘菜单的字跟着界面语言走。网页切语言不刷新页面、也不告诉主进程，只能在这几个时候问一句 */
function syncTrayLang() {
if (win && !win.isDestroyed()) uiLang(win.webContents).then(refreshTray, () => {});
}
function createTray() {
if (tray || HIDDEN) return; // 测试宿主不往用户的菜单栏上放图标
try {
// Windows 用多尺寸的 tray.ico（为什么见 trayIconFile）。读不出来就退回下面那两份 PNG，日志里留一句
let ico = null;
if (process.platform === "win32") {
ico = nativeImage.createFromPath(trayIconFile(__dirname, process.platform));
if (ico.isEmpty()) {
bootLog("▲ 托盘的 .ico 读不出来，先用 PNG：" + trayIconFile(__dirname, process.platform));
ico = null;
}
}
if (ico) tray = new Tray(ico);
else {
// 图标用 public/ 那张（装机包里有，build/ 不进包）。给 1x 和 2x 两份，Retina 屏上不糊
const src = nativeImage.createFromPath(path.join(__dirname, "public", "favicon.png"));
const img = nativeImage.createEmpty();
img.addRepresentation({ scaleFactor: 1, buffer: src.resize({ width: 16, height: 16, quality: "best" }).toPNG() });
img.addRepresentation({ scaleFactor: 2, buffer: src.resize({ width: 32, height: 32, quality: "best" }).toPNG() });
tray = new Tray(img);
}
refreshTray();
// Windows / Linux 的习惯是单击托盘图标就把窗口叫出来、右键才出菜单；macOS 单击就是出菜单
if (process.platform !== "darwin") tray.on("click", showMainWindow);
// macOS 上点状态栏图标不会让窗口失焦，鼠标移上去那一下再问一次语言（Linux 没有这个事件，靠窗口焦点那两下）
tray.on("mouse-enter", syncTrayLang);
} catch (e) {
tray = null;
bootLog("▲ 托盘图标没建起来（不影响使用）：" + String((e && e.message) || e));
}
}
app.on("will-quit", () => {
MAIN_STALL.stop();
if (MAIN_PROFILE) MAIN_PROFILE.stop(); // 同一线程上的调试会话是同步回话的：这一行返回时文件已经写好
try { if (SHELL_BRIDGE && SHELL_BRIDGE.pixels) SHELL_BRIDGE.pixels.close(); } catch {} // 缩图的临时目录
// 系统关机那条路不走 shutdown（不拦它），子进程至少发一声 SIGTERM，别留在后台
if (!SHUTDOWN) killChildren("SIGTERM");
if (SUPERVISOR) SUPERVISOR.kill(); // 独立服务进程：收尾那条路已经请它退过了，这里只是兜底
try {
globalShortcut.unregisterAll();
} catch {}
try {
if (global.__openworkbuddyPet) global.__openworkbuddyPet.destroy();
} catch {}
try {
if (tray) tray.destroy(); // Windows 上不收的话，退出后托盘里会留一个鼠标划过才消失的空图标
} catch {}
});
// 点 Dock 图标（macOS）/ 点任务栏图标要能把界面叫回来。
// 没有这一段的时候：窗口一最小化或者按快捷键藏起来，Dock 图标就成了摆设——点它什么都不发生，
// 用户只能去戳桌面宠物才能把主界面调出来，而宠物默认还是关着的，等于彻底找不回来。
// Electron 在 macOS 上不会自己 show 窗口，activate 事件得应用自己接。
app.on("activate", () => {
if (!win || win.isDestroyed()) return; // 窗口还没建出来/已经销毁：启动流程或 closed 分支会管，这里别插手
if (win.isMinimized()) win.restore();
win.show();
win.focus();
});
// 兜底。真正管退出的是主窗口的 close / closed（见上面）——那条不挑窗口数量，
// 宠物开着照样退。这条只在宠物关着（默认就是关着）时顺带触发一次；requestQuit 放行过之后再来就是直接退，重复无害。
// 启动失败页那条路窗口上没挂 close 的闸，关掉它走的是这里：服务端没起来，问不出在跑的任务，直接收尾退出
app.on("window-all-closed", () => requestQuit());
// ---------- 独立服务进程（2026-09-29 起桌面版默认，为什么见 SERVER_PROCESS 那段） ----------
/**
* 起独立服务进程，等它报端口。能用返回 {port, reused}；走不通返回 null，调用方退回在这个进程里 require server.js。
* dialog / shell / clipboard / 离屏渲染窗口这些只有主进程才有的东西，它发消息过来要（bridge-main.js）。
*/
async function startServerProcess() {
let electron = null;
try { electron = require("electron"); } catch {}
if (!electron || !electron.utilityProcess || typeof electron.utilityProcess.fork !== "function") {
bootLog("[服务进程] 这个 Electron 没有 utilityProcess，已改回在主进程里运行");
return null;
}
const shellBridge = SHELL_BRIDGE = require("./src/desktop/bridge-main").createShellBridge({
electron,
getWin: () => win,
pet: () => global.__openworkbuddyPet, // 宠物在服务端起来之后才建
registerShortcuts,
relaunch: relaunchApp,
onApproval: (m) => { if (approvalNudge) approvalNudge(m); },
bootLog,
hidden: HIDDEN,
ops: MAIN_OPS,
// 缩图三件活挪出界面线程（为什么见 thumb-sips.js；谁来做见 pixelsKind）。OWB_MAIN_PIXELS=native 走回主线程 nativeImage，浸泡测试做反向对照用
pixels: (() => {
const pk = pixelsKind(process.platform, process.env);
if (pk === "sips") return require("./src/platform/render/thumb-sips").createSipsPixels();
if (pk === "render") return require("./src/platform/render/browser-render").createRenderPixels({ electron, log: bootLog });
return null;
})(),
});
// 网页截图的 PNG 编码同理（见 htmlshot.js pngOf）：反向对照时一起退回界面线程上的 toPNG
if (process.env.OWB_MAIN_PIXELS === "native") require("./src/platform/render/htmlshot")._internals.setEncoder({ native: true });
const nice = Number(process.env.OWB_SERVER_NICE);
SUPERVISOR = require("./src/desktop/server-supervisor").createServerSupervisor({
fork: (env) => electron.utilityProcess.fork(path.join(__dirname, "server-host.js"), [], {
serviceName: "OpenWorkBuddy Server", stdio: "pipe", cwd: process.cwd(), env,
}),
env: () => {
const alive = !!(win && !win.isDestroyed());
const env = {
...process.env,
OWB_BRIDGE: "1",
// 服务进程里 app.isPackaged 问不到，数据根却要靠它定（paths.js）；server-host.js 会拿 OWB_DATA_DIR 对一遍账
OWB_PACKAGED: app.isPackaged ? "1" : "0",
OWB_DATA_DIR: dataPath(),
OWB_USER_DATA: app.getPath("userData"),
// 服务进程的 process.execPath 是 Electron Helper：拉「当 node 用」的子进程得用主程序（electron-bridge.nodeExec）
OWB_NODE_EXEC: process.execPath,
OWB_SHELL_PID: String(process.pid),
OWB_BRIDGE_STATE: JSON.stringify({
caps: { windows: true, pet: !HIDDEN },
winAlive: alive,
fullScreen: alive && win.isFullScreen(),
}),
};
// 带上它 server.js 会把自己当成 run_node 派生的子进程，不认「个人桌面版」
delete env.ELECTRON_RUN_AS_NODE;
return env;
},
shell: shellBridge,
log: bootLog,
readyMs: Number(process.env.OWB_SERVER_READY_MS) || undefined,
nice: Number.isFinite(nice) && nice > 0 ? nice : 5,
onPort: (p, reused) => {
SERVER_OWN = !reused;
SERVER_REMOTE = !reused;
if (p === PORT) return;
bootLog(`[服务进程] 重启后端口换了：${PORT} → ${p}`);
PORT = p;
if (win && !win.isDestroyed()) win.loadURL(`http://127.0.0.1:${PORT}`);
},
onFallback: (why) => fallBackInproc(why),
});
const r = await SUPERVISOR.start();
if (!r) { SUPERVISOR = null; return null; }
SERVER_REMOTE = !r.reused;
if (SERVER_REMOTE) bootLog(`[服务进程] 服务端在独立进程里（pid ${SUPERVISOR.pid()}），主进程只管窗口`);
return r;
}
/**
* 独立服务进程跑起来之后 5 分钟内又崩满 3 次：不再折腾它，在这个进程里接着跑（钉在原来那个口上，窗口不用换地址）。
* 这一路跟启动时退回是同一个结果，只是晚一点——用户手上的是一个还能用的应用，不是一个连不上的窗口。
*/
function fallBackInproc(why) {
SUPERVISOR = null;
SERVER_REMOTE = false;
if (QUIT_STATE) return; // 正在退：不用再起
bootLog(`[服务进程] 改在主进程里接着跑（${why}）`);
process.env.PORT = String(PORT);
global.__wbOnListen = (p) => {
if (p === PORT) return;
bootLog(`端口换了：${PORT} → ${p}（原来那个被别的程序占着）`);
PORT = p;
if (win && !win.isDestroyed()) win.loadURL(`http://127.0.0.1:${PORT}`);
};
if (approvalNudge) { try { require(path.join(__dirname, "src", "core", "safety", "security.js")).watchApprovals(approvalNudge); } catch {} }
try {
require("./server.js");
} catch (e) {
console.error("[启动] 服务端起不来:", e);
showBootFailure(e);
}
}
/** 窗口在不在、是不是全屏：推给独立服务进程（它那边的 global.__wbWin 就靠这一份） */
function pushServerState(patch) {
if (SUPERVISOR) SUPERVISOR.post({ t: "state", patch });
}
/** killChildren 要多扫的根 */
function serverRoots() {
return SUPERVISOR ? SUPERVISOR.roots() : [];
}
/** 退出收尾的最后一步：请独立服务进程自己收尾（停 MCP），等不到就杀 */
async function stopServer() {
if (SUPERVISOR) await SUPERVISOR.stop();
}
/** 数据恢复之后的「重启应用」（server.js /api/backup/restart 从服务进程发过来） */
function relaunchApp() {
if (HIDDEN) return bootLog("[隐藏运行] 收到重启请求，测试宿主不重启");
bootLog("重启应用（数据恢复之后）");
try { killChildren("SIGTERM"); } catch {}
if (SUPERVISOR) SUPERVISOR.kill();
app.relaunch();
app.exit(0);
}
/**
* 测试宿主的遥控（只在 OWB_SHELL_HIDDEN=1 时接）：stdin 一行一个命令。
* lag 那一份是主进程事件循环的迟到量——CF-2 要证明的就是这个数：服务端挪走以后，对话跑得再多它也不该涨。
*/
if (HIDDEN) {
const step = 10;
// 量迟到用单调钟，另拿墙钟对一下：2026-09-29 浸泡测试里那个 2000ms 是合盖睡了 181 秒（Date.now 睡着也走），
// 不是主线程卡住。两个钟差出一秒以上 = 这一拍跨过了睡眠，记进 slept、不算迟到——测试据此判这一轮作废
const mono = () => require("perf_hooks").performance.now();
let samples = [], max = 0, last = mono(), lastWall = Date.now(), slept = 0;
const tick = setInterval(() => {
const now = mono(), wallNow = Date.now();
const gap = now - last, wallGap = wallNow - lastWall;
last = now; lastWall = wallNow;
if (wallGap - gap > 1000) { slept++; return; }
const d = Math.max(0, Math.round(gap - step));
samples.push(d);
if (d > max) max = d;
if (samples.length > 200000) samples = samples.slice(-100000);
}, step);
if (tick.unref) tick.unref();
const lag = () => {
const s = samples.slice().sort((a, b) => a - b);
const q = (p) => (s.length ? s[Math.min(s.length - 1, Math.floor(p * s.length))] : 0);
return { n: s.length, p50: q(0.5), p99: q(0.99), max, slept };
};
let buf = "";
try {
process.stdin.setEncoding("utf8");
process.stdin.on("data", (d) => {
buf += d;
for (let i = buf.indexOf("\n"); i >= 0; i = buf.indexOf("\n")) {
const cmd = buf.slice(0, i).trim();
buf = buf.slice(i + 1);
if (cmd === "quit") requestQuit();
else if (cmd === "lag-reset") { samples = []; max = 0; slept = 0; last = mono(); lastWall = Date.now(); }
else if (cmd === "status") {
console.log("OWB_CTL " + JSON.stringify({
lag: lag(), remote: SERVER_REMOTE, port: PORT, pageUp: PAGE_UP,
serverPid: SUPERVISOR ? SUPERVISOR.pid() : 0, starts: SUPERVISOR ? SUPERVISOR.starts : 0,
bridge: SHELL_BRIDGE ? { ...SHELL_BRIDGE.counts } : null,
stall: { ...MAIN_STALL.counts, max: MAIN_STALL.maxMs, last: MAIN_STALL.stalls.slice(-5) },
ops: MAIN_OPS.stats(),
pixels: SHELL_BRIDGE && SHELL_BRIDGE.pixels ? { ...SHELL_BRIDGE.pixels.counts } : null,
shot: (() => { try { return { ...require("./src/platform/render/htmlshot")._internals.state().stats }; } catch { return null; } })(),
}));
}
else if (cmd === "profile-stop" && MAIN_PROFILE) {
MAIN_PROFILE.stop().then((f) => console.log("OWB_CTL " + JSON.stringify({ profile: f })));
}
}
});
// 跑测试的那个进程没了：别留一个谁也看不见、谁也不管的应用在后台。
// OWB_SHELL_STDIN=0 是 Windows 包冒烟（scripts/win-smoke.js）用的：免安装版外面套着一层解压壳，
// 壳拉起真应用时不把 stdin 传下去，真应用一读就是「已经结束」，没等窗口出来就自己退了
if (process.env.OWB_SHELL_STDIN !== "0") process.stdin.on("end", () => requestQuit());
} catch {}
}