1
function createMainWindow(): BrowserWindow {
2
  const win = new BrowserWindow({
3
    width: 1440,
4
    height: 900,
5
    show: false,                    // 先隐藏，ready-to-show 再显示，避免白屏
6
    backgroundColor: "#0f172a",     // 预置背景色，配合 show:false 双保险
7
    webPreferences: { sandbox: true, spellcheck: false },
8
  });
9
  win.removeMenu();
10
  win.webContents.setUserAgent(CHROME_UA);      // 伪装标准 Chrome，抹掉 Electron 指纹
11
  win.webContents.setWindowOpenHandler(({ url }) => {
12
    if (url.startsWith("http://") || url.startsWith("https://")) {
13
      void shell.openExternal(url);             // 一切 window.open 转交系统浏览器
14
    }
15
    return { action: "deny" };
16
  });
17
  showOnReady(win);
18
  return win;
19
}

1
async function connectElectron(): Promise<Browser> {
2
  const browser = await chromium.connectOverCDP(CDP_ENDPOINT, {
3
    timeout: 30_000,
4
    noDefaults: true,
5
    isLocal: true,
6
  });
7
  try {
8
    const cdp = await browser.newBrowserCDPSession();
9
    const { userAgent } = (await cdp.send("Browser.getVersion")) as { userAgent: string };
10
    await cdp.detach().catch(() => {});
11
    if (!userAgent.includes("Electron")) {
12
      throw new Error(
13
        `CDP 端点不是 FeedMind Electron（实际 UA: ${userAgent}），已拒绝连接以隔离用户主机浏览器`,
14
      );
15
    }
16
  } catch (err) {
17
    await browser.close().catch(() => {});   // 验不过，立刻断开
18
    throw err;
19
  }
20
  return browser;
21
}

1
for (let attempt = 0; attempt < 2; attempt++) {
2
  const browser = await connectElectron();
3
  browser.on("disconnected", resetConnection);       // 断连自愈
4

5
  const pages = browser.contexts()[0]?.pages() ?? [];
6
  const selected = pages.find((p) => p.url().includes(CRAWLER_MARKER));
7
  if (selected) {
8
    selected.on("close", () => {
9
      if (_page === selected) resetConnection();
10
    });
11
    return selected;
12
  }
13

14
  // 第一轮没找到：断开连接 → 请求主进程补建标记窗口 → 等 300ms 再试一轮
15
  await browser.close().catch(() => {});
16
  if (attempt === 0) {
17
    await ensureMarkedWindow(CRAWLER_MARKER);
18
    await new Promise((r) => setTimeout(r, 300));
19
  }
20
}

1
// 任务级串行互斥：promise-chain 锁，多爬取任务排队共享同一页面
2
export async function createBrowser(): Promise<Page> {
3
  const prev = _lockTail;
4
  const { promise, resolve: release } = Promise.withResolvers<void>();
5
  _lockTail = promise;
6
  await prev;
7
  // ...
8
}
9

10
// 爬取提速：拦截并 abort 图片/媒体/字体/样式表
11
await page.route("**/*", (route) => {
12
  const type = route.request().resourceType();
13
  if (["image", "media", "font", "stylesheet"].includes(type)) {
14
    void route.abort();
15
  } else {
16
    void route.continue();
17
  }
18
});

1
// build.mjs —— 主进程构建脚本
2
// 1. 先用 tsc 生成 TypeScript 声明与类型检查
3
execSync("tsc -b", { cwd: desktopDir, stdio: "inherit" });
4

5
// 2. 用 esbuild 把主进程 + 整个 API 服务 bundle 成单文件
6
await build({
7
  entryPoints: [resolve(desktopDir, "src/main.ts")],
8
  outfile: resolve(desktopDir, "dist/main.js"),
9
  bundle: true,
10
  platform: "node",
11
  target: "node22",
12
  format: "esm",
13
  sourcemap: true,
14
  external: [
15
    "electron",
16
    "@libsql/*",
17
    "better-sqlite3",
18
    "playwright-core",
19
    "@remotion/*",
20
    // ...原生模块与带动态 require 的重型库
21
  ],
22
  banner: {
23
    // ESM 模式下注入 require/__filename/__dirname 垫片，保障 CJS 依赖正常加载
24
    js: `import { createRequire as __createRequire } from 'node:module';
25
         const require = __createRequire(import.meta.url); /* ... */`,
26
  },
27
  minify: true,
28
});

1
# electron-builder.yml（节选）
2
asar: true
3
asarUnpack:
4
  # .node 与原生 exe 不能从 asar 内加载，必须解包到磁盘
5
  - "**/better-sqlite3/**/*"
6
  - "**/@libsql/**/*"
7
  - "**/@remotion/compositor-win32-x64-msvc/**/*"
8
files:
9
  - dist/main.js
10
  - package.json
11
  # 只收必需的原生依赖与二进制
12
  - node_modules/@libsql/win32-x64-msvc/**/*
13
  - node_modules/playwright-core/**/*
14
  # 剔除已被 bundle 进 main.js 的纯 JS 重型依赖
15
  - "!node_modules/@mastra/**"
16
  - "!node_modules/@ai-sdk/**"
17
  - "!node_modules/drizzle-orm/**"
18
  - "!node_modules/zod/**"
19
  # 剔除非 win32-x64 平台的无效变体（macOS/Linux/arm64 的二进制全都用不上）
20
  - "!node_modules/**/@rspack/binding-{darwin,linux}-*/**"
21
  - "!node_modules/**/@esbuild/{aix-ppc64,android-*,darwin-*,linux-*}/**"
22
extraResources:
23
  # Web 静态产物 → resources/web-dist，API 同源托管
24
  - from: ../web/dist
25
    to: web-dist

1
// after-pack.mjs —— 打包后裁剪 Chromium 冗余文件
2
export default async function afterPack(context) {
3
  const { appOutDir } = context;
4

5
  // 1. 剔除大型无用文档（19.4MB）
6
  fs.unlinkSync(path.join(appOutDir, "LICENSES.chromium.html"));
7

8
  // 2. 裁剪语言包：50+ 个 .pak 只留中英文（省 ~30MB）
9
  const kept = new Set(["zh-CN.pak", "en-US.pak", "en-GB.pak"]);
10
  for (const item of fs.readdirSync(path.join(appOutDir, "locales"))) {
11
    if (!kept.has(item)) fs.unlinkSync(path.join(appOutDir, "locales", item));
12
  }
13

14
  // 短暂让出 IO 循环，确保 Windows 文件系统句柄稳定释放
15
  await new Promise((resolve) => setTimeout(resolve, 300));
16
}

1
function startMemoryMonitor(): void {
2
  let lastHeap = process.memoryUsage().heapUsed;
3
  let risingStreak = 0;
4
  setInterval(() => {
5
    const { rss, heapUsed } = process.memoryUsage();
6
    risingStreak = heapUsed > lastHeap ? risingStreak + 1 : 0;
7
    lastHeap = heapUsed;
8
    // 每 5 分钟采样：连续 3 次上涨升级为 warn
9
    console.log(JSON.stringify({ event: "memory-sample", rssMB: ..., risingStreak }));
10
    void checkMarkedWindowMemory();
11
  }, MEMORY_SAMPLE_MS);
12
}
13

14
async function checkMarkedWindowMemory(): Promise<void> {
15
  // 用 getAppMetrics 按 PID 定位 Agent 窗口的渲染进程，工作集超 1.5GB 即熔断销毁重建
16
  const metrics = app.getAppMetrics();
17
  const pid = entry.win.webContents.getOSProcessId();
18
  const proc = metrics.find((m) => m.pid === pid);
19
  if (proc && proc.memory.workingSetSize > MARKED_WINDOW_MEMORY_LIMIT_MB * 1024 * 1024) {
20
    await destroyMarkedWindow(AGENT_MARKER);   // 销毁窗口 = 回收整个渲染子进程
21
  }
22
}