agent-hub-runner 0.1.2 → 0.1.4

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";
 
@@ -21,7 +22,9 @@ export const THROTTLE_S = 10;
 export const COPY_FILES = ["runner.mjs", "ops.mjs", "edit.mjs", "changes.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 +90,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 +103,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 +188,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/ops.mjs

@@ -1,7 +1,7 @@
 // @意图#R636(2026-10-27): 运行器在你电脑上真正执行 read / write / edit / bash。路径只在这里判断（S6 结论：服务器不解析用户电脑的路径）：
 // 先按授权目录换算成真实路径（解开符号链接，包括指向不存在目标的符号链接），不在授权目录里的一律拒绝；bash 的工作目录就是授权目录。
 // 第一轮没有沙箱（king 定的范围）：bash 里的命令本身能碰到目录外的东西，只能靠你看清批准卡片再点。
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -68,7 +68,7 @@ function imageMime(buf) {
 export async function opRead(args, root) {
   const real = await resolveInside(args.path, root);
   const st = await fs.stat(real);
-  if (st.isDirectory()) throw new Error(`${args.path} 是目录，不是文件（看目录里有什么用 bash 的 ls）`);
+  if (st.isDirectory()) throw new Error(`${args.path} 是目录，不是文件（看目录里有什么用 ${process.platform === "win32" ? "PowerShell 的 Get-ChildItem" : "bash 的 ls"}）`);
   if (st.size > MAX_READ_BYTES) throw new Error(`${args.path} 太大（${st.size} 字节），超过 ${MAX_READ_BYTES} 字节；用 bash 的 head/sed 看一部分`);
   const buf = await fs.readFile(real);
   const mime = imageMime(buf);
@@ -102,18 +102,54 @@ export async function opEdit(args, root, { onChange } = {}) {
   return { replaced: args.edits.length };
 }
 
-function killGroup(child) {
+function killGroup(child, platform = process.platform) {
   if (!child.pid) return;
+  // @意图#R721(2026-11-02): Windows 没有负进程组，要 taskkill /T /F 才能连子进程一起杀
+  if (platform === "win32") {
+    try { spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }); } catch { /* 进程已经没了 */ }
+    try { child.kill("SIGKILL"); } catch { /* ignore */ }
+    return;
+  }
   try { process.kill(-child.pid, "SIGKILL"); } catch { /* 进程组已经没了 */ }
   try { child.kill("SIGKILL"); } catch { /* ignore */ }
 }
 
+/**
+ * 按平台选执行器。
+ * Windows 上没有 bash：用 PowerShell，整段脚本转 UTF-16LE base64 传给 -EncodedCommand。
+ * 这样一次解决两个实现时踩到的坑：① 中文参数走 -Command 会按 ANSI 代码页解码成乱码；
+ * ② powershell -Command 的退出码恒为 0，得靠脚本尾巴的 exit $LASTEXITCODE 才拿得到真实结果。
+ */
+// @意图#R721(2026-11-02): Windows 用 PowerShell 跑命令（客户是小白，不能要求装 Git Bash）
+export function shellFor(command, platform = process.platform) {
+  if (platform === "win32") {
+    // $ProgressPreference 必须关：不加的话 PowerShell 会把进度流序列化成 #< CLIXML ... 写到 stderr，模型会看到一堆垃圾。
+    // `2>&1 | ForEach-Object { "$_" }`：错误也要转成纯字符串，否则 ErrorRecord 会被序列化成 CLIXML；
+    // 用管道逐条处理，保持边跑边输出（不缓冲）。
+    const script = [
+      "$ProgressPreference = 'SilentlyContinue'",
+      "[Console]::OutputEncoding=[Text.Encoding]::UTF8",
+      "$OutputEncoding=[Text.Encoding]::UTF8",
+      "& {",
+      command,
+      '} 2>&1 | ForEach-Object { "$_" }',
+      "exit $LASTEXITCODE",
+      "",
+    ].join("\n");
+    return {
+      file: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-OutputFormat", "Text", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")],
+    };
+  }
+  return { file: "bash", args: ["-c", command] };
+}
+
 /**
  * bash：在授权目录里用你终端的环境变量跑（服务器的环境变量不下发）。输出边跑边交给 onData；
  * 超时或 signal 中止时杀掉整个进程组。返回 { exitCode, timedOut, aborted }。
  */
 // @意图#R636(2026-10-27): 跑命令（已经过批准，只执行这一次），有超时，超时杀进程
-export function opBash(args, root, { onData, signal } = {}) {
+export function opBash(args, root, { onData, signal, platform = process.platform } = {}) {
   const command = args.command;
   if (typeof command !== "string" || !command.trim()) return Promise.reject(new Error("command 是空的"));
   let timeoutS = DEFAULT_BASH_TIMEOUT_S;
@@ -122,12 +158,13 @@ export function opBash(args, root, { onData, signal } = {}) {
     if (!Number.isFinite(t) || t <= 0) return Promise.reject(new Error("Invalid timeout: must be a finite number of seconds"));
     timeoutS = t;
   }
+  const shell = shellFor(command, platform);
   return new Promise((resolve, reject) => {
-    const child = spawn("bash", ["-c", command], { cwd: root, detached: true, stdio: ["ignore", "pipe", "pipe"], env: process.env });
+    const child = spawn(shell.file, shell.args, { cwd: root, detached: platform !== "win32", stdio: ["ignore", "pipe", "pipe"], env: process.env, windowsHide: true });
     let timedOut = false;
     let aborted = false;
-    const timer = setTimeout(() => { timedOut = true; killGroup(child); }, timeoutS * 1000);
-    const onAbort = () => { aborted = true; killGroup(child); };
+    const timer = setTimeout(() => { timedOut = true; killGroup(child, platform); }, timeoutS * 1000);
+    const onAbort = () => { aborted = true; killGroup(child, platform); };
     if (signal) {
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });

package/package.json

@@ -1,10 +1,32 @@
 {
   "name": "agent-hub-runner",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "agent-hub 的电脑运行器：配对后让你的 bot 在这台电脑上读写授权目录里的文件、跑命令（跑命令要你在网页上批准）",
   "type": "module",
-  "bin": { "agent-hub-runner": "bin/agent-hub-runner.mjs" },
-  "files": ["runner.mjs", "ops.mjs", "edit.mjs", "changes.mjs", "autostart.mjs", "bin/agent-hub-runner.mjs", "README.md"],
-  "engines": { "node": ">=22" },
-  "scripts": { "test": "node --test" }
+  "bin": {
+    "agent-hub-runner": "bin/agent-hub-runner.mjs"
+  },
+  "files": [
+    "runner.mjs",
+    "ops.mjs",
+    "edit.mjs",
+    "changes.mjs",
+    "autostart.mjs",
+    "bin/agent-hub-runner.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cs1145994973/agent-hub-runner.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
 }

package/runner.mjs

@@ -23,11 +23,11 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline/promises";
-import { execFile } from "node:child_process";
+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 { autostartOff, autostartOffWindows, autostartOn, autostartOnWindows, autostartStatus, autostartStatusWindows, logFileFor, ONLY_MAC, otherAutostarts, runnerHome, truncateLogIfBig } from "./autostart.mjs";
 
 export const PROTOCOL_VERSION = 1;
 /** npm 包名，也是装好后的命令名 */
@@ -98,10 +98,19 @@ function checkNode() {
 
 export const PICK_PROMPT = "选择要授权给 bot 的文件夹";
 export const PICK_SCRIPT = `POSIX path of (choose folder with prompt "${PICK_PROMPT}")`;
+/** Windows 上的弹窗脚本：系统自带的 .NET 文件夹选择框，不需要任何额外安装。 */
+export const PICK_SCRIPT_WIN = [
+  "[Console]::OutputEncoding=[Text.Encoding]::UTF8",
+  "Add-Type -AssemblyName System.Windows.Forms",
+  "$d = New-Object System.Windows.Forms.FolderBrowserDialog",
+  `$d.Description = '${PICK_PROMPT}'`,
+  "$d.ShowNewFolderButton = $true",
+  "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Out.Write($d.SelectedPath) }",
+].join("\n");
 /** R640：这个 bot 在对照表里没有目录时，调用一律回这句。 */
 // @意图#R666(2026-10-29): 「右栏」是 R663 以前的位置，改成输入框下面「我的电脑」那一行（和服务器 devices.ts 的 NO_DIR 一字不差）
 export const NO_DIR = "还没给这个 bot 选目录，请在这个 bot 的私聊里点输入框下面「我的电脑」那一行，再点「选择目录」";
-export const PICK_ONLY_MAC = "只支持 Mac：选目录的窗口只在 Mac 上弹";
+export const PICK_ONLY_MAC = "只支持 Mac 和 Windows：选目录的窗口只在 Mac / Windows 上弹";
 /** R640：pair 带了 --dir 时的提示（不报错，照常配对，目录不用）。 */
 export const PAIR_DIR_IGNORED = "目录请连上后在每个 bot 的私聊里选（--dir 已不用，这次没用它）";
 
@@ -138,6 +147,43 @@ export function pickDirMac({ signal } = {}) {
 
 /** 检查授权目录：存在、换成真实路径、是目录、不是磁盘根目录。返回真实路径。 */
 // @意图#R640(2026-10-27): 每个 bot 选的目录都走这套检查
+
+/**
+ * Windows 上弹系统「选文件夹」窗口（.NET FolderBrowserDialog，系统自带，不用装任何东西）。
+ * 选了返回路径；点取消返回 null；signal 中止时 taskkill 关掉窗口并抛 AbortError；弹不出来（没有桌面会话）抛错。
+ */
+// @意图#R716(2026-11-02): Windows 客户是小白，不能要求装 Git Bash，也不能靠手填路径；弹窗用系统自带的 .NET 窗口
+export function pickDirWindows({ signal, spawn: spawnFn = spawn } = {}) {
+  return new Promise((resolve, reject) => {
+    const b64 = Buffer.from(PICK_SCRIPT_WIN + "\n", "utf16le").toString("base64");
+    // 带 -STA：FolderBrowserDialog 要求单线程公寓；不带 -NonInteractive：要的就是交互窗口
+    const child = spawnFn("powershell.exe", ["-NoProfile", "-STA", "-ExecutionPolicy", "Bypass", "-OutputFormat", "Text", "-EncodedCommand", b64], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    let out = "";
+    let err = "";
+    let settled = false;
+    const settle = (fn, v) => { if (!settled) { settled = true; signal?.removeEventListener("abort", onAbort); fn(v); } };
+    const killIt = () => {
+      if (child.pid) { try { spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }); } catch { /* 已退出 */ } }
+      try { child.kill("SIGKILL"); } catch { /* ignore */ }
+    };
+    const onAbort = () => { killIt(); settle(reject, Object.assign(new Error("已中止"), { name: "AbortError" })); };
+    if (signal) { if (signal.aborted) return onAbort(); signal.addEventListener("abort", onAbort, { once: true }); }
+    child.stdout?.on("data", (d) => { out += d.toString("utf8"); });
+    child.stderr?.on("data", (d) => { err += d.toString("utf8"); });
+    child.on("error", (e) => settle(reject, new Error(`弹不出选文件夹的窗口（${e?.message ?? e}）`)));
+    child.on("close", () => {
+      const picked = out.trim();
+      if (picked) return settle(resolve, picked);
+      const why = err.trim().split("\n")[0].trim();
+      if (why) return settle(reject, new Error(`弹不出选文件夹的窗口（${why}）`));
+      settle(resolve, null); // 点了取消：对话框没点确定，没有输出
+    });
+  });
+}
+
 // @意图#R639(2026-10-27): 配对时的 --dir 和网页上选的目录走同一套检查
 export async function checkDir(dir) {
   const real = await fs.realpath(path.resolve(dir)).catch(() => { throw new Error(`授权目录不存在：${dir}`); });
@@ -257,7 +303,7 @@ 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, pickDir = pickDirMac, platform = process.platform, file = configPath(), changes } = {}) {
+export function createSession(cfg, { log = say, platform = process.platform, pickDir = platform === "win32" ? pickDirWindows : pickDirMac, file = configPath(), changes } = {}) {
   let dirs = botDirsOf(cfg); // bot_id → 授权目录
   const jobs = new Map(); // 调用 id → AbortController
   const picks = new Map(); // 弹窗 id → AbortController
@@ -300,7 +346,7 @@ export function createSession(cfg, { log = say, pickDir = pickDirMac, platform =
     const { id } = msg;
     const bot = typeof msg.bot_id === "string" ? msg.bot_id : "";
     if (!bot) { send({ type: "dir_result", id, ok: false, error: "缺 bot_id" }); return; }
-    if (platform !== "darwin") { send({ type: "dir_result", id, ok: false, bot_id: bot, error: PICK_ONLY_MAC }); return; }
+    if (platform !== "darwin" && platform !== "win32") { send({ type: "dir_result", id, ok: false, bot_id: bot, error: PICK_ONLY_MAC }); return; }
     const ac = new AbortController();
     picks.set(id, ac);
     log(`网页上给 bot ${bot} 点了选择目录：请在弹出的窗口里选文件夹`);
@@ -353,7 +399,7 @@ export function createSession(cfg, { log = say, pickDir = pickDirMac, platform =
 // @意图#R640(2026-10-27): hello 报 bot→目录 对照表（bot_dirs），不再报单一 dir
 // @意图#R639(2026-10-27): 没目录也能连上；目录由 createSession 管（网页上选完马上生效），重连时 hello 带当前目录
 // @意图#R636(2026-10-27): 前台运行、心跳、执行工具调用；断线时杀掉正在跑的命令，重连后不重放
-export function startRunner(cfg, { log = say, retryMs = 2000, pickDir = pickDirMac, platform = process.platform, file = configPath(), background = process.env.AGENT_RUNNER_LAUNCHD === "1" } = {}) {
+export function startRunner(cfg, { log = say, retryMs = 2000, platform = process.platform, pickDir = platform === "win32" ? pickDirWindows : pickDirMac, file = configPath(), background = process.env.AGENT_RUNNER_LAUNCHD === "1" } = {}) {
   checkNode();
   let fails = 0;
   const session = createSession(cfg, { log, pickDir, platform, file });
@@ -432,10 +478,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 反复拉起）；
@@ -467,11 +520,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";
 }
 
@@ -497,11 +552,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;
 }
 
@@ -512,10 +572,11 @@ const usage = (prog) => `用法：
   ${prog} start              连上服务器（终端窗口别关；Ctrl-C 断开）
   ${prog} stop               停掉在跑的运行器
   ${prog} status             看配置、各 bot 的目录、在不在跑、开机自启
-  ${prog} autostart on|off|status   Mac 开机自启（on 也用来升级到新版本）
+  ${prog} set-dir <bot_id> <路径>   直接指定这个 bot 的授权目录（和网页上点「选择目录」走同一套检查；弹窗弹不出来时用）
+  ${prog} autostart on|off|status   开机自启（Mac 用 launchd，Windows 用计划任务；on 也用来升级到新版本）
   ${prog} uninstall [--purge]       关掉自启、删掉本地副本和日志（--purge 连配置一起删）
   ${prog} --version
-目录请连上后在网页上每个 bot 的私聊里点输入框下面「我的电脑」那一行选，Mac 上会弹窗让你选。`;
+目录请连上后在网页上每个 bot 的私聊里点输入框下面「我的电脑」那一行选，Mac / Windows 上会弹窗让你选。`;
 
 // @意图#R666(2026-10-29): pair 默认配完直接 start（--no-start 只配对）；配完按 decideAutostart 问 / 提示 / 开启开机自启，开了就不在前台跑；
 // 新命令 stop、autostart on|off|status、uninstall、--version；status 多显示在不在跑、版本、开机自启；用法里的命令按运行方式写（npx 时写 npx 写法）
@@ -557,15 +618,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;
     }
@@ -588,6 +655,26 @@ export async function main(argv, prog = progName(), deps = {}) {
     console.log(`已卸载：开机自启关了、本地副本和日志删了。${purge ? `配置也删了（${file}）；记得在网页「我的电脑」里点「断开」作废令牌。` : `配置留着（${file}）；连配置一起删：${prog} uninstall --purge`}`);
     return;
   }
+  if (a.cmd === "set-dir") {
+    // @意图#R716(2026-11-02): 不靠弹窗也能设目录（无桌面会话 / 弹不出来时应急），走和网页选目录同一套检查
+    const file = configPath();
+    const bot = a.positional[0];
+    const dir = a.positional[1];
+    if (!bot || !dir) { console.log(`用法：${prog} set-dir <bot_id> <路径>\n  bot_id 在网页这个 bot 的私聊里、输入框下面「我的电脑」那一行能看到`); process.exitCode = 1; return; }
+    let cfg;
+    try { cfg = loadConfig(file); } catch (e) { console.log(e?.message ?? String(e)); process.exitCode = 1; return; }
+    if (!cfg?.token) { console.log(`还没配对：${file} 里没有令牌。先在网页上配对：${prog} pair <配对码>@<服务器地址>`); process.exitCode = 1; return; }
+    let real;
+    try { real = await checkDir(dir); } catch (e) { console.log(e?.message ?? String(e)); process.exitCode = 1; return; }
+    cfg.bot_dirs = { ...botDirsOf(cfg), [bot]: real };
+    delete cfg.dir; // 老格式的单一 dir 不再写回
+    saveConfig(cfg, file);
+    const l = readLock(file);
+    const running = l && pidAlive(l.pid);
+    console.log(`已设：${bot} → ${real}`);
+    console.log(running ? `运行器正在跑（进程 ${l.pid}），重启后生效：${prog} stop && ${prog} start` : `配置文件：${file}`);
+    return;
+  }
   if (a.cmd === "status") {
     const file = configPath();
     const cfg = loadConfig(file);