agent-hub-runner 0.1.3 → 0.2.0

package/README.md

@@ -1,3 +1,4 @@
+<!-- @意图#R729(2026-11-04): 加 browser install / status 和「bot 的浏览器」一节（0.2.0） -->
 <!-- @意图#R690(2026-11-01): 加「改动记录」一节：存在哪、打码、64 KB、30 天、怎么删 -->
 <!-- @意图#R666(2026-10-29): 改成不用全局安装的 npx 一条命令（码@地址）、Mac 开机自启、stop / uninstall、常见报错 -->
 <!-- @意图#R664(2026-10-29): npm 包 agent-hub-runner 的说明（随包发布）：给客户看的安装、配对、再连、查看、断开、卸载和安全提示 -->
@@ -48,6 +49,8 @@ npx -y agent-hub-runner@latest autostart off   # 关掉开机自启
 npx -y agent-hub-runner@latest autostart status
 npx -y agent-hub-runner@latest stop            # 停掉在跑的运行器（开机自启的下次开机还会起）
 npx -y agent-hub-runner@latest uninstall       # 关掉开机自启、删掉复制的程序；会问要不要删配置
+npx -y agent-hub-runner@latest browser install # 给 bot 装它自己的浏览器（0.2.0 起，约 200MB，只要一次）
+npx -y agent-hub-runner@latest browser status  # 看浏览器装没装
 ```
 
 开机自启时，程序复制到 `~/.agent-runner/bin/<版本>/`，日志在 `~/.agent-runner/logs/runner.log`（超过 5MB 自动清空）。网页上提示「有新版本」时，按提示运行那一条升级命令。
@@ -80,7 +83,16 @@ npx -y agent-hub-runner@latest uninstall       # 关掉开机自启、删掉复
 - 存之前会把像密钥的字符串换成 `***`（`sk-…`、`ghp_…`、连接串里的密码、私钥、`XXX_KEY=…` 这类赋值）；每条最多 64 KB；只留 30 天，过期自动删。电脑不在线时网页上看不到。
 - 不想留：直接删掉 `edits/` 文件夹，不影响别的。
 
+## bot 的浏览器（0.2.0 起）
+
+- bot 能在你电脑上用一只**它自己的浏览器**（独立的 Chromium，不碰你平时用的浏览器）。先运行一次 `npx -y agent-hub-runner@latest browser install`：装到 `~/.agent-runner/browser/`（playwright-core）和 `~/.agent-runner/browsers/`（Chromium）。先走官方源，下不动会自动换国内镜像（npmmirror）。装好不用重启运行器。
+- 每个 bot 一个资料目录 `~/.agent-runner/browser-profiles/<bot>/`，登录状态会保存。平时在后台（没有窗口）跑，闲 10 分钟自动关。
+- 要登录、扫码、过验证码：在网页「我的电脑」抽屉里点「打开 bot 的浏览器」，会弹出这个 bot 的浏览器窗口，你弄好后直接关掉窗口，bot 接着在后台用。
+- 不想让 bot 用浏览器：网页右栏「bot设置」里取消勾「允许用浏览器」。想清掉登录状态：删掉那个 bot 的资料目录。
+- 卸载：删掉 `~/.agent-runner/browser`、`~/.agent-runner/browsers`、`~/.agent-runner/browser-profiles` 三个文件夹。
+
 ## 安全提示
 
 - 别把放着密钥、令牌的文件夹授权出去：bot 在授权文件夹里读、写、改文件不用你批准。
 - 跑命令前网页上会弹批准卡片，看清命令再点「允许一次」；命令本身能碰到文件夹以外的东西（没有沙箱）。
+- bot 用浏览器不弹批准卡片，能打开任何网址；在 bot 的浏览器里登录过的网站，bot 都能以你的身份操作。别在里面登录你不想让 bot 碰的账号（网银、支付等）。

package/autostart.mjs

@@ -10,6 +10,7 @@
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, truncateSync, writeFileSync } from "node:fs";
+// @意图#R725(2026-11-03): Windows 开机自启用计划任务（schtasks）。和 Mac 一样：登录时拉起、崩溃了重新跑、正常退出不拉起。
 import os from "node:os";
 import path from "node:path";
 
@@ -17,11 +18,14 @@ export const LABEL = "com.agenthub.runner";
 export const LOG_MAX_BYTES = 5 * 1024 * 1024;
 export const THROTTLE_S = 10;
 /** 复制到 ~/.agent-runner/bin/<版本>/ 的文件（package.json 用来读版本号） */
+// @意图#R729(2026-11-04): 多复制 browser.mjs（runner.mjs 要 import 它）
 // @意图#R690(2026-11-01): 多复制 changes.mjs（runner.mjs 要 import 它，少了开机自启的副本起不来）
-export const COPY_FILES = ["runner.mjs", "ops.mjs", "edit.mjs", "changes.mjs", "autostart.mjs", "package.json"];
+export const COPY_FILES = ["runner.mjs", "ops.mjs", "edit.mjs", "changes.mjs", "browser.mjs", "autostart.mjs", "package.json"];
 /** 优先用的稳定 node 路径（Homebrew 升级 node 后这两个软链还在；nvm 的带版本号路径卸了就没了） */
 export const STABLE_NODES = ["/opt/homebrew/bin/node", "/usr/local/bin/node"];
-export const ONLY_MAC = "开机自启目前只支持 Mac";
+export const ONLY_MAC = "开机自启目前只支持 Mac 和 Windows";
+// @意图#R725(2026-11-03): Windows 计划任务名前缀。默认配置是 AgentHubRunner，别的配置加路径 sha256 前 8 位，一份配置一个任务。
+export const TASK_PREFIX = "AgentHubRunner";
 
 const real = (p) => { try { return realpathSync(p); } catch { return path.resolve(p); } };
 
@@ -87,8 +91,10 @@ ${envXml}
 `;
 }
 
-/** 把运行器复制到 <home>/bin/<版本>/，current 软链指过去（先建临时链再改名，换的那一下不会断）。返回 current/runner.mjs 的路径。 */
-export function installCopy({ srcDir, version, env = process.env }) {
+// @意图#R725(2026-11-03): Windows 建软链要管理员权限（或开开发者模式），小白没有。所以 Windows 用一个 current.txt 记当前版本号，
+// 包装脚本读它来找要跑的 runner.mjs。Mac 仍用 current 软链（先建临时链再改名，换的那一下不会断）。
+/** 把运行器复制到 <home>/bin/<版本>/。返回要跑的 runner.mjs 路径。 */
+export function installCopy({ srcDir, version, env = process.env, platform = process.platform }) {
   const binRoot = path.join(runnerHome(env), "bin");
   const dest = path.join(binRoot, version);
   mkdirSync(dest, { recursive: true, mode: 0o700 });
@@ -98,6 +104,10 @@ export function installCopy({ srcDir, version, env = process.env }) {
       if (existsSync(from)) copyFileSync(from, path.join(dest, f));
     }
   }
+  if (platform === "win32") {
+    writeFileSync(path.join(binRoot, "current.txt"), version);
+    return path.join(dest, "runner.mjs");
+  }
   const cur = path.join(binRoot, "current");
   const tmp = path.join(binRoot, `.current-${process.pid}`);
   rmSync(tmp, { force: true });
@@ -179,6 +189,106 @@ export function otherAutostarts(configFile, env = process.env) {
   try { return readdirSync(launchAgentsDir(env)).filter((f) => f.startsWith(LABEL) && f.endsWith(".plist") && f !== mine); } catch { return []; }
 }
 
+// @意图#R725(2026-11-03): Windows 开机自启用计划任务，语义对齐 Mac 的 launchd：
+// - 触发器是「登录时」（/sc onlogon），跑在用户自己的桌面会话里。不能用 SYSTEM 或开机即跑（那样在 Session 0，选目录的窗口弹不出来）。
+// - 退出码不是 0 时重新跑（RestartCount 999、间隔 1 分钟），对齐 KeepAlive 的 SuccessfulExit=false：被网页断开、令牌失效、被顶掉都是 0 退出，不会被反复拉起；崩溃了才会重跑。
+// - 不设 /rl highest：普通权限就够，而且提权会弹 UAC，小白配不上。
+// - 任务跑一个 .cmd：计划任务的 /tr 不支持带空格的参数和重定向，node 装在 Program Files 里，所以包一层。日志追加到和 Mac 同一个文件。
+const psQuote = (s) => `'${String(s).replace(/'/g, "''")}'`;
+
+/** 计划任务名：默认配置 AgentHubRunner，别的配置加 sha8 后缀（对齐 labelFor） */
+export const taskNameFor = (configFile, env = process.env) => { const t = configTag(configFile, env); return t ? `${TASK_PREFIX}-${t}` : TASK_PREFIX; };
+
+/** 计划任务跑的包装脚本：<home>/bin/start-<任务名>.cmd，日志追加到 logFileFor 那个文件 */
+export function taskCmdFor(configFile, env = process.env) {
+  return path.join(runnerHome(env), "bin", `start-${taskNameFor(configFile, env)}.cmd`);
+}
+
+// @意图#R725(2026-11-03): 不靠计划任务的「失败重拉」。实测 schtasks 的 RestartOnFailure 在被 taskkill 强杀时不重拉
+// （任务记的结果是 1，但不再起）。所以在包装脚本里自己循环：退出码不是 0 就等 10 秒再跑，对齐 Mac 的
+// KeepAlive SuccessfulExit=false。正常退出（被网页断开、令牌失效、Ctrl-C，都是 0）不重跑。
+// 脚本路径不写死：从 current.txt 读当前版本号再拼（升级后不用改这个包装脚本）。binDir 是 <home>/bin。
+/** 生成包装脚本的内容。node 是绝对路径，配置路径经环境变量传（和 Mac 的 plist 一样）。 */
+export function taskCmdText({ node, binDir, configFile, log }) {
+  return [
+    "@echo off",
+    "setlocal EnableDelayedExpansion",
+    `set AGENT_RUNNER_CONFIG=${configFile}`,
+    "set AGENT_RUNNER_LAUNCHD=1",
+    ":loop",
+    "set /p VER=<\"" + binDir + "\\current.txt\"",
+    "\"" + node + "\" \"" + binDir + "\\!VER!\\runner.mjs\" start >> \"" + log + "\" 2>&1",
+    "if %ERRORLEVEL%==0 goto end",
+    "timeout /t 10 /nobreak > nul",
+    "goto loop",
+    ":end",
+    "",
+  ].join("\r\n");
+}
+
+/** 调 schtasks，返回 { code, stdout, stderr }，不抛错。AGENT_RUNNER_SCHTASKS 可换成假程序（测试用）。输出是 GBK，转成 UTF-8。 */
+export function runSchtasks(args, env = process.env) {
+  return new Promise((resolve) => {
+    execFile(env.AGENT_RUNNER_SCHTASKS || "schtasks", args, { encoding: "buffer" }, (err, stdout, stderr) => {
+      const dec = (b) => { try { return new TextDecoder("gbk").decode(b); } catch { return String(b ?? ""); } };
+      resolve({ code: err ? (typeof err.code === "number" ? err.code : 1) : 0, stdout: dec(stdout), stderr: dec(stderr) });
+    });
+  });
+}
+
+/** 开启开机自启（Windows）：复制自己、写包装脚本、建计划任务（登录时跑，失败重跑），马上起一次。返回 { task, cmd, node, log }。 */
+export async function autostartOnWindows({ configFile, version, srcDir, execPath = process.execPath, env = process.env, schtasks }) {
+  schtasks ??= (a) => runSchtasks(a, env);
+  const cfg = path.resolve(configFile);
+  if (!existsSync(cfg)) throw new Error(`还没配对：没有 ${cfg}，配对成功后才能设开机自启`);
+  const script = installCopy({ srcDir, version, env, platform: "win32" });
+  const node = pickNode(execPath);
+  const log = logFileFor(cfg, env);
+  mkdirSync(path.dirname(log), { recursive: true });
+  const cmd = taskCmdFor(cfg, env);
+  writeFileSync(cmd, taskCmdText({ node, binDir: path.join(runnerHome(env), "bin"), configFile: cfg, log }));
+  const name = taskNameFor(cfg, env);
+  const user = env.USERNAME;
+  if (!user) throw new Error("开机自启没设成：读不到当前用户名");
+  const args = ["/create", "/tn", name, "/tr", cmd, "/sc", "onlogon", "/ru", user, "/rl", "limited", "/f"];
+  const r = await schtasks(args);
+  if (r.code !== 0) throw new Error(`开机自启没设成：计划任务创建失败（${(r.stderr || r.stdout).trim() || r.code}）`);
+  // 崩溃重跑由包装脚本自己的循环做（见 taskCmdText）。这里只补「用电池也跑」，笔记本合盖不中断。
+  const ps = `$s = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Seconds 0); Set-ScheduledTask -TaskName ${psQuote(name)} -Settings $s | Out-Null`;
+  await new Promise((resolve) => execFile("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], () => resolve()));
+  await schtasks(["/run", "/tn", name]); // 马上起一次，不用等下次登录
+  return { task: name, cmd, node, log };
+}
+
+/** 关掉开机自启（Windows）：停掉并删计划任务、删包装脚本。返回 { wasOn }。 */
+export async function autostartOffWindows({ configFile, env = process.env, schtasks }) {
+  schtasks ??= (a) => runSchtasks(a, env);
+  const cfg = path.resolve(configFile);
+  const name = taskNameFor(cfg, env);
+  const cmd = taskCmdFor(cfg, env);
+  const wasOn = existsSync(cmd);
+  await schtasks(["/end", "/tn", name]);
+  await schtasks(["/delete", "/tn", name, "/f"]);
+  rmSync(cmd, { force: true });
+  return { wasOn };
+}
+
+/** 开机自启现在的样子（Windows）：有没有包装脚本、任务在不在、状态。 */
+export async function autostartStatusWindows({ configFile, env = process.env, schtasks }) {
+  schtasks ??= (a) => runSchtasks(a, env);
+  const cfg = path.resolve(configFile);
+  const name = taskNameFor(cfg, env);
+  const cmd = taskCmdFor(cfg, env);
+  const out = { supported: true, installed: existsSync(cmd), loaded: false, pid: null, task: name, cmd, log: logFileFor(cfg, env), problems: [] };
+  const r = await schtasks(["/query", "/tn", name, "/fo", "csv"]);
+  if (r.code === 0) {
+    out.loaded = true;
+    const row = r.stdout.split(/\r?\n/).find((l) => l.includes(name));
+    if (row && /running/i.test(row)) out.pid = 0; // 计划任务查不到进程号，0 表示在跑但不知道是哪个
+  }
+  return out;
+}
+
 /** 日志超过 max 字节就清空（launchd 用追加方式打开，清空后接着往后写不会乱）。清了返回 true。 */
 export function truncateLogIfBig(file, max = LOG_MAX_BYTES) {
   try {

package/browser.mjs

@@ -0,0 +1,430 @@
+// @意图#R729(2026-11-04): bot 专属浏览器（king 同意 R729，方案里最初记作 R726）。每个 bot 在用户电脑上有一只自己的 Chromium，
+// 和用户平时用的 Chrome 完全分开；登录状态按 bot 存在 ~/.agent-runner/browser-profiles/<botId>/，多个 bot 能同时各用各的。
+// 运行器本身仍然零依赖（king 定乙）：playwright-core 和 Chromium 只在用户运行 `agent-hub-runner browser install` 时才装进
+// ~/.agent-runner/browser/ 和 ~/.agent-runner/browsers/，用到时按绝对路径动态加载；没装、版本不对都回大白话。
+// bot 操作时默认后台跑（不显示窗口）；网页上点「打开 bot 的浏览器」时换成有窗口的，bot 和用户共用这个窗口；用户关掉窗口后 bot 下次操作回到后台。
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { runnerHome } from "./autostart.mjs";
+
+/** 装哪个版本的 playwright-core（钉死；换版本要一起改这里、测试和文档） */
+export const PW_VERSION = "1.64.1";
+/** 官方源失败后换的国内镜像 */
+export const MIRROR_REGISTRY = "https://registry.npmmirror.com";
+export const MIRROR_DOWNLOAD_HOST = "https://cdn.npmmirror.com/binaries/playwright";
+/** 官方源下载 Chromium 最多等多久，超过就当失败换镜像（官方源在国内常常很慢） */
+export const OFFICIAL_TIMEOUT_MS = 10 * 60_000;
+/** 后台（无窗口）浏览器多久没人用就关掉 */
+export const IDLE_CLOSE_MS = 10 * 60_000;
+/** 元素清单最多列多少个、页面文字最多带多少字 */
+export const MAX_ELEMENTS = 150;
+export const MAX_PAGE_TEXT = 2000;
+/** 后台模式的页面大小（截图就是这么大） */
+export const HEADLESS_VIEWPORT = { width: 1280, height: 800 };
+
+export const browserPkgDir = (env = process.env) => path.join(runnerHome(env), "browser");
+export const browsersDir = (env = process.env) => path.join(runnerHome(env), "browsers");
+export const profilesDir = (env = process.env) => path.join(runnerHome(env), "browser-profiles");
+
+/** 装浏览器的命令（提示里用） */
+export const installCmd = (prog = "agent-hub-runner") => `${prog} browser install`;
+// @意图#R729(2026-11-04): 没装 / 版本不对时 bot 和网页看到的话：直接给命令，用户复制到终端运行就行
+export const NOT_INSTALLED = (prog = "npx -y agent-hub-runner@latest") =>
+  `这台电脑还没装 bot 专用的浏览器。请主人在电脑终端里运行：${installCmd(prog)}（会下载 playwright-core 和一只独立的 Chromium，约 200MB，只要装一次）`;
+export const VERSION_MISMATCH = (have, prog = "npx -y agent-hub-runner@latest") =>
+  `电脑上装的浏览器组件版本（${have}）和运行器要的（${PW_VERSION}）不一样。请主人在电脑终端里重新运行：${installCmd(prog)}`;
+export const RETRY_TEXT = "浏览器刚换成了有窗口的模式（主人点了「打开 bot 的浏览器」），这一步没做完，请重试这一步。";
+export const CLOSED_BY_USER = "浏览器窗口被关掉了，这一步没做完，请重试这一步（会在后台重新打开）。";
+
+/** 这个 bot 的资料目录。bot_id 只认字母、数字、点、下划线、横线（防止拼出别的路径）。 */
+// @意图#R729(2026-11-04): 每个 bot 一份资料目录（登录信息、cookie 都在这里，关掉再开还在），互不相干
+export function profileDirFor(botId, env = process.env) {
+  if (typeof botId !== "string" || !/^[A-Za-z0-9._-]{1,100}$/.test(botId) || botId === "." || botId === "..") throw new Error(`bot_id 不合法：${String(botId)}`);
+  return path.join(profilesDir(env), botId);
+}
+
+/** 不加载 playwright，只看文件：装没装、版本对不对、Chromium 在不在。 */
+// @意图#R729(2026-11-04): 心跳里报给服务器（网页抽屉显示「未安装」），也在每次用浏览器前先查一遍
+export function browserStatus(env = process.env) {
+  const pkg = path.join(browserPkgDir(env), "node_modules", "playwright-core", "package.json");
+  let version = null;
+  try { version = String(JSON.parse(readFileSync(pkg, "utf8")).version); } catch { return { installed: false, reason: "no_pkg", version: null }; }
+  if (version !== PW_VERSION) return { installed: false, reason: "version_mismatch", version };
+  const dir = chromiumDir(env);
+  if (!dir || !existsSync(path.join(dir, "INSTALLATION_COMPLETE"))) return { installed: false, reason: "no_chromium", version };
+  return { installed: true, reason: null, version };
+}
+
+/** 装好的 playwright-core 自带的 browsers.json 里 chromium 那一项（版本号目录、浏览器版本） */
+function chromiumEntry(env) {
+  try {
+    const j = JSON.parse(readFileSync(path.join(browserPkgDir(env), "node_modules", "playwright-core", "browsers.json"), "utf8"));
+    return (j.browsers ?? []).find((b) => b.name === "chromium") ?? null;
+  } catch { return null; }
+}
+/** Chromium 应该装在哪（按 browsers.json 算出版本号目录） */
+function chromiumDir(env) {
+  const c = chromiumEntry(env);
+  return c?.revision ? path.join(browsersDir(env), `chromium-${c.revision}`) : null;
+}
+
+/**
+ * 后台（无头）模式用的 User-Agent：和有窗口的 Chrome 一样，不带 HeadlessChrome。
+ * 不这么做百度等网站一搜就跳验证码（2026-11-04 真机验收时遇到）。这不是过验证码，只是别自报「我是无头浏览器」。
+ */
+// @意图#R729(2026-11-04): 真机验收发现百度对 HeadlessChrome 的 UA 直接跳图形验证码；无头时按平台 + 钉死的 Chromium 主版本号给一个普通 Chrome 的 UA
+export function headlessUserAgent(env = process.env, platform = process.platform) {
+  const major = String(chromiumEntry(env)?.browserVersion ?? "").split(".")[0] || "156";
+  const os = platform === "darwin" ? "Macintosh; Intel Mac OS X 10_15_7" : platform === "win32" ? "Windows NT 10.0; Win64; x64" : "X11; Linux x86_64";
+  return `Mozilla/5.0 (${os}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`;
+}
+
+/** 没装好就抛大白话 */
+export function ensureInstalled(env = process.env, prog) {
+  const st = browserStatus(env);
+  if (st.installed) return st;
+  if (st.reason === "version_mismatch") throw new Error(VERSION_MISMATCH(st.version, prog));
+  throw new Error(NOT_INSTALLED(prog));
+}
+
+/** 跑一个命令，输出原样转给终端；返回退出码。timeoutMs 到了杀掉、算失败。 */
+function runCmd(cmd, args, { env, timeoutMs, platform = process.platform } = {}) {
+  return new Promise((resolve) => {
+    const win = platform === "win32";
+    // Windows 上 npm 是 npm.cmd，新版 Node 要 shell 才能跑 .cmd；参数里的路径加引号
+    const child = spawn(cmd, win ? args.map((a) => (/[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a)) : args, { env, stdio: "inherit", shell: win });
+    let timer;
+    if (timeoutMs) timer = setTimeout(() => { try { child.kill(); } catch { /* 已经退出 */ } resolve({ code: -1, timedOut: true }); }, timeoutMs);
+    child.on("error", (e) => { clearTimeout(timer); resolve({ code: -1, error: e }); });
+    child.on("exit", (code) => { clearTimeout(timer); resolve({ code: code ?? -1 }); });
+  });
+}
+
+/**
+ * agent-hub-runner browser install：先把 playwright-core 装进 ~/.agent-runner/browser/，再把 Chromium 下到 ~/.agent-runner/browsers/。
+ * 两步都是先官方源，失败（或官方下 Chromium 超过 10 分钟）再换国内镜像。返回每一步用的是哪个源。
+ */
+// @意图#R729(2026-11-04): king 定：先官方、失败再镜像（npm 用 registry.npmmirror.com，Chromium 用 cdn.npmmirror.com 的 playwright 镜像）；
+// 只装 Chromium 本体（--no-shell，不另下 headless shell），后台模式也用它（channel: "chromium"），有窗口和后台共用同一只浏览器、同一份资料目录
+export async function installBrowser({ env = process.env, log = console.log, run = runCmd, platform = process.platform, officialTimeoutMs = OFFICIAL_TIMEOUT_MS } = {}) {
+  const dir = browserPkgDir(env);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const pj = path.join(dir, "package.json");
+  if (!existsSync(pj)) writeFileSync(pj, `${JSON.stringify({ name: "agent-hub-runner-browser", private: true, description: "agent-hub-runner browser install 装的浏览器组件" }, null, 2)}\n`);
+  const npm = platform === "win32" ? "npm.cmd" : "npm";
+  const npmArgs = ["install", "--no-audit", "--no-fund", "--save-exact", "--prefix", dir, `playwright-core@${PW_VERSION}`];
+  const used = { npm: "official", chromium: "official" };
+  const st = browserStatus(env);
+  if (st.version === PW_VERSION) log(`playwright-core ${PW_VERSION} 已经装过，跳过。`);
+  else {
+    log(`第 1 步：装 playwright-core ${PW_VERSION}（官方源）……`);
+    let r = await run(npm, npmArgs, { env, platform });
+    if (r.code !== 0) {
+      log("官方源没装成，换国内镜像 registry.npmmirror.com 再试……");
+      used.npm = "mirror";
+      r = await run(npm, [...npmArgs, "--registry", MIRROR_REGISTRY], { env, platform });
+      if (r.code !== 0) throw new Error("playwright-core 没装成（官方源和镜像都失败了）。检查网络后再运行一次同一条命令。");
+    }
+  }
+  const cli = path.join(dir, "node_modules", "playwright-core", "cli.js");
+  if (!existsSync(cli)) throw new Error(`装完了却找不到 ${cli}，请再运行一次同一条命令。`);
+  const pwEnv = { ...env, PLAYWRIGHT_BROWSERS_PATH: browsersDir(env) };
+  const args = [cli, "install", "--no-shell", "chromium"];
+  log(`第 2 步：下载 Chromium 到 ${browsersDir(env)}（官方源，约 200MB）……`);
+  let r = await run(process.execPath, args, { env: pwEnv, platform, timeoutMs: officialTimeoutMs });
+  if (r.code !== 0) {
+    log(r.timedOut ? `官方源 ${Math.round(officialTimeoutMs / 60_000)} 分钟还没下完，换国内镜像再试……` : "官方源没下成，换国内镜像 cdn.npmmirror.com 再试……");
+    used.chromium = "mirror";
+    r = await run(process.execPath, args, { env: { ...pwEnv, PLAYWRIGHT_DOWNLOAD_HOST: MIRROR_DOWNLOAD_HOST }, platform });
+    if (r.code !== 0) throw new Error("Chromium 没下成（官方源和镜像都失败了）。检查网络后再运行一次同一条命令。");
+  }
+  const after = browserStatus(env);
+  if (!after.installed) throw new Error("下载完了但检查没通过，请再运行一次同一条命令。");
+  log(`装好了：playwright-core ${PW_VERSION}（${used.npm === "mirror" ? "镜像" : "官方源"}），Chromium（${used.chromium === "mirror" ? "镜像" : "官方源"}）。bot 现在能用浏览器了，运行器不用重启。`);
+  return used;
+}
+
+/** 按绝对路径加载 ~/.agent-runner/browser/ 里的 playwright-core（运行器自己不依赖它）。 */
+// @意图#R729(2026-11-04): 乙：用到时才加载；PLAYWRIGHT_BROWSERS_PATH 要在第一次加载前设好（它在加载时读）
+export function loadPlaywright(env = process.env, prog) {
+  ensureInstalled(env, prog);
+  process.env.PLAYWRIGHT_BROWSERS_PATH = browsersDir(env);
+  const req = createRequire(path.join(browserPkgDir(env), "package.json"));
+  return req("playwright-core");
+}
+
+/** 页面正在跳转时读页面会碰到的错误（等一下再读就好） */
+const NAV_RACE = /Execution context was destroyed|interrupted by another navigation|Cannot find context with specified id|frame was detached|navigat(ing|ion).*(changed|interrupted)/i;
+
+// ---- 页面里跑的两段（序列化后在浏览器里执行，不能引用外面的变量） ----
+/** 找出页面上能点、能填的元素（看得见的），最多 max 个 */
+function collectElements(max) {
+  const sel = "a[href],button,input:not([type=hidden]),textarea,select,summary,[role=button],[role=link],[role=textbox],[role=searchbox],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=option],[role=combobox],[contenteditable=''],[contenteditable=true],[onclick]";
+  const out = [];
+  for (const el of document.querySelectorAll(sel)) {
+    const r = el.getBoundingClientRect();
+    if (r.width < 2 || r.height < 2) continue;
+    const s = getComputedStyle(el);
+    if (s.visibility === "hidden" || s.display === "none" || Number(s.opacity) === 0) continue;
+    if (r.bottom < -200 || r.top > innerHeight * 3) continue;
+    out.push(el);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+/** 一个元素的一行说明 */
+function describeElements(els) {
+  const cut = (t, n) => { const x = String(t ?? "").replace(/\s+/g, " ").trim(); return x.length > n ? `${x.slice(0, n)}…` : x; };
+  return els.map((el) => {
+    const tag = el.tagName.toLowerCase();
+    const role = el.getAttribute("role") || "";
+    const type = (el.getAttribute("type") || "").toLowerCase();
+    const r = el.getBoundingClientRect();
+    let kind = role || tag;
+    if (tag === "a") kind = "链接";
+    else if (tag === "button" || role === "button" || type === "submit" || type === "button") kind = "按钮";
+    else if (tag === "input" && (type === "checkbox" || type === "radio")) kind = type === "checkbox" ? "勾选框" : "单选";
+    else if (tag === "input" || tag === "textarea" || role === "textbox" || role === "searchbox" || el.isContentEditable) kind = "输入框";
+    else if (tag === "select" || role === "combobox") kind = "下拉框";
+    const text = cut(el.innerText || el.textContent, 60);
+    const label = cut(el.getAttribute("aria-label") || el.getAttribute("title") || el.getAttribute("alt"), 40);
+    const ph = cut(el.getAttribute("placeholder"), 40);
+    const val = tag === "input" && type !== "password" && type !== "checkbox" && type !== "radio" ? cut(el.value, 40) : "";
+    const href = tag === "a" ? cut(el.getAttribute("href"), 80) : "";
+    const parts = [kind];
+    if (text) parts.push(`"${text}"`);
+    if (label && label !== text) parts.push(`标签="${label}"`);
+    if (ph) parts.push(`提示="${ph}"`);
+    if (val) parts.push(`值="${val}"`);
+    if (type === "password") parts.push("(密码框)");
+    if ((type === "checkbox" || type === "radio") && el.checked) parts.push("(已勾)");
+    if (href && !href.startsWith("javascript")) parts.push(`→ ${href}`);
+    parts.push(`@(${Math.round(r.left + r.width / 2)},${Math.round(r.top + r.height / 2)})`);
+    return parts.join(" ");
+  });
+}
+
+/**
+ * 每个 bot 一只浏览器（launchPersistentContext，资料目录按 bot 分）。bot 的操作按 bot 排队一个一个做；
+ * 网页点「打开」不排队，直接把后台的换成有窗口的（正在做的那一步会失败一次，叫模型重试）。
+ */
+// @意图#R729(2026-11-04): king 定的几条：默认后台跑、点按钮才显示；撞上时弹出同一个窗口一起看（后台实例关掉、同一份资料目录重开有窗口的、恢复打开的网址）；
+// 用户关掉窗口后下次操作回到后台；后台的 10 分钟没人用就关；浏览器操作全部自动允许（这里不管批准）
+// showWindow=false 只给测试用：「有窗口」模式照样走切换逻辑，但实际不弹窗口
+export function createBrowserManager({ env = process.env, log = () => {}, idleMs = IDLE_CLOSE_MS, load = () => loadPlaywright(env), prog, showWindow = true } = {}) {
+  /** botId → { ctx, headed, page, refs, gen, timer } */
+  const bots = new Map();
+  /** botId → 正在开 / 换模式的 Promise（同一个 bot 同时只开一次） */
+  const opening = new Map();
+  /** botId → 操作队列的尾巴 */
+  const queues = new Map();
+  let gen = 0;
+
+  const arm = (botId, e) => {
+    clearTimeout(e.timer);
+    if (e.headed) return; // 有窗口的由用户关，不自动关
+    e.timer = setTimeout(() => { if (bots.get(botId) === e) { log(`[${botId}] 浏览器 ${Math.round(idleMs / 60_000)} 分钟没用，关掉了`); void closeEntry(botId, e); } }, idleMs);
+    e.timer.unref?.();
+  };
+  async function closeEntry(botId, e) {
+    clearTimeout(e.timer);
+    if (bots.get(botId) === e) bots.delete(botId);
+    await e.ctx.close().catch(() => {});
+  }
+
+  async function launch(botId, headed, urls = []) {
+    const pw = load();
+    const dir = profileDirFor(botId, env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    let ctx;
+    try {
+      ctx = await pw.chromium.launchPersistentContext(dir, {
+        channel: "chromium", headless: !(headed && showWindow), viewport: headed ? null : HEADLESS_VIEWPORT,
+        locale: "zh-CN", args: headed ? ["--start-maximized"] : [],
+        ...(headed && showWindow ? {} : { userAgent: headlessUserAgent(env) }),
+      });
+    } catch (e) {
+      const m = String(e?.message ?? e);
+      if (/ProcessSingleton|SingletonLock|profile.*in use|already in use/i.test(m)) throw new Error("这个 bot 的浏览器资料目录正被另一只浏览器占着（可能是上次没关干净），先把那个 Chromium 窗口关掉再试。");
+      throw new Error(`浏览器没打开：${m.split("\n")[0]}`);
+    }
+    const e = { ctx, headed, page: null, refs: [], gen: ++gen, timer: undefined };
+    ctx.on("page", (p) => { if (bots.get(botId) === e) e.page = p; }); // 点了链接开新标签页：跟过去
+    ctx.on("close", () => { if (bots.get(botId) === e) { clearTimeout(e.timer); bots.delete(botId); if (e.headed) log(`[${botId}] 浏览器窗口关掉了，之后 bot 用浏览器会在后台打开`); } });
+    bots.set(botId, e);
+    const pages = ctx.pages();
+    for (let i = 0; i < urls.length; i++) {
+      const p = i < pages.length ? pages[i] : await ctx.newPage();
+      await p.goto(urls[i], { waitUntil: "domcontentloaded", timeout: 30_000 }).catch(() => {});
+      e.page = p;
+    }
+    if (!e.page) e.page = ctx.pages()[0] ?? await ctx.newPage();
+    arm(botId, e);
+    return e;
+  }
+
+  /** 拿到这个 bot 的浏览器（没有就后台开一只） */
+  async function get(botId) {
+    const cur = bots.get(botId);
+    if (cur) return cur;
+    if (opening.has(botId)) return opening.get(botId);
+    const p = launch(botId, false).finally(() => opening.delete(botId));
+    opening.set(botId, p);
+    return p;
+  }
+
+  /** 网页点「打开 bot 的浏览器」：换成 / 打开有窗口的 */
+  // @意图#R730(2026-11-04): 打开失败只把错误回给网页，runner 不能因此崩掉
+  async function openHeaded(botId) {
+    if (opening.has(botId)) await opening.get(botId).catch(() => {});
+    const cur = bots.get(botId);
+    if (cur?.headed) { await cur.page?.bringToFront().catch(() => {}); return { ok: true, already: true, urls: cur.ctx.pages().map((p) => p.url()) }; }
+    const run = (async () => {
+      let urls = [];
+      if (cur) {
+        urls = cur.ctx.pages().map((p) => p.url()).filter((u) => u && u !== "about:blank");
+        log(`[${botId}] 网页上点了打开浏览器：后台的先关掉，换成有窗口的（恢复 ${urls.length} 个网页）`);
+        await closeEntry(botId, cur);
+      } else log(`[${botId}] 网页上点了打开浏览器`);
+      const e = await launch(botId, true, urls);
+      await e.page?.bringToFront().catch(() => {});
+      return { ok: true, already: false, urls };
+    })().finally(() => opening.delete(botId));
+    // @意图#R730(2026-11-04): 存进 opening 的是 run 派生出来的 promise。run 失败（没装浏览器、启动出错）时，没人 await 它就成了
+    // 未处理的 rejection，Node 会把整个 runner 进程退掉，网页上显示离线。挂一个空 catch 标成已处理；别人 await 它照样拿到错误。
+    const waiting = run.then(() => bots.get(botId));
+    waiting.catch(() => {});
+    opening.set(botId, waiting);
+    return run;
+  }
+
+  function currentPage(e) {
+    if (e.page && !e.page.isClosed()) return e.page;
+    const ps = e.ctx.pages();
+    e.page = ps[ps.length - 1] ?? null;
+    return e.page;
+  }
+
+  async function settle(page) {
+    await page.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => {});
+    await page.waitForLoadState("load", { timeout: 3_000 }).catch(() => {});
+    await page.waitForTimeout(300).catch(() => {});
+  }
+
+  // @意图#R729(2026-11-04): 真机验收发现：按回车搜索、网页自己跳转时，刚好在跳的那一下读元素会报 Execution context was destroyed；
+  // 碰到跳转类错误就等页面稳住再读，最多 3 次
+  async function observe(e, page, view) {
+    for (let i = 0; ; i++) {
+      try {
+        const head = { url: page.url(), title: await page.title().catch(() => ""), headed: e.headed };
+        if (view === "image") {
+          const buf = await page.screenshot({ type: "jpeg", quality: 60, timeout: 15_000 });
+          return { kind: "image", mime: "image/jpeg", data: buf.toString("base64"), ...head };
+        }
+        return { kind: "elements", text: await elementsText(e, page), ...head };
+      } catch (err) {
+        if (i >= 2 || !NAV_RACE.test(String(err?.message ?? err))) throw err;
+        await settle(page);
+        page = currentPage(e) ?? page;
+      }
+    }
+  }
+
+  async function elementsText(e, page) {
+    for (const h of e.refs) await h.dispose().catch(() => {});
+    e.refs = [];
+    const arr = await page.evaluateHandle(collectElements, MAX_ELEMENTS);
+    const lines = await arr.evaluate(describeElements);
+    for (let i = 0; i < lines.length; i++) {
+      const h = await arr.getProperty(String(i));
+      e.refs.push(h.asElement() ?? h);
+    }
+    await arr.dispose().catch(() => {});
+    const body = await page.evaluate(() => (document.body?.innerText ?? "").replace(/\n{3,}/g, "\n\n").trim()).catch(() => "");
+    const text = body.length > MAX_PAGE_TEXT ? `${body.slice(0, MAX_PAGE_TEXT)}…（后面还有 ${body.length - MAX_PAGE_TEXT} 字，滚动后再看）` : body;
+    return `可操作的元素（[编号] 类型 文字 @(中心坐标)；点击 / 输入用编号）：\n${lines.map((l, i) => `[${i + 1}] ${l}`).join("\n") || "（没找到）"}\n\n页面文字：\n${text || "（空）"}`;
+  }
+
+  function refOf(e, ref) {
+    const n = Number(ref);
+    const h = Number.isInteger(n) && n >= 1 ? e.refs[n - 1] : undefined;
+    if (!h) throw new Error(`没有编号 [${String(ref)}]：编号只在最近一次返回的元素清单里有效，先用 snapshot 拿新清单`);
+    return h;
+  }
+
+  const num = (v, name) => { const n = Number(v); if (!Number.isFinite(n)) throw new Error(`${name} 要是数字`); return n; };
+
+  async function act(e, action, a) {
+    if (action === "close") { await closeEntry(a.__bot, e); return { kind: "text", text: "浏览器关掉了（登录状态还在，下次用会重新打开）" }; }
+    let page = currentPage(e) ?? await e.ctx.newPage();
+    e.page = page;
+    switch (action) {
+      case "open": {
+        const url = String(a.url ?? "").trim();
+        if (!url) throw new Error("open 要给 url");
+        const full = /^[a-z][a-z0-9+.-]*:/i.test(url) ? url : `https://${url}`;
+        if (!/^(https?|file|about|data):/i.test(full)) throw new Error(`不支持的网址：${url}`);
+        // 网页自己又跳了一次（重定向到登录页、验证页）不算失败，下面照常读跳到的那一页
+        await page.goto(full, { waitUntil: "domcontentloaded", timeout: 30_000 }).catch((err) => { if (!NAV_RACE.test(String(err?.message ?? err))) throw err; });
+        break;
+      }
+      case "look": case "screenshot": case "snapshot": break;
+      case "click": await page.mouse.click(num(a.x, "x"), num(a.y, "y")); break;
+      case "click_ref": await refOf(e, a.ref).click({ timeout: 10_000 }); break;
+      case "type": {
+        const text = String(a.text ?? "");
+        if (a.ref !== undefined && a.ref !== null && a.ref !== "") {
+          await refOf(e, a.ref).click({ timeout: 10_000 });
+          await page.keyboard.press("ControlOrMeta+A");
+        }
+        await page.keyboard.type(text, { delay: 25 });
+        break;
+      }
+      case "press": await page.keyboard.press(String(a.key ?? "Enter")); break;
+      case "scroll": await page.mouse.wheel(Number(a.dx ?? 0) || 0, a.dy === undefined ? 600 : num(a.dy, "dy")); break;
+      case "back": await page.goBack({ waitUntil: "domcontentloaded", timeout: 15_000 }).catch(() => null); break;
+      default: throw new Error(`不认识的浏览器动作：${action}`);
+    }
+    if (action !== "look" && action !== "screenshot" && action !== "snapshot") await settle(currentPage(e) ?? page);
+    page = currentPage(e) ?? page;
+    const view = action === "snapshot" ? "elements" : a.view === "image" ? "image" : "elements";
+    return observe(e, page, view);
+  }
+
+  /** bot 的一步操作。同一个 bot 的操作排队；中途被网页「打开」换了模式就回 RETRY_TEXT。 */
+  // @意图#R729(2026-11-04): 返回观察结果（截图或元素清单）；资料目录、模式切换都在这里管
+  async function run(botId, action, args = {}) {
+    profileDirFor(botId, env); // 先校验 bot_id
+    const prev = queues.get(botId) ?? Promise.resolve();
+    const job = prev.catch(() => {}).then(async () => {
+      if (action === "close" && !bots.has(botId) && !opening.has(botId)) return { kind: "text", text: "浏览器本来就没开" };
+      ensureInstalled(env, prog);
+      const e = await get(botId);
+      const g = e.gen;
+      try {
+        const r = await act(e, action, { ...args, __bot: botId });
+        if (bots.get(botId) === e) arm(botId, e);
+        return r;
+      } catch (err) {
+        const now = bots.get(botId);
+        if (action !== "close" && (now?.gen ?? -1) !== g) throw new Error(now || opening.has(botId) ? RETRY_TEXT : CLOSED_BY_USER);
+        throw err;
+      }
+    });
+    queues.set(botId, job);
+    try { return await job; } finally { if (queues.get(botId) === job) queues.delete(botId); }
+  }
+
+  return {
+    run,
+    openHeaded,
+    /** 测试 / 排查用：这个 bot 现在的模式（null = 没开） */
+    mode(botId) { const e = bots.get(botId); return e ? (e.headed ? "headed" : "headless") : null; },
+    /** 测试用：这个 bot 的 BrowserContext（模拟用户关窗口） */
+    _contextOf(botId) { return bots.get(botId)?.ctx ?? null; },
+    /** 运行器退出时关掉所有浏览器 */
+    async closeAll() { await Promise.all([...bots.entries()].map(([b, e]) => closeEntry(b, e))); },
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-hub-runner",
-  "version": "0.1.3",
-  "description": "agent-hub 的电脑运行器：配对后让你的 bot 在这台电脑上读写授权目录里的文件、跑命令（跑命令要你在网页上批准）",
+  "version": "0.2.0",
+  "description": "agent-hub 的电脑运行器：配对后让你的 bot 在这台电脑上读写授权目录里的文件、跑命令（跑命令要你在网页上批准），还能用它自己的独立浏览器",
   "type": "module",
   "bin": {
     "agent-hub-runner": "bin/agent-hub-runner.mjs"
@@ -11,6 +11,7 @@
     "ops.mjs",
     "edit.mjs",
     "changes.mjs",
+    "browser.mjs",
     "autostart.mjs",
     "bin/agent-hub-runner.mjs",
     "README.md"

package/runner.mjs

@@ -27,7 +27,8 @@ import { execFile, spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { runOp } from "./ops.mjs";
 import { buildChangeRecord, changesDirFor, CHANGE_ID_RE, createChangeStore } from "./changes.mjs";
-import { autostartOff, autostartOn, autostartStatus, logFileFor, ONLY_MAC, otherAutostarts, runnerHome, truncateLogIfBig } from "./autostart.mjs";
+import { browserStatus, createBrowserManager, installBrowser } from "./browser.mjs";
+import { autostartOff, autostartOffWindows, autostartOn, autostartOnWindows, autostartStatus, autostartStatusWindows, logFileFor, ONLY_MAC, otherAutostarts, runnerHome, truncateLogIfBig } from "./autostart.mjs";
 
 export const PROTOCOL_VERSION = 1;
 /** npm 包名，也是装好后的命令名 */
@@ -303,8 +304,12 @@ const wsUrlOf = (server) => `${server.replace(/^http/, "ws")}/devices/ws`;
 // @意图#R639(2026-10-27已废弃): 目录不再是连接时固定的常量；没目录时 call 一律拒绝；pick_dir 选完检查、写回配置（600）、回 dir_result（R640 改成按 bot 分）
 // @意图#R690(2026-11-01): write / edit 带 change_id（服务器记灰字时生成的 auto_id）就在写改成功后存一份改动记录（存失败只记日志）；
 // 新消息 change_get {id, change_id} → change_result {id, ok:true, found, record}，不看这个 bot 有没有目录（换了目录也能看旧记录）
-export function createSession(cfg, { log = say, platform = process.platform, pickDir = platform === "win32" ? pickDirWindows : pickDirMac, file = configPath(), changes } = {}) {
+// @意图#R729(2026-11-04): 新消息 browser {id, bot_id, action, args} → result（截图或元素清单）、browser_open {id, bot_id} → result（网页点「打开 bot 的浏览器」）；
+// 浏览器不看这个 bot 有没有选目录（资料目录在 ~/.agent-runner/browser-profiles/<bot_id>/，和授权目录无关）；断线不关浏览器（重连后接着用）
+export function createSession(cfg, { log = say, platform = process.platform, pickDir = platform === "win32" ? pickDirWindows : pickDirMac, file = configPath(), changes, browser } = {}) {
   let dirs = botDirsOf(cfg); // bot_id → 授权目录
+  let browsers = browser; // R729：每个 bot 一只浏览器，用到时才建
+  const browserMgr = () => (browsers ??= createBrowserManager({ log }));
   const jobs = new Map(); // 调用 id → AbortController
   const picks = new Map(); // 弹窗 id → AbortController
   let store = changes; // 改动记录（R690），用到时才建
@@ -342,6 +347,34 @@ export function createSession(cfg, { log = say, platform = process.platform, pic
     }
   }
 
+  // @意图#R729(2026-11-04): bot 用浏览器：全部自动允许（不弹卡）；打字只记字数（可能是密码）
+  async function handleBrowser(send, msg) {
+    const { id } = msg;
+    const bot = typeof msg.bot_id === "string" ? msg.bot_id : "";
+    const action = typeof msg.action === "string" ? msg.action : "";
+    const args = msg.args && typeof msg.args === "object" ? msg.args : {};
+    if (!bot) { send({ type: "result", id, ok: false, error: "缺 bot_id" }); return; }
+    log(`[${bot}] 浏览器：${action}${action === "open" ? ` ${args.url ?? ""}` : action === "type" ? `（${String(args.text ?? "").length} 个字）` : ""}`);
+    try {
+      const res = await browserMgr().run(bot, action, args);
+      send({ type: "result", id, ok: true, ...res });
+    } catch (e) {
+      send({ type: "result", id, ok: false, error: e?.message ?? String(e) });
+    }
+  }
+  // @意图#R729(2026-11-04): 网页点「打开 bot 的浏览器」：在这台电脑上弹出有窗口的浏览器（后台的换成有窗口的，恢复打开的网址）
+  async function handleBrowserOpen(send, msg) {
+    const { id } = msg;
+    const bot = typeof msg.bot_id === "string" ? msg.bot_id : "";
+    if (!bot) { send({ type: "result", id, ok: false, error: "缺 bot_id" }); return; }
+    try {
+      const r = await browserMgr().openHeaded(bot);
+      send({ type: "result", id, ok: true, bot_id: bot, already: !!r.already, urls: r.urls ?? [] });
+    } catch (e) {
+      send({ type: "result", id, ok: false, bot_id: bot, error: e?.message ?? String(e) });
+    }
+  }
+
   async function handlePick(send, msg) {
     const { id } = msg;
     const bot = typeof msg.bot_id === "string" ? msg.bot_id : "";
@@ -377,6 +410,8 @@ export function createSession(cfg, { log = say, platform = process.platform, pic
       if (msg.type === "call") return handleCall(send, msg);
       if (msg.type === "pick_dir") return handlePick(send, msg);
       if (msg.type === "change_get") return handleChangeGet(send, msg);
+      if (msg.type === "browser") return handleBrowser(send, msg); // R729
+      if (msg.type === "browser_open") return handleBrowserOpen(send, msg); // R729
       if (msg.type === "abort") { jobs.get(msg.id)?.abort(); picks.get(msg.id)?.abort(); }
       return undefined;
     },
@@ -386,6 +421,8 @@ export function createSession(cfg, { log = say, platform = process.platform, pic
       jobs.clear();
       picks.clear();
     },
+    /** R729：运行器退出时关掉所有 bot 的浏览器 */
+    closeBrowsers() { return browsers ? browsers.closeAll() : Promise.resolve(); },
   };
 }
 
@@ -396,6 +433,8 @@ export function createSession(cfg, { log = say, platform = process.platform, pic
 // @意图#R666(2026-10-29): hello 多报 runner_version（网页提示有新版本）和 autostart（是不是开机自启起的，网页据此给升级命令）；
 // 服务器用 4409 顶掉这条（同一份配置又开了一个）：不再重连、结束（"replaced"）；连不上时只在第一次和之后每 30 次打一行，开机自启没网时日志不刷屏；
 // 连上那句不再说「右栏」，开机自启时不说「按 Ctrl-C」
+// @意图#R729(2026-11-04): hello 和心跳多报浏览器装没装（browser: {installed, version}），网页抽屉据此显示「未安装」和安装命令；装好后不用重启，下一次心跳就更新；
+// 停掉时关掉所有 bot 的浏览器
 // @意图#R640(2026-10-27): hello 报 bot→目录 对照表（bot_dirs），不再报单一 dir
 // @意图#R639(2026-10-27): 没目录也能连上；目录由 createSession 管（网页上选完马上生效），重连时 hello 带当前目录
 // @意图#R636(2026-10-27): 前台运行、心跳、执行工具调用；断线时杀掉正在跑的命令，重连后不重放
@@ -411,6 +450,7 @@ export function startRunner(cfg, { log = say, retryMs = 2000, platform = process
   const done = new Promise((r) => { resolveDone = r; });
   const finish = (why) => { if (!stopped) { stopped = true; } resolveDone(why); };
   const send = (sock, msg) => { if (sock.readyState === WebSocket.OPEN) sock.send(JSON.stringify(msg)); };
+  const browserInfo = () => { try { const b = browserStatus(); return { installed: b.installed, version: b.version }; } catch { return { installed: false, version: null }; } };
 
   function connect() {
     if (stopped) return;
@@ -418,8 +458,8 @@ export function startRunner(cfg, { log = say, retryMs = 2000, platform = process
     ws = sock;
     sock.addEventListener("open", () => {
       send(sock, { type: "hello", version: PROTOCOL_VERSION, device_id: cfg.device_id, token: cfg.token, bot_dirs: session.botDirs,
-        name: cfg.name ?? os.hostname(), os: `${process.platform} ${os.release()}`, runner_version: RUNNER_VERSION, autostart: background });
-      beat = setInterval(() => send(sock, { type: "ping" }), HEARTBEAT_MS);
+        name: cfg.name ?? os.hostname(), os: `${process.platform} ${os.release()}`, runner_version: RUNNER_VERSION, autostart: background, browser: browserInfo() });
+      beat = setInterval(() => send(sock, { type: "ping", browser: browserInfo() }), HEARTBEAT_MS);
     });
     sock.addEventListener("message", (ev) => {
       let msg;
@@ -452,6 +492,7 @@ export function startRunner(cfg, { log = say, retryMs = 2000, platform = process
     if (stopped) return;
     stopped = true;
     session.killAll();
+    void session.closeBrowsers(); // R729
     clearInterval(beat);
     try { ws?.close(1000, "runner stopped"); } catch { /* ignore */ }
     resolveDone("stopped");
@@ -478,10 +519,17 @@ export function takeLock(file = configPath(), { pid = process.pid, launchd = pro
   return { ok: true, release: () => { if (readLock(file)?.pid === pid) rmSync(lockPath(file), { force: true }); } };
 }
 
-/** 被网页断开 / 令牌失效后把这份配置的开机自启关掉（不然每次登录都白起一次）；不是 Mac、没开都不要紧 */
+// @意图#R725(2026-11-03): Windows 被断开时也关掉计划任务，不然下次登录又白起一次
+/** 被网页断开 / 令牌失效后把这份配置的开机自启关掉（不然每次登录都白起一次）；不是 Mac / Windows、没开都不要紧 */
 async function autostartOffQuietly(file, deps) {
-  if ((deps.platform ?? process.platform) !== "darwin") return false;
-  try { return (await autostartOff({ configFile: file, launchctl: deps.launchctl })).wasOn; } catch { return false; }
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "darwin" && platform !== "win32") return false;
+  try {
+    const r = platform === "win32"
+      ? await autostartOffWindows({ configFile: file, schtasks: deps.schtasks })
+      : await autostartOff({ configFile: file, launchctl: deps.launchctl });
+    return r.wasOn;
+  } catch { return false; }
 }
 
 // @意图#R666(2026-10-29): 先拿锁（后台已在跑就提示退出 0）；开机自启时启动前日志超 5MB 清空、配置坏了/没配对也退出 0（不让 launchd 反复拉起）；
@@ -513,11 +561,13 @@ async function runStart(prog = progName(), deps = {}) {
   process.exit(0);
 }
 
-/** R666：配完要不要开机自启：flag（--autostart / --no-autostart）优先；不是 Mac 不开；是终端就问；不是终端（脚本、管道）不问、只提示 */
+// @意图#R725(2026-11-03): Windows 也支持开机自启（计划任务，见 autostart.mjs）。Mac 和 Windows 都问；别的系统不开。
+/** R666：配完要不要开机自启：flag（--autostart / --no-autostart）优先；不是 Mac / Windows 不开；是终端就问；不是终端（脚本、管道）不问、只提示 */
 export function decideAutostart({ flag, platform = process.platform, tty = !!(process.stdin.isTTY && process.stdout.isTTY) }) {
-  if (flag === true) return platform === "darwin" ? "on" : "unsupported";
+  const supported = platform === "darwin" || platform === "win32";
+  if (flag === true) return supported ? "on" : "unsupported";
   if (flag === false) return "off";
-  if (platform !== "darwin") return "off";
+  if (!supported) return "off";
   return tty ? "ask" : "hint";
 }
 
@@ -543,11 +593,16 @@ async function stopHolder(file) {
 
 const here = () => path.dirname(fileURLToPath(import.meta.url));
 // @意图#R666(2026-10-29): 开启自启：前台有一个在跑就先停掉它（不然后台那个起来就因为锁退出了），再交给 autostart.mjs（复制自己、写 plist、加载）
+// @意图#R725(2026-11-03): Windows 走计划任务（autostartOnWindows），Mac 走 launchd。提示里的「这台 Mac」按平台写。
 async function turnAutostartOn(file, prog, deps = {}) {
   const held = readLock(file);
   if (held && !held.launchd) await stopHolder(file);
-  const r = await autostartOn({ configFile: file, version: RUNNER_VERSION, srcDir: here(), launchctl: deps.launchctl, platform: deps.platform });
-  console.log(`已设开机自启：以后登录这台 Mac 会自动连上，不用开终端。现在已经在后台连着，可以关掉这个终端窗口了。\n日志：${r.log}\n关掉开机自启：${prog} autostart off`);
+  const platform = deps.platform ?? process.platform;
+  const r = platform === "win32"
+    ? await autostartOnWindows({ configFile: file, version: RUNNER_VERSION, srcDir: here(), execPath: deps.execPath, schtasks: deps.schtasks })
+    : await autostartOn({ configFile: file, version: RUNNER_VERSION, srcDir: here(), launchctl: deps.launchctl, platform });
+  const where = platform === "win32" ? "这台电脑" : "这台 Mac";
+  console.log(`已设开机自启：以后登录${where}会自动连上，不用开终端。现在已经在后台连着，可以关掉这个终端窗口了。\n日志：${r.log}\n关掉开机自启：${prog} autostart off`);
   return r;
 }
 
@@ -559,11 +614,14 @@ const usage = (prog) => `用法：
   ${prog} stop               停掉在跑的运行器
   ${prog} status             看配置、各 bot 的目录、在不在跑、开机自启
   ${prog} set-dir <bot_id> <路径>   直接指定这个 bot 的授权目录（和网页上点「选择目录」走同一套检查；弹窗弹不出来时用）
-  ${prog} autostart on|off|status   Mac 开机自启（on 也用来升级到新版本）
+  ${prog} autostart on|off|status   开机自启（Mac 用 launchd，Windows 用计划任务；on 也用来升级到新版本）
   ${prog} uninstall [--purge]       关掉自启、删掉本地副本和日志（--purge 连配置一起删）
+  ${prog} browser install    装 bot 专用的浏览器（playwright-core + 一只独立的 Chromium，约 200MB，先官方源、失败换国内镜像）
+  ${prog} browser status     看浏览器装没装
   ${prog} --version
 目录请连上后在网页上每个 bot 的私聊里点输入框下面「我的电脑」那一行选，Mac / Windows 上会弹窗让你选。`;
 
+// @意图#R729(2026-11-04): 新命令 browser install | status（装 bot 专用浏览器、看装没装）
 // @意图#R666(2026-10-29): pair 默认配完直接 start（--no-start 只配对）；配完按 decideAutostart 问 / 提示 / 开启开机自启，开了就不在前台跑；
 // 新命令 stop、autostart on|off|status、uninstall、--version；status 多显示在不在跑、版本、开机自启；用法里的命令按运行方式写（npx 时写 npx 写法）
 // @意图#R664(2026-10-29): 导出给 bin/agent-hub-runner.mjs 调；用法和「现在运行：… start」里的命令名用 progName（装好的 agent-hub-runner，仓库里 node 写法）
@@ -604,15 +662,21 @@ export async function main(argv, prog = progName(), deps = {}) {
     const sub = a.positional[0] ?? "status";
     const file = configPath();
     if (sub === "on") { loadConfig(file); await turnAutostartOn(file, prog, deps); return; }
-    if (platform !== "darwin") { console.log(ONLY_MAC); return; }
+    if (platform !== "darwin" && platform !== "win32") { console.log(ONLY_MAC); return; }
+    // @意图#R725(2026-11-03): Windows 的 off / status 走计划任务，Mac 走 launchd
     if (sub === "off") {
-      const r = await autostartOff({ configFile: file, launchctl: deps.launchctl });
+      const r = platform === "win32"
+        ? await autostartOffWindows({ configFile: file, schtasks: deps.schtasks })
+        : await autostartOff({ configFile: file, launchctl: deps.launchctl });
       console.log(r.wasOn ? "已关掉开机自启（后台那个也停了）。" : "本来就没开开机自启。");
       return;
     }
     if (sub === "status") {
-      const st = await autostartStatus({ configFile: file, launchctl: deps.launchctl, platform });
-      console.log(st.installed ? `开机自启：开着（${st.loaded ? (st.pid ? `后台在跑，进程 ${st.pid}` : "已加载，现在没在跑") : "还没加载"}）\nplist：${st.plist}\n日志：${st.log}` : "开机自启：没开");
+      const st = platform === "win32"
+        ? await autostartStatusWindows({ configFile: file, schtasks: deps.schtasks })
+        : await autostartStatus({ configFile: file, launchctl: deps.launchctl, platform });
+      const where = st.task ? `计划任务：${st.task}` : `plist：${st.plist}`;
+      console.log(st.installed ? `开机自启：开着（${st.loaded ? (st.pid ? `后台在跑，进程 ${st.pid}` : "已加载，现在没在跑") : "还没加载"}）\n${where}\n日志：${st.log}` : "开机自启：没开");
       for (const p of st.problems) console.log(`注意：${p}`);
       return;
     }
@@ -669,6 +733,19 @@ export async function main(argv, prog = progName(), deps = {}) {
     console.log(`服务器：${cfg.server}\n设备：${cfg.device_id}\n运行器版本：${RUNNER_VERSION}\n现在：${run}${auto}\n各 bot 的授权目录：${d.length ? d.map(([b, p]) => `\n  ${b}：${p}`).join("") : "（还没有，连上后在每个 bot 的私聊里点「选择目录」）"}`);
     return;
   }
+  // @意图#R729(2026-11-04): 乙：浏览器组件不进运行器的依赖，用户敲这一条才装（网页抽屉里给的就是它）；status 只看文件，不加载
+  if (a.cmd === "browser") {
+    const sub = a.positional[0] ?? "status";
+    if (sub === "install") { await (deps.installBrowser ?? installBrowser)({ log: (t) => console.log(t) }); return; }
+    if (sub === "status") {
+      const st = browserStatus();
+      console.log(st.installed ? `浏览器：装好了（playwright-core ${st.version}）`
+        : st.reason === "version_mismatch" ? `浏览器：版本不对（装的是 ${st.version}），重新运行 ${prog} browser install`
+          : `浏览器：还没装。运行 ${prog} browser install`);
+      return;
+    }
+    throw new Error(`browser 后面只能是 install 或 status（${sub} 不认识）`);
+  }
   if (a.cmd === "version") { console.log(RUNNER_VERSION); return; }
   console.log(usage(prog));
   process.exitCode = a.cmd && a.cmd !== "help" ? 1 : 0;