@wemind/cli 1.1.0 → 1.1.1

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import crypto, { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
 import os from "node:os";
 import { spawn, spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 //#region ../wechat-ilink-core/dist/config.js
 /**
 * iLink 应用标识。
@@ -13,6 +13,54 @@ import { fileURLToPath } from "node:url";
 */
 const ILINK_APP_ID = process.env.ILINK_APP_ID?.trim() || "bot";
 //#endregion
+//#region ../wechat-ilink-core/dist/pkg-version.js
+/**
+* 读取「调用方所在包」自己的版本号（从它的 package.json）。
+*
+* ## 为什么放在 core
+* `@wemind/wechat-mcp` 与 `@wemind/cli` 都需要上报自己的版本，两边的「向上查找 package.json」
+* 逻辑完全一样。放 core 里只维护一份；两个消费方各留一个 3 行的薄适配层。
+*
+* ## 为什么必须由调用方传入位置（`callerUrl`）
+* `import.meta.url` 指向**当前文件**，而当前文件在 core 里——用它去向上找，命中的会是 core
+* 自己的 `package.json`（或更上层的仓库根），**永远拿不到调用方的版本**。
+* 实测过：在 daemon 语境里直接复用 mcp 的同类实现，得到的是 mcp 的版本（1.0.4）而不是
+* daemon 的（1.1.0），且不会报错——静默给错值是最坏的一类 bug。
+* 所以这里强制由调用方传 `import.meta.url`，函数从**那个位置**向上找。
+*
+* ## 为什么还要 expectedName
+* 只按「最近的 package.json」查找并不可靠：在 monorepo 里向上找，可能先撞到 core 的、
+* 也可能撞到仓库根的。用 `name` 精确匹配，命中不了就返回 `undefined`（安全失败），
+* 由调用方决定兜底值，绝不静默返回别人的版本。
+*
+* ## 打包后仍然有效
+* 两个消费方都用 tsdown 把 core **内联**进单文件产物。由于查找起点是调用方的
+* `import.meta.url`（打包后是 `dist/cli.js` / `dist/index.js`），向上第一个带
+* `name` 匹配的 `package.json` 正是该消费方自己的——dev（`src/`）与产物（`dist/`）两种布局都成立。
+*
+* @param callerUrl 调用方模块的 `import.meta.url`
+* @param expectedName 期望的包名（即调用方自己 package.json 的 `name`）
+* @returns 匹配到的 `version`；找不到返回 `undefined`
+*/
+function readOwnVersion(callerUrl, expectedName) {
+	if (!callerUrl || !expectedName) return void 0;
+	let dir;
+	try {
+		dir = path.dirname(fileURLToPath(callerUrl));
+	} catch {
+		return;
+	}
+	const { root } = path.parse(dir);
+	while (dir && dir !== root) {
+		const candidate = path.join(dir, "package.json");
+		try {
+			const p = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+			if (p.name === expectedName && p.version) return p.version;
+		} catch {}
+		dir = path.dirname(dir);
+	}
+}
+//#endregion
 //#region ../wechat-ilink-core/dist/api/types.js
 /**
 * iLink Bot API 协议类型（镜像服务端 proto：GetUpdatesReq/Resp、WeixinMessage、SendMessageReq 等）。
@@ -144,8 +192,11 @@ var ILinkError = class extends Error {
 };
 //#endregion
 //#region ../wechat-ilink-core/dist/api/client.js
-const DEFAULT_LONG_POLL_TIMEOUT_MS = 35e3;
+/** 普通 RPC 的超时（send/typing/config/upload/notify）。 */
 const DEFAULT_API_TIMEOUT_MS = 15e3;
+/** 消息长轮询（getupdates）超时。 */
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35e3;
+/** 扫码状态长轮询（get_qrcode_status）超时。与消息长轮询语义不同，故分开命名。 */
 const QR_LONG_POLL_TIMEOUT_MS = 35e3;
 const ILINK_CLIENT_VERSION = process.env.ILINK_CLIENT_VERSION?.trim() || "2.4.3";
 const CHANNEL_VERSION = ILINK_CLIENT_VERSION;
@@ -183,6 +234,7 @@ function buildHeaders(opts) {
 	if (opts.token?.trim()) headers.Authorization = `Bearer ${opts.token.trim()}`;
 	return headers;
 }
+/** POST 一个 iLink CGI，返回原始响应体。HTTP 非 2xx 抛错；响应体是否是 JSON 由调用方决定。 */
 async function apiFetch(params) {
 	const base = ensureTrailingSlash(params.baseUrl);
 	const url = new URL(params.endpoint, base);
@@ -191,7 +243,7 @@ async function apiFetch(params) {
 		body: params.body
 	});
 	const controller = new AbortController();
-	const t = setTimeout(() => controller.abort(), params.timeoutMs);
+	const timer = setTimeout(() => controller.abort(), params.timeoutMs);
 	try {
 		const res = await fetch(url.toString(), {
 			method: "POST",
@@ -200,12 +252,19 @@ async function apiFetch(params) {
 			signal: controller.signal
 		});
 		const rawText = await res.text();
-		clearTimeout(t);
-		if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`);
+		if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText.slice(0, 500)}`);
 		return rawText;
-	} catch (err) {
-		clearTimeout(t);
-		throw err;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** 宽松解析：空响应体或非 JSON 返回 null（部分接口成功时无响应体）。 */
+function tryParseJson(raw) {
+	if (!raw) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
 	}
 }
 /** 防御性解析 API JSON 响应：失败抛带 label 与响应片段的清晰错误，而非裸 SyntaxError（畸形/代理 HTML/截断响应不致以晦涩错误打断调用方）。 */
@@ -216,6 +275,15 @@ function parseJsonResp(raw, label) {
 		throw new Error(`${label}: response not JSON (${raw.slice(0, 120)})`);
 	}
 }
+/**
+* iLink 即使 HTTP 200 也可能在响应体返回非 0 ret/errcode 表示失败。语义见 error-codes.ts：
+*   ret=-2 参数错误（最常见 context_token 失效/不匹配）；errcode=-14 会话过期。
+* 不校验会导致「假成功」——消息其实没送达。仅在明确拿到非 0 错误码时抛 ILinkError（携带码+分类，供上层按类型处理）。
+*/
+function throwIfErrorCode(op, resp) {
+	const code = resp?.ret ?? resp?.errcode;
+	if (code !== void 0 && code !== 0) throw new ILinkError(op, code, resp?.errmsg);
+}
 function buildBaseInfo() {
 	return { channel_version: CHANNEL_VERSION };
 }
@@ -243,7 +311,7 @@ async function getUpdates(params) {
 	}
 }
 async function sendMessage(params) {
-	const raw = await apiFetch({
+	throwIfErrorCode("sendMessage", tryParseJson(await apiFetch({
 		baseUrl: params.baseUrl,
 		endpoint: "ilink/bot/sendmessage",
 		body: JSON.stringify({
@@ -253,19 +321,11 @@ async function sendMessage(params) {
 		token: params.token,
 		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
 		label: "sendMessage"
-	});
-	let code;
-	let errmsg;
-	try {
-		const resp = raw ? JSON.parse(raw) : null;
-		code = resp?.ret ?? resp?.errcode;
-		errmsg = resp?.errmsg;
-	} catch {}
-	if (code !== void 0 && code !== 0) throw new ILinkError("sendMessage", code, errmsg);
+	})));
 }
 /** 取 CDN 上传地址（发图/发文件用）。返回 upload_full_url 或 upload_param。 */
 async function getUploadUrl(params) {
-	return parseJsonResp(await apiFetch({
+	const resp = parseJsonResp(await apiFetch({
 		baseUrl: params.baseUrl,
 		endpoint: "ilink/bot/getuploadurl",
 		body: JSON.stringify({
@@ -283,6 +343,8 @@ async function getUploadUrl(params) {
 		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
 		label: "getUploadUrl"
 	}), "getUploadUrl");
+	throwIfErrorCode("getUploadUrl", resp);
+	return resp;
 }
 async function fetchQRCode(apiBaseUrl) {
 	return parseJsonResp(await apiFetch({
@@ -303,26 +365,21 @@ async function pollQRStatus(apiBaseUrl, qrcode) {
 			headers: buildCommonHeaders(),
 			signal: controller.signal
 		});
-		if (!response.ok) {
-			const body = await response.text().catch(() => "(unreadable)");
-			clearTimeout(timer);
-			throw new Error(`Failed to poll QR status: ${response.status} ${response.statusText} ${body}`);
-		}
 		const text = await response.text();
-		clearTimeout(timer);
+		if (!response.ok) throw new Error(`pollQRStatus ${response.status} ${response.statusText} ${text.slice(0, 500)}`);
 		return parseJsonResp(text, "pollQRStatus");
 	} catch (err) {
-		clearTimeout(timer);
 		if (err instanceof Error && err.name === "AbortError") return { status: "wait" };
 		throw err;
+	} finally {
+		clearTimeout(timer);
 	}
 }
 function generateId(prefix) {
 	return `${prefix}:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
 }
-const DEFAULT_CONFIG_TIMEOUT_MS = 15e3;
 async function getConfig(params) {
-	return parseJsonResp(await apiFetch({
+	const resp = parseJsonResp(await apiFetch({
 		baseUrl: params.baseUrl,
 		endpoint: "ilink/bot/getconfig",
 		body: JSON.stringify({
@@ -331,12 +388,14 @@ async function getConfig(params) {
 			base_info: buildBaseInfo()
 		}),
 		token: params.token,
-		timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+		timeoutMs: DEFAULT_API_TIMEOUT_MS,
 		label: "getConfig"
 	}), "getConfig");
+	throwIfErrorCode("getConfig", resp);
+	return resp;
 }
 async function sendTyping(params) {
-	await apiFetch({
+	throwIfErrorCode("sendTyping", tryParseJson(await apiFetch({
 		baseUrl: params.baseUrl,
 		endpoint: "ilink/bot/sendtyping",
 		body: JSON.stringify({
@@ -344,39 +403,36 @@ async function sendTyping(params) {
 			base_info: buildBaseInfo()
 		}),
 		token: params.token,
-		timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
+		timeoutMs: DEFAULT_API_TIMEOUT_MS,
 		label: "sendTyping"
-	});
+	})));
 }
-/** 通知服务端该 bot 客户端上线（best-effort，失败不阻断）。 */
-async function notifyStart(params) {
+/**
+* 上线/下线通知的共同实现。
+* best-effort：失败只记日志、绝不抛出——通知失败不应阻断登录/登出主流程。
+* 也正因为要吞错，这里刻意**不校验**响应体的 ret/errcode。
+*/
+async function notifyLifecycle(op, endpoint, params) {
 	try {
 		await apiFetch({
 			baseUrl: params.baseUrl,
-			endpoint: "ilink/bot/msg/notifystart",
+			endpoint,
 			body: JSON.stringify({ base_info: buildBaseInfo() }),
 			token: params.token,
-			timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
-			label: "notifyStart"
+			timeoutMs: DEFAULT_API_TIMEOUT_MS,
+			label: op
 		});
 	} catch (err) {
-		console.error(`[wemind/wechat-ilink-core/ilink] notifyStart failed (ignored, best-effort): ${String(err)}`);
+		console.error(`[wemind/wechat-ilink-core/ilink] ${op} failed (ignored, best-effort): ${String(err)}`);
 	}
 }
+/** 通知服务端该 bot 客户端上线（best-effort，失败不阻断）。 */
+async function notifyStart(params) {
+	await notifyLifecycle("notifyStart", "ilink/bot/msg/notifystart", params);
+}
 /** 通知服务端该 bot 客户端下线（best-effort，失败不阻断）。 */
 async function notifyStop(params) {
-	try {
-		await apiFetch({
-			baseUrl: params.baseUrl,
-			endpoint: "ilink/bot/msg/notifystop",
-			body: JSON.stringify({ base_info: buildBaseInfo() }),
-			token: params.token,
-			timeoutMs: DEFAULT_CONFIG_TIMEOUT_MS,
-			label: "notifyStop"
-		});
-	} catch (err) {
-		console.error(`[wemind/wechat-ilink-core/ilink] notifyStop failed (ignored, best-effort): ${String(err)}`);
-	}
+	await notifyLifecycle("notifyStop", "ilink/bot/msg/notifystop", params);
 }
 //#endregion
 //#region ../wechat-ilink-core/dist/api/transport-errors.js
@@ -559,6 +615,12 @@ function setLabel(key, label) {
 */
 const ACCOUNT_KEY = process.env.WECHAT_ACCOUNT?.trim() || "default";
 const DATA_DIR = process.env.WECHAT_DATA_DIR?.trim() || path.join(WEMIND_ROOT, ACCOUNT_KEY);
+/** 持久化文件名：集中在此，避免各处拼字符串写错（load/save/clear 必须指向同一份）。 */
+const FILES = {
+	account: "account.json",
+	state: "state.json",
+	qrState: "qr_login.json"
+};
 function ensureDir(dir) {
 	fs.mkdirSync(dir, { recursive: true });
 }
@@ -566,8 +628,9 @@ function readJson$2(filePath) {
 	let raw;
 	try {
 		raw = fs.readFileSync(filePath, "utf-8");
-	} catch {
-		return null;
+	} catch (e) {
+		if (isNotFound(e)) return null;
+		throw e;
 	}
 	try {
 		return JSON.parse(raw);
@@ -579,28 +642,63 @@ function readJson$2(filePath) {
 		return null;
 	}
 }
+function isNotFound(err) {
+	return err?.code === "ENOENT";
+}
 /** 原子写：先写临时文件再 rename 覆盖（同盘 rename 原子），避免写途崩溃/并发产生半截损坏文件。 */
 function writeJson(filePath, data) {
 	ensureDir(path.dirname(filePath));
 	const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-	fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-	fs.renameSync(tmp, filePath);
+	try {
+		fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+		fs.renameSync(tmp, filePath);
+	} catch (e) {
+		try {
+			fs.rmSync(tmp, { force: true });
+		} catch {}
+		throw e;
+	}
 }
-function loadAccount() {
-	return readJson$2(path.join(DATA_DIR, "account.json"));
+function loadAccount(dir = DATA_DIR) {
+	return readJson$2(path.join(dir, FILES.account));
 }
-function loadState() {
-	return readJson$2(path.join(DATA_DIR, "state.json")) ?? {
+let warnedWinPerms = false;
+/**
+* 把登录凭证写进**指定**目录的 `account.json`（原子写 + POSIX 600 + Windows 一次性明文告警）。
+*
+* 为什么要有 dir 参数：`wemind login` 是先写到暂存目录 `.staging/`、扫码确认后才 rename 成账号目录。
+* 那条路径以前直接 `fs.writeFileSync`，于是「POSIX 600 / Windows 告警」这两条安全承诺在最推荐
+* 的登录入口上不成立（chmod 也漏了）。改成复用本函数，两条路径行为一致。
+* rename 同盘保留权限位，所以先写好再归档不会丢 600。
+*/
+function saveAccountTo(dir, account) {
+	const file = path.join(dir, FILES.account);
+	writeJson(file, account);
+	if (process.platform === "win32") {
+		if (!warnedWinPerms) {
+			warnedWinPerms = true;
+			console.error(`[wemind/wechat-ilink-core] warning: ${file} stores the bot token in plaintext; Windows cannot restrict it via chmod. Protect ${dir} with folder permissions or disk encryption.`);
+		}
+	} else try {
+		fs.chmodSync(file, 384);
+	} catch {}
+}
+/** 空状态：唯一来源，避免 loadState/resetState 各写一份、将来加字段时漏改。 */
+function emptyState() {
+	return {
 		updatesBuf: "",
 		contextTokens: {},
 		lastMessageId: 0
 	};
 }
-function saveState(state) {
-	writeJson(path.join(DATA_DIR, "state.json"), state);
+function loadState(dir = DATA_DIR) {
+	return readJson$2(path.join(dir, FILES.state)) ?? emptyState();
 }
-function saveQrState(state) {
-	writeJson(path.join(DATA_DIR, "qr_login.json"), state);
+function saveState(state, dir = DATA_DIR) {
+	writeJson(path.join(dir, FILES.state), state);
+}
+function saveQrState(state, dir = DATA_DIR) {
+	writeJson(path.join(dir, FILES.qrState), state);
 }
 //#endregion
 //#region ../wechat-ilink-core/dist/store/allow-from.js
@@ -741,8 +839,6 @@ async function uploadMediaBytes(params) {
 		no_need_thumb: true,
 		aeskey: aeskey.toString("hex")
 	});
-	const code = up.ret ?? up.errcode;
-	if (code !== void 0 && code !== 0) throw new ILinkError("getUploadUrl", code, up.errmsg);
 	return {
 		downloadParam: await uploadBufferToCdn({
 			buf: data,
@@ -3023,6 +3119,18 @@ function sendOrdered(account, to, ctx, text, state = MessageState.FINISH, fallba
 	});
 	return replyChain;
 }
+/**
+* 发一条「必须送达」的答复（控制指令回执、任务回执、任务结束确认、出错提示）。
+*
+* 与 sendOrdered 的唯一差别：**先计入连发额度**。服务端按「距用户上一条消息」计连续发送数，
+* 这类答复确实占额度；只发不计数会让 brain 回合的 budgetOf 低估真实值 → 误判「还能发」→
+* 撞 ret=-2 限流、结果丢失。计数后仍走同一条 replyChain，保证与进度/答案不乱序、遵守最小间隔。
+* 与 `setTaskPush` 同一套语义：task 推送也是「必须送达、只计数不被 awaiting 暂停」。
+*/
+function sendNotice(account, to, ctx, text, fallbackToken) {
+	budgetOf(to).count += 1;
+	return sendOrdered(account, to, ctx, text, MessageState.FINISH, fallbackToken);
+}
 /** 把长回复作为 .md 文件发送（走同一串行链+节流）；发文件失败则兜底回退为文本。 */
 function sendMdOrdered(account, to, ctx, finalText, fallbackToken) {
 	replyChain = replyChain.then(async () => {
@@ -3322,21 +3430,21 @@ async function workerLoop(account, state) {
 				r = "处理指令出错：" + String(e);
 			}
 			log("control:", JSON.stringify(ctrl), "->", r.replace(/\n/g, " | "));
-			await reply(account, from, token, r, MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			await sendNotice(account, from, token, r, latestToken());
 			continue;
 		}
 		const tcmd = item.text ? parseTaskControl(item.text) : null;
 		if (tcmd?.kind === "stop") {
 			const r = stopTask(from);
 			log("task: stop ->", r);
-			await reply(account, from, token, r, MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			await sendNotice(account, from, token, r, latestToken());
 			continue;
 		}
 		if (tcmd?.kind === "toWorker") {
 			if (hasActiveTask(from)) {
 				log("task: inject(explicit):", tcmd.text.slice(0, 40));
 				injectTask(from, tcmd.text);
-			} else await reply(account, from, token, dispatchTask(from, tcmd.text), MessageState.FINISH, latestToken()).catch((e) => handleSendError(e, account));
+			} else await sendNotice(account, from, token, dispatchTask(from, tcmd.text), latestToken());
 			continue;
 		}
 		const brainEscape = item.text ? parseBrainEscape(item.text) : null;
@@ -3350,7 +3458,7 @@ async function workerLoop(account, state) {
 			await handleMessage(account, token, from, brainText, item.imageItems, item.createTimeMs, latestToken);
 		} catch (e) {
 			log("handleMessage error:", e instanceof Error ? e.stack || e.message : String(e));
-			await reply(account, from, token, "处理这条消息时出错了，请再发一次试试。", MessageState.FINISH, latestToken()).catch((e2) => handleSendError(e2, account));
+			await sendNotice(account, from, token, "处理这条消息时出错了，请再发一次试试。", latestToken());
 		}
 	}
 }
@@ -3488,8 +3596,50 @@ function pm2Available() {
 }
 /** 账号的 daemon 日志路径，与 run-daemon.ps1 / ecosystem 方式一致：`~/.wemind/<key>/daemon.log`。 */
 function daemonLogPath(key) {
-	const root = process.env.WEMIND_HOME?.trim() || path.join(os.homedir(), ".wemind");
-	return path.join(root, key, "daemon.log");
+	return path.join(accountDir(key), "daemon.log");
+}
+/**
+* 生成 pm2 的 app 声明（`{ apps: [decl] }`，写进账号目录的 `pm2.app.json`）。
+*
+* **为什么用 JSON 声明而不是把参数堆在 `pm2 start` 命令行上**：
+* - `restart_delay` / `stop_exit_codes` / `max_restarts` 在命令行上是 `--restart-delay` /
+*   `--stop-exit-codes`（**变参**）/ `--max-restarts`，还要和 `-- daemon` 这个「脚本参数分隔符」
+*   挤在同一条命令里——解析顺序、变参吞掉后续 token 的风险都只能靠真机试；
+* - JSON 声明没有解析层：键值原样进 `pm2_env`（`stop_exit_codes` 在 `God.handleExit` 里既接受
+*   数字数组也接受数字字符串，这里给数字数组），与 `ecosystem.config.cjs` 同源同义；
+* - 路径全走 JSON 转义，不再依赖 shell 引号。
+*
+* 与 `ecosystem.config.cjs` 保持一致的项：app 名 `wemind-<key>`、崩溃 5s 重拉、最多 50 次、
+* 退出码 78（大脑配置错误）不重启、日志合并到账号 `daemon.log`。导出供单测直接断言（不需要装 pm2）。
+*/
+function buildAppDeclaration(key, cliPath, logPath) {
+	return {
+		name: `wemind-${key}`,
+		script: cliPath,
+		args: "daemon",
+		interpreter: "node",
+		cwd: os.homedir(),
+		autorestart: true,
+		restart_delay: 5e3,
+		max_restarts: 50,
+		stop_exit_codes: [78],
+		out_file: logPath,
+		error_file: logPath,
+		merge_logs: true,
+		watch: false,
+		env: { WECHAT_ACCOUNT: key }
+	};
+}
+/**
+* 把声明写进账号目录，返回文件路径。单独导出便于测试（不触碰 pm2）；
+* `dir` 可覆盖目标目录——单测传临时目录，避免动真实 `~/.wemind`。
+*/
+function writeAppDeclaration(key, cliPath, logPath, dir = accountDir(key)) {
+	fs.mkdirSync(dir, { recursive: true });
+	const file = path.join(dir, "pm2.app.json");
+	const apps = [buildAppDeclaration(key, cliPath, logPath)];
+	fs.writeFileSync(file, JSON.stringify({ apps }, null, 2) + "\n", "utf-8");
+	return file;
 }
 /** 用 pm2 启动某账号的 daemon：app 名 `wemind-<key>`，注入 WECHAT_ACCOUNT，日志归一到账号 daemon.log。 */
 function pm2Start(key, cliPath) {
@@ -3497,21 +3647,23 @@ function pm2Start(key, cliPath) {
 		ok: false,
 		msg: "未检测到 pm2。请先安装：npm i -g pm2，再重试 `wemind start`。"
 	};
-	const name = `wemind-${key}`;
 	const log = daemonLogPath(key);
+	const name = `wemind-${key}`;
 	pm2Run(`delete ${name}`, { quiet: true });
-	const r = pm2Run(`start "${cliPath}" --name ${name} --interpreter node --output "${log}" --error "${log}" --merge-logs -- daemon`, { env: {
+	const decl = writeAppDeclaration(key, cliPath, log);
+	const r = pm2Run(`start "${decl}"`, { env: {
 		...process.env,
 		WECHAT_ACCOUNT: key
 	} });
 	if (r.status !== 0) return {
 		ok: false,
-		msg: `pm2 启动失败（exit=${r.status}）。`
+		msg: `pm2 启动失败（exit=${r.status}），声明文件：${decl}`
 	};
 	pm2Run("save", { quiet: true });
 	return {
 		ok: true,
-		msg: `已用 pm2 启动 ${name}（日志：${log}）。\n  开机自启（首次）：执行 \`pm2 startup\`——Linux/macOS 按提示操作；Windows 用计划任务跑 \`pm2 resurrect\`。`
+		msg: `已用 pm2 启动 ${name}（日志：${log}）。\n  崩溃 5s 重拉、退出码 78（大脑配置错误）不再重启，与自带看门狗一致。
+  开机自启（首次）：执行 \`pm2 startup\`——Linux/macOS 按提示操作；Windows 用计划任务跑 \`pm2 resurrect\`。`
 	};
 }
 /** 停止某账号的 daemon（pm2 delete）。 */
@@ -3845,17 +3997,23 @@ async function checkAgent(ag, timeoutMs = 6e4) {
 //#endregion
 //#region src/version.ts
 /**
-* CLI 版本号（`wemind version` / `wemind --version` / help 头部）。
-* 与 package.json 的 version 必须一致——单测 version.test.ts 会读 package.json 校验，
-* 避免「发了新版本、CLI 还报旧版本号」这种排查成本极高的小漂移。
+* CLI 版本号与包身份（`wemind version` / `wemind --version` / help 头部）。
+*
+* **版本号唯一来源是 `package.json`**，这里在运行时读它，不再手写常量。
+* 为什么：以前版本号散落在 package.json 和本文件两处，`npm version` 只会改前者，
+* 漏改本文件会导致「发了 1.2.0、`wemind version` 还报 1.1.0」这种极难排查的漂移。
+* 现在 `npm run release:patch|minor|major` 一步到位，本文件自动跟着变。
+*
+* 查找逻辑在 `@wemind/wechat-ilink-core` 的 `readOwnVersion()`（与 MCP 包共用一份）：
+* 必须把**本文件的** `import.meta.url` 传进去，否则会命中的是 core 自己的 package.json。
 */
-const CLI_VERSION = "1.1.0";
+/** 期望的 npm 包名。这是**独立常量**，故意不从 package.json 读——它是校验基准。 */
+const CLI_PKG_NAME = "@wemind/cli";
 /**
-* npm 包名（与 package.json 的 name 一致，单测校验）。
-* 命令名是 `wemind`，但**包名**是 `@wemind/cli`——两者不同，所以 `npx` 不能靠「唯一 bin」自动解析，
-* 必须写全 `npx @wemind/cli`（见 README 与 docs/发布-wemind-npm.md）。
+* 包版本。正常情况下等于 `package.json` 的 `version`；
+* 若查找失败（不该发生），退化为可识别的占位值，单测会把它当失败信号。
 */
-const CLI_PKG_NAME = "@wemind/cli";
+const CLI_VERSION = readOwnVersion(import.meta.url, "@wemind/cli") ?? "0.0.0-unknown";
 /** 单行版本串（供 --version 输出）：命令名 + 版本，包名放括号里便于反馈问题时对上 npm 页面。 */
 function versionLine() {
 	return `wemind ${CLI_VERSION} (${CLI_PKG_NAME}, node ${process.versions.node}, ${process.platform}-${process.arch})`;
@@ -3871,13 +4029,6 @@ function versionLine() {
 const BASE = process.env.WEMIND_ILINK_BASE?.trim() || "https://ilinkai.weixin.qq.com";
 const STAGING = path.join(WEMIND_ROOT, ".staging");
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function readAccount(dir) {
-	try {
-		return JSON.parse(fs.readFileSync(path.join(dir, "account.json"), "utf-8"));
-	} catch {
-		return null;
-	}
-}
 function readPid(dir, name) {
 	try {
 		const n = parseInt(fs.readFileSync(path.join(dir, name), "utf-8").trim(), 10);
@@ -3893,19 +4044,99 @@ function readPid(dir, name) {
 function aliveOurs(pid, markers = CLI_PID_MARKERS) {
 	return isOurProcess(pid, markers);
 }
-function killPid(pid) {
-	if (process.platform === "win32") spawnSync("taskkill", [
-		"/PID",
-		String(pid),
-		"/T",
-		"/F"
-	], {
-		stdio: "ignore",
-		windowsHide: true
-	});
-	else try {
-		process.kill(pid);
+/** 阻塞式 sleep（CLI 是同步流程；Atomics.wait 不占 CPU、不比 spawn 一个进程贵）。 */
+function sleepSync(ms) {
+	try {
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	} catch {}
+}
+/**
+* 某 pid 的全部后代（POSIX）。Windows 不需要——`taskkill /T` 自己会走进程树。
+* 用 `ps -A -o pid=,ppid=` 一次取全表再在内存里建树，比逐层 `pgrep -P` 少起进程。
+* （导出仅供单测；CLI 内部不对外。）
+*/
+function descendantPids(pid) {
+	try {
+		const psArgs = [[
+			"-A",
+			"-o",
+			"pid=,ppid="
+		], [
+			"-e",
+			"-o",
+			"pid=,ppid="
+		]];
+		let stdout = "";
+		for (const args of psArgs) {
+			const r = spawnSync("ps", args, {
+				encoding: "utf8",
+				timeout: 5e3
+			});
+			if (r.status === 0 && r.stdout) {
+				stdout = r.stdout;
+				break;
+			}
+		}
+		const childrenOf = /* @__PURE__ */ new Map();
+		for (const line of stdout.split(/\r?\n/)) {
+			const m = line.trim().match(/^(\d+)\s+(\d+)$/);
+			if (!m) continue;
+			const child = Number(m[1]);
+			const parent = Number(m[2]);
+			const bucket = childrenOf.get(parent);
+			if (bucket) bucket.push(child);
+			else childrenOf.set(parent, [child]);
+		}
+		const out = [];
+		const walk = (p) => {
+			for (const c of childrenOf.get(p) ?? []) {
+				out.push(c);
+				walk(c);
+			}
+		};
+		walk(pid);
+		return out;
+	} catch {
+		return [];
+	}
+}
+/**
+* 杀「pid 及其整棵进程树」。
+*
+* Windows：`taskkill /T /F` 本来就连带子树。
+* POSIX：`process.kill(pid)` **只**结束该进程，不动它的子进程——daemon 被停后，它拉起的
+* ACP 大脑 / worker 会留下来继续占着会话与文件句柄（Windows 的 `taskkill /T` 会连带子树，所以这个缺陷只在 POSIX 暴露）。
+* 所以这里先收集后代、由叶子往根 SIGTERM（daemon 的 SIGTERM 处理器会自己清 pid 文件），
+* 等一小会儿再对仍存活的补 SIGKILL。
+*/
+function killProcessTrees(pids) {
+	const unique = [...new Set(pids.filter((p) => isAlive(p)))];
+	if (!unique.length) return;
+	if (process.platform === "win32") {
+		for (const pid of unique) spawnSync("taskkill", [
+			"/PID",
+			String(pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		return;
+	}
+	const targets = [];
+	for (const pid of unique) targets.push(...descendantPids(pid).reverse(), pid);
+	const all = [...new Set(targets)].filter((p) => isAlive(p));
+	for (const pid of all) try {
+		process.kill(pid, "SIGTERM");
 	} catch {}
+	sleepSync(800);
+	for (const pid of all) {
+		if (!isAlive(pid)) continue;
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+	}
 }
 function openFile(p) {
 	try {
@@ -3942,7 +4173,10 @@ function startDaemon(key, runner) {
 	const useRunner = (runner || process.env.WEMIND_RUNNER || "builtin").toLowerCase();
 	console.log((useRunner === "pm2" ? pm2Start(key, cliPath) : watchdogStart(key, cliPath)).msg);
 }
-/** 停止某账号的常驻：先 pm2 delete（方案 a），再按 pid 兜底杀 wrapper/daemon/brain（兼容直接启动的）。 */
+/**
+* 停止某账号的常驻：先 pm2 delete（方案 a），再按 pid 兜底杀 wrapper/daemon/brain/worker
+* （兼容直接启动的）。停的是**整条链**：除列出的进程外，还连带它们的子进程树。
+*/
 function stopDaemon(key) {
 	pm2Stop(key);
 	const dir = accountDir(key);
@@ -3962,22 +4196,30 @@ function stopDaemon(key) {
 			pid: readPid(dir, "brain.pid"),
 			name: "brain",
 			markers: brainPidMarkers(ag.bin, ag.args)
+		},
+		{
+			pid: readPid(dir, "worker.pid"),
+			name: "worker",
+			markers: brainPidMarkers(ag.bin, ag.args)
 		}
 	];
 	const lines = commandLines(cand.map((c) => c.pid));
 	const stopped = [];
 	const skipped = [];
+	const toKill = [];
 	for (const c of cand) {
 		if (!c.pid || !isAlive(c.pid)) continue;
 		if (matchesMarkers(lines.get(c.pid), c.markers)) {
-			killPid(c.pid);
+			toKill.push(c.pid);
 			stopped.push(`${c.name} ${c.pid}`);
 		} else skipped.push(`${c.name} ${c.pid}`);
 	}
+	killProcessTrees(toKill);
 	for (const f of [
 		"wrapper.pid",
 		"daemon.pid",
-		"brain.pid"
+		"brain.pid",
+		"worker.pid"
 	]) try {
 		fs.unlinkSync(path.join(dir, f));
 	} catch {}
@@ -3988,7 +4230,7 @@ function stopDaemon(key) {
 }
 /** 把 STAGING 的登录按 botId 归档 + 登记。 */
 function finalizeStaging(label) {
-	const acc = readAccount(STAGING);
+	const acc = loadAccount(STAGING);
 	if (!acc?.botId) throw new Error(`staging 无有效登录（${STAGING}）`);
 	const key = deriveAccountKey(acc.botId);
 	const dest = accountDir(key);
@@ -4088,13 +4330,13 @@ async function cmdLogin(label, autoStart, runner) {
 		}
 		if (s.status === "confirmed") {
 			if (!s.bot_token || !s.ilink_bot_id || !s.ilink_user_id) throw new Error("confirmed 但数据不全");
-			fs.writeFileSync(path.join(STAGING, "account.json"), JSON.stringify({
+			saveAccountTo(STAGING, {
 				botToken: s.bot_token,
 				botId: s.ilink_bot_id,
 				userId: s.ilink_user_id,
 				baseUrl: s.baseurl ?? BASE,
 				savedAt: Date.now()
-			}, null, 2), "utf-8");
+			});
 			clearSessionPause(s.ilink_bot_id);
 			await notifyStart({
 				baseUrl: s.baseurl ?? BASE,
@@ -4205,10 +4447,18 @@ async function cmdBrainCheck(key) {
 /** brain 子命令派发：show（默认）/ set / unset / check。 */
 async function cmdBrain(rest) {
 	const argv = [...rest];
+	const FLAGS = /* @__PURE__ */ new Set([
+		"--bin",
+		"--args",
+		"--shell",
+		"--no-shell",
+		"--restart"
+	]);
 	const takeFlag = (name) => {
 		const i = argv.indexOf(name);
 		if (i < 0) return void 0;
 		const v = argv[i + 1];
+		if (v === void 0 || FLAGS.has(v)) throw new Error(`${name} 缺少参数值`);
 		argv.splice(i, 2);
 		return v;
 	};
@@ -4247,7 +4497,7 @@ async function cmdBrain(rest) {
 }
 function cmdAdopt(key, label) {
 	if (!key) throw new Error("用法: adopt <key> [--label 名]");
-	const acc = readAccount(accountDir(key));
+	const acc = loadAccount(accountDir(key));
 	if (!acc?.botId) throw new Error(`${accountDir(key)} 无有效 account.json`);
 	const meta = registerAccount({
 		key,
@@ -4262,7 +4512,7 @@ function cmdAdopt(key, label) {
 async function cmdLogout(sel) {
 	const key = resolveKey(sel);
 	const dir = accountDir(key);
-	const acc = readAccount(dir);
+	const acc = loadAccount(dir);
 	const stopMsg = stopDaemon(key);
 	if (acc?.botToken) try {
 		await notifyStop({
@@ -4485,7 +4735,20 @@ async function runManage(argv) {
 			console.log(`${k} 授权用户(${list.length})：\n${list.map((u) => "  - " + u).join("\n") || "  （空）"}`);
 			break;
 		}
-		default: console.log(`WeMind 多账号管理（wemind v${CLI_VERSION}）
+		case "help":
+		case "--help":
+		case "-h":
+		case void 0:
+			console.log(helpText());
+			break;
+		default:
+			console.error(`未知命令：${cmd}`);
+			console.error(helpText());
+			process.exitCode = 2;
+	}
+}
+function helpText() {
+	return `WeMind 多账号管理（wemind v${CLI_VERSION}）
 用法: wemind <command>            其余：wemind version | help
 
   login [--label 名] [--start]   一条命令完成扫码登录：自刷新二维码 + 自动归档（--start 顺带启动 daemon）
@@ -4508,8 +4771,7 @@ async function runManage(argv) {
   allow <key|label> <userId>     授权某用户可驱动该账号 bot
   revoke <key|label> <userId>    撤销某用户的授权
 
-说明：key = 由微信 botId 派生的唯一标识（目录名）；label = 人类可读别名。多数命令可用 key 或 label。`);
-	}
+说明：key = 由微信 botId 派生的唯一标识（目录名）；label = 人类可读别名。多数命令可用 key 或 label。`;
 }
 //#endregion
 //#region src/cli.ts