pi-proactive 0.2.0-beta.4 → 0.2.0-beta.6

package/tools/daemon-install.mjs

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+/**
+ * pi-proactive 常驻助理：**跨平台一键安装**（用户只跑这一条命令 → 看到「已常驻」）。
+ *
+ * 为什么有 .mjs 版：旧入口 `tools/daemon-install.sh` 是 **bash** → **Windows 用户装不了常驻助理**
+ * （见 `docs/project/windows-porting.md` §三①）。本文件是**同一条安装动作**的跨平台实现：
+ *
+ *   · macOS   → launchd（**复用 `daemon/launchd.plist` 模板**，模板本身不改）
+ *   · Linux   → systemd --user（**复用 `daemon/pi-proactive-daemon.service` 模板**）
+ *   · Windows → **计划任务**（`schtasks /Create /SC MINUTE /MO n ... /F`）
+ *
+ * 三条平台硬约束（Windows 尤其）：
+ *   ① **短路径**：端点（unix socket）路径上限 100B → agent 根与工作目录必须短；
+ *   ② **引号化**：Windows 路径常含空格（`C:\Program Files\nodejs\node.exe`）→ 逐个加引号；
+ *   ③ **幂等**：重复安装**更新**同名任务，**不产生第二份任务/进程**（`/Query` 先探测 + `/F` 覆盖）。
+ *
+ * 验证三证据（**缺一即失败，不谎报成功**）：
+ *   ① 进程在      —— 心跳文件里的 pid 活着
+ *   ② 心跳在更新  —— 两次读取的 ts 前进
+ *   ③ 宿主已加载  —— launchctl print / systemctl is-active / schtasks /Query
+ *
+ * 成本硬约束：装上**不等于花钱** —— 配置默认 `enabled=false` + 干跑。
+ *
+ * 用法：
+ *   node pi-proactive/tools/daemon-install.mjs
+ *   node pi-proactive/tools/daemon-install.mjs --agent-dir <dir>   # 指定 agent 根目录
+ *   node pi-proactive/tools/daemon-install.mjs --agent-id <id>     # 指定稳定身份
+ *   node pi-proactive/tools/daemon-install.mjs --label <label>     # launchd 单元标签
+ *   node pi-proactive/tools/daemon-install.mjs --service-name <n> # systemd 单元名
+ *   node pi-proactive/tools/daemon-install.mjs --task-name <n>    # Windows 计划任务名
+ *   node pi-proactive/tools/daemon-install.mjs --no-start         # 只写配置，不启动
+ *   node pi-proactive/tools/daemon-install.mjs --print-plan       # 只打印计划（JSON），不落任何副作用
+ *
+ * 退出码：0=已常驻（验证通过）；1=失败；2=环境不支持 / 用法错误。
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	MAX_SOCKET_PATH_BYTES,
+	buildWindowsTaskCommand,
+	chooseShortAgentDir,
+	defaultAgentDir,
+	defaultAgentId,
+	detectPlatform,
+	isAlive,
+	pkgRootFrom,
+	quoteSystemd,
+	readJsonSafe,
+	renderLaunchdPlist,
+	renderSystemdUnit,
+	resolveDaemonEntry,
+	resolveSocketPath,
+	run,
+} from "./daemon-common.mjs";
+
+const PKG_ROOT = pkgRootFrom(import.meta.url);
+
+const USAGE = `pi-proactive 常驻助理 · 跨平台安装器（macOS / Linux / Windows）
+
+  node pi-proactive/tools/daemon-install.mjs [选项]
+
+  --agent-dir <dir>    agent 根目录（默认 ~/.pi/agent）
+  --agent-id <id>      稳定身份（默认 employee#<主机名>#pi-proactive-daemon）
+  --label <label>      launchd 单元标签（默认 com.pi-proactive.daemon）
+  --service-name <n>   systemd 单元名（默认 pi-proactive-daemon.service）
+  --task-name <n>      Windows 计划任务名（默认 PiProactiveDaemon）
+  --minutes <n>        Windows 计划任务周期（分钟，默认 1）
+  --no-start           只写配置，不启动
+  --print-plan         只打印安装计划（JSON），不产生任何副作用
+  -h, --help           本帮助
+`;
+
+/** 解析命令行。 */
+function parseArgs(argv) {
+	const o = {
+		agentDir: defaultAgentDir(),
+		agentId: "",
+		label: process.env.PI_PROACTIVE_DAEMON_LABEL || "com.pi-proactive.daemon",
+		serviceName: process.env.PI_PROACTIVE_DAEMON_SERVICE || "pi-proactive-daemon.service",
+		taskName: process.env.PI_PROACTIVE_DAEMON_TASK || "PiProactiveDaemon",
+		minutes: 1,
+		noStart: false,
+		printPlan: false,
+		platform: "",
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		const next = () => {
+			const v = argv[++i];
+			if (v === undefined) {
+				console.error(`参数 ${a} 缺值`);
+				process.exit(2);
+			}
+			return v;
+		};
+		if (a === "--agent-dir") o.agentDir = path.resolve(next());
+		else if (a === "--agent-id") o.agentId = next();
+		else if (a === "--label") o.label = next();
+		else if (a === "--service-name") o.serviceName = next();
+		else if (a === "--task-name") o.taskName = next();
+		else if (a === "--minutes") o.minutes = Math.max(1, Number(next()) || 1);
+		else if (a === "--no-start") o.noStart = true;
+		else if (a === "--print-plan") o.printPlan = true;
+		else if (a === "--platform") o.platform = next();
+		else if (a === "-h" || a === "--help") {
+			console.log(USAGE);
+			process.exit(0);
+		} else {
+			console.error(`未知参数：${a}`);
+			process.exit(2);
+		}
+	}
+	return o;
+}
+
+/** 值班配置（**不存在才写**；不覆盖用户已有配置）。 */
+function daemonConfigJson(agentId) {
+	return `${JSON.stringify(
+		{
+			version: "v1",
+			enabled: false, // 装上不等于花钱
+			agentId,
+			dryRun: true,
+			budget: {
+				maxActionsPerHour: 6,
+				maxActionsPerDay: 40,
+				maxTokenUnitsPerDay: 200000,
+				maxLimitedActionsPerDay: 20,
+				degradeToObserveWhenExhausted: true,
+			},
+			permissions: { defaultTier: "limited" },
+			tickIntervalMs: 30000,
+			handoverHour: 8,
+			staleSocketMs: 3600000,
+			staleExecutionMs: 3600000,
+			contact: {
+				enabled: true,
+				target: "auto",
+				minIntervalMs: 3600000,
+				maxPerDay: 8,
+				deviceNotify: "fallback",
+			},
+			host: { hostKind: "auto" },
+		},
+		null,
+		2,
+	)}\n`;
+}
+
+/**
+ * 生成安装计划（**纯计算**：不落任何副作用 → `--print-plan` 与真实安装同源）。
+ */
+function buildPlan(opts) {
+	const platform = detectPlatform(opts.platform);
+	const node = process.execPath;
+	const runner = path.join(PKG_ROOT, "daemon", "run-daemon.mjs");
+	const daemon = resolveDaemonEntry(PKG_ROOT);
+	if (!daemon) {
+		throw new Error("找不到常驻入口（试过 src/daemon.ts、build/src/daemon.js）");
+	}
+	const agentId = opts.agentId || defaultAgentId();
+
+	// ---- agent 根：Windows 必须**短**（端点路径 < 100B）----
+	let agentDir = opts.agentDir;
+	let socketInfo = resolveSocketPath(PKG_ROOT, agentId, agentDir);
+	if (platform === "win32") {
+		// 候选根（按优先级）：用户指定 → 可覆盖的回退根 → %LOCALAPPDATA%\pp → C:\pp-agent
+		// （Windows 上 agent 根必须**短**：端点路径上限 100B；C:\ 根最短，但可能没有写权限）
+		const fallback =
+			process.env.PI_PROACTIVE_WINDOWS_FALLBACK_ROOT ||
+			path.join(os.homedir(), "AppData", "Local", "pp");
+		const candidates = [opts.agentDir, fallback, "C:\\pp-agent"];
+		const picked = chooseShortAgentDir(candidates, (d) => {
+			const s = resolveSocketPath(PKG_ROOT, agentId, d);
+			return s ? s.bytes : null;
+		});
+		if (!picked) {
+			throw new Error(
+				`找不到端点路径 < ${MAX_SOCKET_PATH_BYTES}B 的 agent 根（试过 ${candidates.join("、")}）` +
+					"→ 请用 --agent-dir 指定一个更短的目录",
+			);
+		}
+		agentDir = picked.dir;
+		socketInfo = resolveSocketPath(PKG_ROOT, agentId, agentDir);
+	}
+
+	const logDir = path.join(agentDir, "proactive", "daemon");
+	const daemonDir = path.join(agentDir, "proactive", "daemon");
+	const configFile = path.join(agentDir, "proactive", "daemon.json");
+	const hostStateFile = path.join(daemonDir, "host.json");
+	// Windows 的工作目录用**短** agent 根；unix 侧用包根（与旧行为一致）。
+	const workDir = platform === "win32" ? agentDir : PKG_ROOT;
+
+	const runnerArgs = [
+		"--agent-dir",
+		agentDir,
+		"--agent-id",
+		agentId,
+		"--entry",
+		daemon.entry,
+		"--log-dir",
+		logDir,
+		"--node",
+		node,
+		"--work-dir",
+		workDir,
+	];
+
+	const hostKind = platform === "win32" ? "schtasks" : platform === "darwin" ? "launchd" : "systemd";
+	const steps = [
+		{ kind: "mkdir", path: agentDir },
+		{ kind: "mkdir", path: daemonDir },
+		{ kind: "writeIfAbsent", path: configFile, content: daemonConfigJson(agentId) },
+	];
+
+	let unitPath = "";
+	if (platform === "darwin") {
+		unitPath = path.join(os.homedir(), "Library", "LaunchAgents", `${opts.label}.plist`);
+		const template = fs.readFileSync(path.join(PKG_ROOT, "daemon", "launchd.plist"), "utf8");
+		const content = renderLaunchdPlist(template, {
+			label: opts.label,
+			pkgRoot: PKG_ROOT,
+			agentId,
+			logDir,
+			runner,
+			programArgs: [node, runner, ...runnerArgs],
+		});
+		steps.push({ kind: "write", path: unitPath, content });
+		if (!opts.noStart) {
+			steps.push({
+				kind: "exec",
+				cmd: "launchctl",
+				args: ["bootout", `gui/${process.getuid?.() ?? 0}/${opts.label}`],
+				ignoreFail: true,
+			});
+			// bootout 是**异步**的：不等它真正从域里消失就 bootstrap，会出现
+			// 「bootstrap 返回 0，但随后被挂起的 bootout 摘掉」→ 单元根本没加载（重启即失效）。
+			steps.push({
+				kind: "waitGone",
+				cmd: "launchctl",
+				args: ["print", `gui/${process.getuid?.() ?? 0}/${opts.label}`],
+				timeoutMs: 10_000,
+			});
+			steps.push({
+				kind: "execFallback",
+				attempts: [
+					{ cmd: "launchctl", args: ["bootstrap", `gui/${process.getuid?.() ?? 0}`, unitPath] },
+					{ cmd: "launchctl", args: ["load", "-w", unitPath] },
+					{ cmd: "launchctl", args: ["bootstrap", `gui/${process.getuid?.() ?? 0}`, unitPath] },
+				],
+			});
+		}
+	} else if (platform === "linux") {
+		unitPath = path.join(os.homedir(), ".config", "systemd", "user", opts.serviceName);
+		const template = fs.readFileSync(path.join(PKG_ROOT, "daemon", "pi-proactive-daemon.service"), "utf8");
+		const execStart = [node, runner, ...runnerArgs].map(quoteSystemd).join(" ");
+		const content = renderSystemdUnit(template, {
+			pkgRoot: PKG_ROOT,
+			agentId,
+			workDir,
+			execStart,
+		});
+		steps.push({ kind: "write", path: unitPath, content });
+		if (!opts.noStart) {
+			steps.push({ kind: "exec", cmd: "systemctl", args: ["--user", "daemon-reload"] });
+			steps.push({ kind: "exec", cmd: "systemctl", args: ["--user", "enable", "--now", opts.serviceName] });
+		}
+	} else if (platform === "win32") {
+		unitPath = `计划任务：${opts.taskName}`;
+		const tr = buildWindowsTaskCommand({ node, runner, extraArgs: runnerArgs });
+		// 幂等：先探测同名任务是否已存在 → 存在就是**更新**（/F 覆盖），绝不建第二个。
+		steps.push({ kind: "exec", cmd: "schtasks", args: ["/Query", "/TN", opts.taskName], ignoreFail: true, probe: "exists" });
+		steps.push({
+			kind: "exec",
+			cmd: "schtasks",
+			args: [
+				"/Create",
+				"/TN",
+				opts.taskName,
+				"/TR",
+				tr,
+				"/SC",
+				"MINUTE",
+				"/MO",
+				String(opts.minutes),
+				"/F",
+			],
+		});
+		if (!opts.noStart) {
+			steps.push({ kind: "exec", cmd: "schtasks", args: ["/Run", "/TN", opts.taskName], ignoreFail: true });
+		}
+		steps.push({ kind: "exec", cmd: "schtasks", args: ["/Query", "/TN", opts.taskName] });
+	} else {
+		throw new Error(`不支持的操作系统：${process.platform}（本安装器支持 macOS / Linux / Windows）`);
+	}
+
+	steps.push({
+		kind: "write",
+		path: hostStateFile,
+		content: `${JSON.stringify(
+			{
+				hostKind,
+				label: opts.taskName,
+				workspaceId: "",
+				paneId: "",
+				unitPath,
+				agentId,
+				installedAt: Date.now(),
+			},
+			null,
+			2,
+		)}\n`,
+	});
+
+	return {
+		platform,
+		agentDir,
+		workDir,
+		pkgRoot: PKG_ROOT,
+		node,
+		runner,
+		daemonEntry: daemon.entry,
+		agentId,
+		label: opts.label,
+		serviceName: opts.serviceName,
+		taskName: opts.taskName,
+		minutes: opts.minutes,
+		hostKind,
+		unitPath,
+		logDir,
+		configFile,
+		hostStateFile,
+		socketPath: socketInfo?.path ?? "",
+		socketBytes: socketInfo?.bytes ?? -1,
+		noStart: opts.noStart,
+		steps,
+	};
+}
+
+/** 执行计划（每步都可判定失败 → 不谎报成功）。 */
+async function executePlan(plan) {
+	for (const step of plan.steps) {
+		switch (step.kind) {
+			case "mkdir":
+				fs.mkdirSync(step.path, { recursive: true });
+				break;
+			case "write": {
+				fs.mkdirSync(path.dirname(step.path), { recursive: true });
+				fs.writeFileSync(step.path, step.content);
+				break;
+			}
+			case "writeIfAbsent":
+				if (!fs.existsSync(step.path)) {
+					fs.mkdirSync(path.dirname(step.path), { recursive: true });
+					fs.writeFileSync(step.path, step.content);
+					console.log(`已写值班配置（enabled=false · 默认干跑）：${step.path}`);
+				} else {
+					console.log(`值班配置已存在，保持不动：${step.path}`);
+				}
+				break;
+			case "exec": {
+				const r = run(step.cmd, step.args, { cwd: plan.workDir });
+				if (!r.ok && !step.ignoreFail) {
+					throw new Error(`${step.cmd} ${step.args.join(" ")} 失败：${r.stderr || r.stdout || r.error}`);
+				}
+				break;
+			}
+			case "waitGone": {
+				// 等到目标从宿主里消失（最多 timeoutMs）
+				const deadline = Date.now() + (step.timeoutMs ?? 10_000);
+				while (Date.now() < deadline) {
+					const r = run(step.cmd, step.args, { cwd: plan.workDir });
+					if (!r.ok) break;
+					await sleep(200);
+				}
+				break;
+			}
+			case "execFallback": {
+				const last = step.attempts[step.attempts.length - 1];
+				for (const attempt of step.attempts) {
+					const r = run(attempt.cmd, attempt.args, { cwd: plan.workDir });
+					if (r.ok) break;
+					if (attempt === last) {
+						throw new Error(`${last.cmd} ${last.args.join(" ")} 失败：${last.stderr || last.stdout || last.error}`);
+					}
+				}
+				break;
+			}
+			default:
+				throw new Error(`未知步骤：${step.kind}`);
+		}
+	}
+}
+
+/** 睡一会儿。 */
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+/** 验证三证据（进程在 + 心跳在更新 + 宿主已加载）。 */
+async function verify(plan) {
+	const hbFile = path.join(plan.agentDir, "proactive", "daemon", "heartbeat.json");
+	let ts1 = 0;
+	let pid = 0;
+	// 等一个**活着的**值班进程写下的心跳（旧心跳可能来自刚被 bootout 杀掉的进程 → 不能算数）
+	for (let i = 0; i < 240; i++) {
+		const hb = readJsonSafe(hbFile);
+		if (hb && typeof hb.ts === "number" && isAlive(hb.pid)) {
+			ts1 = hb.ts;
+			pid = Number(hb.pid) || 0;
+			break;
+		}
+		await sleep(500);
+	}
+	if (!ts1) {
+		const tail = (f) => {
+			try {
+				return fs.readFileSync(f, "utf8").split("\n").slice(-20).join("\n");
+			} catch {
+				return "";
+			}
+		};
+		throw new Error(
+			`验证失败：没有看到心跳文件（${hbFile}）→ 助理没起来\n` +
+				`---- daemon.err.log（尾部）----\n${tail(path.join(plan.logDir, "daemon.err.log"))}\n` +
+				`---- daemon.out.log（尾部）----\n${tail(path.join(plan.logDir, "daemon.out.log"))}`,
+		);
+	}
+	if (!isAlive(pid)) throw new Error(`验证失败：心跳里的进程不在（pid=${pid || "?"}）→ 助理没起来`);
+
+	let ts2 = ts1;
+	for (let i = 0; i < 60 && ts2 === ts1; i++) {
+		await sleep(500);
+		ts2 = Number(readJsonSafe(hbFile)?.ts ?? ts1);
+	}
+	if (ts2 === ts1) throw new Error(`验证失败：心跳没有更新（ts 一直是 ${ts1}）→ 助理没在跑`);
+
+	// 宿主已加载
+	if (plan.platform === "darwin") {
+		const r = run("launchctl", ["print", `gui/${process.getuid?.() ?? 0}/${plan.label}`]);
+		if (!r.ok) throw new Error(`验证失败：LaunchAgent 没加载（${plan.unitPath}）→ 助理没在跑`);
+	} else if (plan.platform === "linux") {
+		const r = run("systemctl", ["--user", "is-active", plan.serviceName]);
+		if (!r.ok) throw new Error(`验证失败：systemd 单元没在跑（${plan.unitPath}）→ 助理没在跑`);
+	} else {
+		const r = run("schtasks", ["/Query", "/TN", plan.taskName]);
+		if (!r.ok) throw new Error(`验证失败：计划任务不存在（${plan.taskName}）→ 助理没在跑`);
+	}
+	return { pid, ts1, ts2 };
+}
+
+// ------------------------------------------------------------------ 入口 ----
+
+const opts = parseArgs(process.argv.slice(2));
+let plan;
+try {
+	plan = buildPlan(opts);
+} catch (e) {
+	console.error(String(e instanceof Error ? e.message : e));
+	process.exit(2);
+}
+
+if (opts.printPlan) {
+	process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+	process.exit(0);
+}
+
+try {
+	await executePlan(plan);
+	if (opts.noStart) {
+		console.log(`已写配置（--no-start · 未启动）：${plan.unitPath}`);
+		process.exit(0);
+	}
+	const v = await verify(plan);
+	console.log("已常驻");
+	console.log(`  · 宿主：${plan.hostKind}`);
+	console.log(`  · 单元：${plan.unitPath}`);
+	console.log(`  · 进程：pid=${v.pid} 在跑`);
+	console.log(`  · 心跳：${path.join(plan.agentDir, "proactive", "daemon", "heartbeat.json")}（ts ${v.ts1} → ${v.ts2} 在前进）`);
+	console.log(`  · 端点路径：${plan.socketPath}（${plan.socketBytes}B ≤ ${MAX_SOCKET_PATH_BYTES}B）`);
+	console.log("  · 想关掉：node pi-proactive/tools/daemon-uninstall.mjs");
+	console.log("提醒：默认 enabled=false + 干跑 → 装上不会花钱；要真跑请开开关与预算上限。");
+	process.exit(0);
+} catch (e) {
+	console.error(String(e instanceof Error ? e.message : e));
+	process.exit(1);
+}