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

package/tools/daemon-uninstall.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+/**
+ * pi-proactive 常驻助理：**跨平台一键卸载**（幂等 · 卸载后**零残留**）。
+ *
+ * 与 `tools/daemon-install.mjs` **对称**（同一份平台口径，见 `tools/daemon-common.mjs`）：
+ *   · macOS   → launchctl bootout/unload + 删 plist
+ *   · Linux   → systemctl --user disable --now + 删 unit
+ *   · Windows → schtasks /Delete /TN <任务> /F + taskkill + 删目录
+ *
+ * 做三件事（顺序固定）：
+ *   ① 停（宿主 + 残留进程；监督器也要杀，否则它会把值班进程再拉起来）
+ *   ② 删（单元 / 任务 / 日志 / socket / 状态目录）
+ *   ③ 校验（**逐项列出证据**；有残留即非零退出 —— 不谎报「卸载成功」）
+ *
+ * 保留（默认不删）：`<agentDir>/proactive/` 下的任务表 / 事件流 / 邮箱（**用户数据**，
+ * 删不删由用户决定；`--purge-data` 才连它一起删）。
+ *
+ * 用法：
+ *   node pi-proactive/tools/daemon-uninstall.mjs
+ *   node pi-proactive/tools/daemon-uninstall.mjs --agent-dir <dir>
+ *   node pi-proactive/tools/daemon-uninstall.mjs --label <label>      # launchd 单元标签
+ *   node pi-proactive/tools/daemon-uninstall.mjs --service-name <n>  # systemd 单元名
+ *   node pi-proactive/tools/daemon-uninstall.mjs --task-name <n>     # Windows 计划任务名
+ *   node pi-proactive/tools/daemon-uninstall.mjs --purge-data        # 连用户数据一起删
+ *   node pi-proactive/tools/daemon-uninstall.mjs --print-plan        # 只打印卸载计划（JSON）
+ *
+ * 退出码：0=卸载完成且无残留；1=有残留；2=环境不支持 / 用法错误。
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	defaultAgentDir,
+	defaultAgentId,
+	detectPlatform,
+	isAlive,
+	pkgRootFrom,
+	readJsonSafe,
+	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-uninstall.mjs [选项]
+
+  --agent-dir <dir>    agent 根目录（默认 ~/.pi/agent）
+  --agent-id <id>      稳定身份（缺省从 host.json 读）
+  --label <label>      launchd 单元标签（默认 com.pi-proactive.daemon）
+  --service-name <n>   systemd 单元名（默认 pi-proactive-daemon.service）
+  --task-name <n>      Windows 计划任务名（默认 PiProactiveDaemon）
+  --purge-data         连用户数据（任务表 / 事件流 / 邮箱）一起删
+  --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",
+		purgeData: 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 === "--purge-data") o.purgeData = 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 buildPlan(opts) {
+	const platform = detectPlatform(opts.platform);
+	const daemonDir = path.join(opts.agentDir, "proactive", "daemon");
+	const proactiveDir = path.join(opts.agentDir, "proactive");
+	const hostStateFile = path.join(daemonDir, "host.json");
+	const hbFile = path.join(daemonDir, "heartbeat.json");
+	const lockFile = path.join(daemonDir, "daemon.lock", "pid");
+	const hostState = readJsonSafe(hostStateFile);
+	const agentId = opts.agentId || (hostState && hostState.agentId) || defaultAgentId();
+	const socketInfo = resolveSocketPath(PKG_ROOT, agentId, opts.agentDir);
+
+	const steps = [];
+	let unitPath = "";
+
+	if (platform === "darwin") {
+		unitPath = path.join(os.homedir(), "Library", "LaunchAgents", `${opts.label}.plist`);
+		steps.push({
+			kind: "exec",
+			cmd: "launchctl",
+			args: ["bootout", `gui/${process.getuid?.() ?? 0}/${opts.label}`],
+			ignoreFail: true,
+		});
+		steps.push({ kind: "exec", cmd: "launchctl", args: ["unload", unitPath], ignoreFail: true });
+		steps.push({ kind: "rm", path: unitPath });
+	} else if (platform === "linux") {
+		unitPath = path.join(os.homedir(), ".config", "systemd", "user", opts.serviceName);
+		steps.push({ kind: "exec", cmd: "systemctl", args: ["--user", "disable", "--now", opts.serviceName], ignoreFail: true });
+		steps.push({ kind: "exec", cmd: "systemctl", args: ["--user", "reset-failed", opts.serviceName], ignoreFail: true });
+		steps.push({ kind: "rm", path: unitPath });
+		steps.push({ kind: "exec", cmd: "systemctl", args: ["--user", "daemon-reload"], ignoreFail: true });
+	} else if (platform === "win32") {
+		unitPath = `计划任务：${opts.taskName}`;
+		steps.push({ kind: "exec", cmd: "schtasks", args: ["/Delete", "/TN", opts.taskName, "/F"], ignoreFail: true });
+		// 杀残留进程（Windows 用 taskkill；unix 用 kill）
+		steps.push({
+			kind: "killPids",
+			cmd: platform === "win32" ? "taskkill" : "kill",
+			args: platform === "win32" ? ["/F", "/PID", "{pid}"] : ["-TERM", "{pid}"],
+			sources: [hbFile, lockFile],
+			ignoreFail: true,
+		});
+	} else {
+		throw new Error(`不支持的操作系统：${process.platform}（本卸载器支持 macOS / Linux / Windows）`);
+	}
+
+	if (platform !== "win32") {
+		steps.push({
+			kind: "killPids",
+			cmd: "kill",
+			args: ["-TERM", "{pid}"],
+			sources: [hbFile, lockFile],
+			ignoreFail: true,
+		});
+	}
+
+	steps.push({ kind: "rm", path: daemonDir });
+	if (socketInfo?.path) steps.push({ kind: "rm", path: socketInfo.path });
+	if (opts.purgeData) steps.push({ kind: "rm", path: proactiveDir });
+
+	return {
+		platform,
+		agentDir: opts.agentDir,
+		agentId,
+		label: opts.label,
+		serviceName: opts.serviceName,
+		taskName: opts.taskName,
+		hostKind: platform === "win32" ? "schtasks" : platform === "darwin" ? "launchd" : "systemd",
+		unitPath,
+		daemonDir,
+		proactiveDir,
+		hostStateFile,
+		heartbeatFile: hbFile,
+		socketPath: socketInfo?.path ?? "",
+		socketBytes: socketInfo?.bytes ?? -1,
+		purgeData: opts.purgeData,
+		steps,
+	};
+}
+
+/** 执行计划。 */
+function executePlan(plan) {
+	for (const step of plan.steps) {
+		switch (step.kind) {
+			case "rm":
+				fs.rmSync(step.path, { recursive: true, force: true });
+				break;
+			case "exec": {
+				const r = run(step.cmd, step.args, { cwd: plan.agentDir });
+				if (!r.ok && !step.ignoreFail) {
+					throw new Error(`${step.cmd} ${step.args.join(" ")} 失败：${r.stderr || r.stdout || r.error}`);
+				}
+				break;
+			}
+			case "killPids": {
+				// 从心跳（值班进程）与锁（监督器）里取 pid → 全杀掉
+				const pids = new Set();
+				for (const src of step.sources ?? []) {
+					try {
+						const raw = fs.readFileSync(src, "utf8").trim();
+						const pid = Number(raw.startsWith("{") ? (JSON.parse(raw).pid ?? 0) : raw) || 0;
+						if (pid > 0) pids.add(pid);
+					} catch {
+						/* 文件不在 → 没有 pid */
+					}
+				}
+				for (const pid of pids) {
+					if (!isAlive(pid)) continue;
+					const args = step.args.map((a) => (a === "{pid}" ? String(pid) : a));
+					run(step.cmd, args, { cwd: plan.agentDir });
+				}
+				break;
+			}
+			default:
+				throw new Error(`未知步骤：${step.kind}`);
+		}
+	}
+}
+
+/** 睡一会儿。 */
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+/** 校验零残留（逐项；有残留即非零退出）。 */
+async function verifyResidue(plan) {
+	const residue = [];
+	const check = (gone, what) => {
+		if (!gone) residue.push(what);
+	};
+	if (plan.platform === "darwin") {
+		const r = run("launchctl", ["print", `gui/${process.getuid?.() ?? 0}/${plan.label}`]);
+		check(!r.ok, `服务仍处于加载状态（launchctl print 成功）：${plan.label}`);
+	} else if (plan.platform === "linux") {
+		const r = run("systemctl", ["--user", "is-enabled", plan.serviceName]);
+		check(!r.ok, `服务仍处于 enabled 状态：${plan.serviceName}`);
+	} else {
+		const r = run("schtasks", ["/Query", "/TN", plan.taskName]);
+		check(!r.ok, `计划任务仍存在：${plan.taskName}`);
+	}
+	check(!fs.existsSync(plan.daemonDir), `状态/日志目录仍在：${plan.daemonDir}`);
+	if (plan.socketPath) check(!fs.existsSync(plan.socketPath), `socket 端点仍在：${plan.socketPath}`);
+	// 进程：心跳/锁里的 pid 必须已经不在
+	for (const src of [plan.heartbeatFile, path.join(plan.daemonDir, "daemon.lock", "pid")]) {
+		let pid = 0;
+		try {
+			const raw = fs.readFileSync(src, "utf8").trim();
+			pid = Number(raw.startsWith("{") ? (JSON.parse(raw).pid ?? 0) : raw) || 0;
+		} catch {
+			continue;
+		}
+		if (pid > 0 && isAlive(pid)) residue.push(`进程还在（pid=${pid}）`);
+	}
+	await sleep(500);
+	return residue;
+}
+
+// ------------------------------------------------------------------ 入口 ----
+
+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 {
+	executePlan(plan);
+	if (plan.purgeData) {
+		console.log(`已删用户数据（--purge-data）：${plan.proactiveDir}`);
+	} else {
+		console.log(`保留（未删）：${plan.proactiveDir} 下的任务表 / 事件流 / 邮箱（用户数据；--purge-data 才删）`);
+	}
+	const residue = await verifyResidue(plan);
+	if (residue.length > 0) {
+		console.error("结果：存在残留（见上方）");
+		for (const r of residue) console.error(`  · ${r}`);
+		console.error("手工清理命令（逐条执行即可清干净）：");
+		if (plan.platform === "darwin") {
+			console.error(`  launchctl bootout "gui/${process.getuid?.() ?? 0}/${plan.label}" || true`);
+			console.error(`  rm -f "${plan.unitPath}"`);
+		} else if (plan.platform === "linux") {
+			console.error(`  systemctl --user disable --now "${plan.serviceName}" || true`);
+			console.error(`  rm -f "${plan.unitPath}"`);
+		} else {
+			console.error(`  schtasks /Delete /TN "${plan.taskName}" /F || true`);
+		}
+		console.error(`  rm -rf "${plan.daemonDir}"`);
+		process.exit(1);
+	}
+	console.log("结果：卸载完成，无残留（exit 0）");
+	process.exit(0);
+} catch (e) {
+	console.error(String(e instanceof Error ? e.message : e));
+	process.exit(1);
+}