@lark-apaas/openclaw-scripts-diagnose-cli 0.1.17 → 0.1.18-alpha.1

package/dist/index.cjs

@@ -52,7 +52,7 @@ node_assert = __toESM(node_assert);
 * it terse and parseable.
 */
 function getVersion() {
-	return "0.1.17";
+	return "0.1.18-alpha.1";
 }
 //#endregion
 //#region src/rule-engine/base.ts
@@ -3743,12 +3743,53 @@ function coerceCalVer(v) {
 function compareCalVer(a, b) {
 	return semver.default.compare(coerceCalVer(a), coerceCalVer(b));
 }
-/** Whether the given openclaw version falls inside this plugin entry's compat range. */
-function compatible(entry, openclawVersion) {
+/** Look up an entry by exact plugin version; undefined if not in the table. */
+function findEntry(pluginVersion) {
+	return VERSION_COMPAT_MAP.find((e) => e.openclawLarkVersion === pluginVersion);
+}
+/**
+* Infer the effective upper bound for a compat entry that has no explicit maxOpenclawVersion.
+*
+* Scans toward higher plugin versions (lower indices in the descending table) and returns
+* the first entry whose minOpenclawVersion differs from the current entry's.
+* That minOpenclawVersion becomes an EXCLUSIVE upper bound — the openclaw version that
+* starts a new incompatible range.
+*
+* Returns undefined for the topmost entry (no upper bound).
+*/
+function inferEffectiveMax(index) {
+	const cur = VERSION_COMPAT_MAP[index];
+	if (cur.maxOpenclawVersion != null) return {
+		max: cur.maxOpenclawVersion,
+		exclusive: false
+	};
+	for (let i = index - 1; i >= 0; i--) if (compareCalVer(VERSION_COMPAT_MAP[i].minOpenclawVersion, cur.minOpenclawVersion) > 0) return {
+		max: VERSION_COMPAT_MAP[i].minOpenclawVersion,
+		exclusive: true
+	};
+}
+/**
+* Full version compatibility check that infers the effective maxOpenclawVersion for
+* entries that only define minOpenclawVersion.
+*
+* For entries with an explicit maxOpenclawVersion the upper bound is INCLUSIVE (existing
+* semantics). For entries without one the upper bound is EXCLUSIVE — it is derived from
+* the minOpenclawVersion of the next entry group that requires a higher openclaw version.
+*
+* Example: openclaw-lark@2026.4.10 (min=2026.4.27, no explicit max) gets an inferred
+* exclusive max of '2026.5.6', so openclaw@2026.5.7 is correctly detected as incompatible
+* whereas the old compatible() call would have returned true.
+*/
+function effectiveCompatible(pluginVersion, openclawVersion) {
+	const index = VERSION_COMPAT_MAP.findIndex((e) => compareCalVer(e.openclawLarkVersion, pluginVersion) <= 0);
+	if (index === -1) return false;
+	const entry = VERSION_COMPAT_MAP[index];
 	const oc = coerceCalVer(openclawVersion);
 	if (semver.default.lt(oc, coerceCalVer(entry.minOpenclawVersion))) return false;
-	if (entry.maxOpenclawVersion != null && semver.default.gt(oc, coerceCalVer(entry.maxOpenclawVersion))) return false;
-	return true;
+	const maxInfo = inferEffectiveMax(index);
+	if (!maxInfo) return true;
+	const max = coerceCalVer(maxInfo.max);
+	return maxInfo.exclusive ? semver.default.lt(oc, max) : !semver.default.gt(oc, max);
 }
 /**
 * Floor match: find the entry with the largest openclawLarkVersion that is
@@ -3766,10 +3807,19 @@ function findClosestEntry(pluginVersion) {
 const PLUGIN_NAME$1 = "openclaw-lark";
 const LEGACY_SHORT_NAMES = ["feishu-openclaw-plugin"];
 const FORK_SCOPES = ["@lark-apaas"];
-/** 特化 fork 版全名：虽免于 VERSION_COMPAT_MAP 检查，仍需 openclaw ≥ 此版本 */
+/** 特化 fork 版全名：复用官方 effectiveCompatible，按对标版本取完整兼容区间 */
 const FORK_LARK_PLUGIN_FULL_NAME = "@lark-apaas/openclaw-lark";
-/** 来自 VERSION_COMPAT_MAP openclawLarkVersion=2026.4.1 对应的 minOpenclawVersion */
-const FORK_LARK_PLUGIN_MIN_OC_VERSION = "2026.3.28";
+/**
+* fork 版对标的官方 openclaw-lark 版本。fork 自身版本不在 VERSION_COMPAT_MAP 内，
+* 兼容性按此对标版本经 effectiveCompatible 取完整区间（含推断上界）判定。
+*/
+const FORK_LARK_PLUGIN_PINNED_VERSION = "2026.4.1";
+/**
+* fork 版兼容区间的下界，取自 VERSION_COMPAT_MAP 中 openclawLarkVersion=2026.4.1
+* 的 minOpenclawVersion，避免与映射表脱钩写死。仅用于区分升级方向
+* （oc 低于下界 → 升 openclaw；高于上界 → 升 lark）；该条目被移除时回退到已知值。
+*/
+const FORK_LARK_PLUGIN_MIN_OC_VERSION = findEntry(FORK_LARK_PLUGIN_PINNED_VERSION)?.minOpenclawVersion ?? "2026.3.28";
 let _ocVersion = void 0;
 function getOcVersion() {
 	if (_ocVersion === void 0) _ocVersion = readOpenclawRuntimeVersion();
@@ -3845,7 +3895,15 @@ let FeishuPluginLarkUpgradeRule = class FeishuPluginLarkUpgradeRule extends Diag
 		const cc = resolveCompatContext(ctx);
 		if (!cc) return { pass: true };
 		const { ocCur, recommendedOc, installed, isLegacy } = cc;
-		if (isForkPlugin(installed)) return { pass: true };
+		if (isForkPlugin(installed)) {
+			if (installed.fullName !== FORK_LARK_PLUGIN_FULL_NAME) return { pass: true };
+			if (resolveForkUpgradeDirection(ocCur) !== "lark") return { pass: true };
+			return {
+				pass: false,
+				action: "upgrade_lark",
+				message: `飞书插件 ${describePlugin(installed)}（fork 版，对标 openclaw-lark@${FORK_LARK_PLUGIN_PINNED_VERSION}）与当前 openclaw@${ocCur} 不兼容；建议升级飞书插件至兼容版本`
+			};
+		}
 		if (!isLarkUpgradeNeededFromCC(cc)) return { pass: true };
 		const prefix = buildCompatPrefix(installed, ocCur, isLegacy);
 		if (!recommendedOc) return {
@@ -3890,13 +3948,12 @@ function isLegacyPlugin(p) {
 	return LEGACY_SHORT_NAMES.includes(p.allowName);
 }
 /**
-* 用 floor 匹配找到最近的兼容表条目，检查 ocCur 是否在其 [min, max] 范围内。
-* 版本读不到、表中无 ≤ 当前插件版本的条目、或不在范围内，均视为不兼容。
+* 检查已装插件版本与当前 openclaw 版本是否兼容。
+* 使用 effectiveCompatible() 以正确推断无显式 maxOpenclawVersion 条目的上界。
 */
 function isVersionCompatible(p, ocCur) {
 	if (!p.version) return false;
-	const entry = findClosestEntry(p.version);
-	return entry != null && compatible(entry, ocCur);
+	return effectiveCompatible(p.version, ocCur);
 }
 /**
 * 豁免判断：若推荐的 openclaw 版本本身低于最近条目要求的最低版本，
@@ -3919,13 +3976,25 @@ function describeCompatConstraint(entry, pluginVersion) {
 	return `该插件版本要求 openclaw ≥ ${entry.minOpenclawVersion}`;
 }
 /**
-* @lark-apaas/openclaw-lark 豁免 VERSION_COMPAT_MAP，但仍要求 openclaw ≥ FORK_LARK_PLUGIN_MIN_OC_VERSION。
+* fork @lark-apaas/openclaw-lark 的升级方向：复用官方 effectiveCompatible，按对标版本
+* FORK_LARK_PLUGIN_PINNED_VERSION (2026.4.1) 取完整兼容区间。
+*   null       → 兼容
+*   'openclaw' → oc 低于区间下界，需升级 openclaw
+*   'lark'     → oc 高于区间上界（插件相对当前 openclaw 过旧），需升级飞书插件
+*/
+function resolveForkUpgradeDirection(ocCur) {
+	if (effectiveCompatible(FORK_LARK_PLUGIN_PINNED_VERSION, ocCur)) return null;
+	return compareCalVer(ocCur, FORK_LARK_PLUGIN_MIN_OC_VERSION) < 0 ? "openclaw" : "lark";
+}
+/**
+* @lark-apaas/openclaw-lark 复用官方 effectiveCompatible（按对标版本 2026.4.1 完整区间）。
+* 本函数（Rule 1）只负责 openclaw 方向（oc 低于下界）；oc 高于上界由 Rule 2 报 upgrade_lark。
 * 其他 @lark-apaas scope 的 fork 插件继续无条件 pass。
-* recommendedOc 可为 undefined（doctor 模式），此时只检测最低版本要求，不指定目标升级版本。
+* recommendedOc 可为 undefined（doctor 模式），此时不指定目标升级版本。
 */
 function validateForkPlugin(installed, ocCur, recommendedOc) {
 	if (installed.fullName !== FORK_LARK_PLUGIN_FULL_NAME) return { pass: true };
-	if (compareCalVer(ocCur, FORK_LARK_PLUGIN_MIN_OC_VERSION) >= 0) return { pass: true };
+	if (resolveForkUpgradeDirection(ocCur) !== "openclaw") return { pass: true };
 	const recommendation = recommendedOc ? `；将 openclaw 升级到 ${recommendedOc} 即可满足` : `；请升级 openclaw 至 ${FORK_LARK_PLUGIN_MIN_OC_VERSION} 或更高版本`;
 	return {
 		pass: false,
@@ -3992,7 +4061,7 @@ function needsLarkUpgrade(ctx) {
 	if (!cc) return false;
 	const { ocCur, installed } = cc;
 	if (isForkPlugin(installed)) {
-		if (installed.fullName === FORK_LARK_PLUGIN_FULL_NAME) return compareCalVer(ocCur, FORK_LARK_PLUGIN_MIN_OC_VERSION) < 0;
+		if (installed.fullName === FORK_LARK_PLUGIN_FULL_NAME) return !effectiveCompatible(FORK_LARK_PLUGIN_PINNED_VERSION, ocCur);
 		return false;
 	}
 	return isLarkUpgradeNeededFromCC(cc);
@@ -5137,6 +5206,139 @@ async function installOpenclaw(openclawTag, ossFileMap, opts = {}) {
 	}
 	console.error(`[install-openclaw] done in ${Date.now() - t0}ms`);
 }
+//#endregion
+//#region src/lark-tools-update.ts
+/**
+* 共享的飞书插件备份 / 恢复 / `openclaw-lark-tools update` 调用。
+*
+* upgrade-lark（场景修复流）与 install-extension（升级触发的兼容性预判路径）都需要
+* 「备份 → npx 适配升级 → 失败回滚」的同一套处理，此处统一封装，避免两份实现漂移。
+*
+* 日志通过可选 `log` 注入：upgrade-lark 传写日志文件的 Logger，install-extension 传
+* `console.error`，独立调用方不传则静默。
+*/
+const NOOP_LOG = () => {};
+/** 升级前需备份的 extensions/ 下的插件目录（含 legacy） */
+const FEISHU_PLUGIN_DIRS = ["openclaw-lark", "feishu-openclaw-plugin"];
+/** 读取 package.json 的 version 字段，失败返回 null（仅用于日志） */
+function readPkgVersion(pkgPath) {
+	try {
+		const pkg = JSON.parse(node_fs.default.readFileSync(pkgPath, "utf-8"));
+		return typeof pkg.version === "string" ? pkg.version : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 备份 openclaw.json + FEISHU_PLUGIN_DIRS 下存在的插件目录到 backupDir。
+* 只备份当前存在的文件；不存在的记日志后跳过（恢复时据此判断「升级前是否存在」）。
+*/
+function backupFeishuPlugins(opts) {
+	const { workspaceDir, configPath, backupDir } = opts;
+	const log = opts.log ?? NOOP_LOG;
+	try {
+		node_fs.default.mkdirSync(backupDir, { recursive: true });
+		log(`backup dir: ${backupDir}`);
+		if (node_fs.default.existsSync(configPath)) {
+			const stat = node_fs.default.statSync(configPath);
+			node_fs.default.copyFileSync(configPath, node_path.default.join(backupDir, "openclaw.json"));
+			log(`  backed up: openclaw.json (${stat.size} bytes)`);
+		} else log(`  skipped: openclaw.json (not found)`);
+		node_fs.default.mkdirSync(node_path.default.join(backupDir, "extensions"), { recursive: true });
+		const extSrc = node_path.default.join(workspaceDir, "extensions");
+		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
+			const src = node_path.default.join(extSrc, pluginDir);
+			if (node_fs.default.existsSync(src)) {
+				const dst = node_path.default.join(backupDir, "extensions", pluginDir);
+				node_fs.default.cpSync(src, dst, { recursive: true });
+				const version = readPkgVersion(node_path.default.join(src, "package.json"));
+				log(`  backed up: extensions/${pluginDir}${version ? ` (version: ${version})` : ""}`);
+			} else log(`  skipped: extensions/${pluginDir} (not found)`);
+		}
+		return { ok: true };
+	} catch (e) {
+		const msg = `backup failed: ${e.message}`;
+		log(`ERROR: ${msg}`);
+		return {
+			ok: false,
+			error: msg
+		};
+	}
+}
+/**
+* 回滚到备份快照：先删除当前 openclaw.json + 插件目录，再从备份恢复（仅恢复备份中存在的，
+* 即升级前确实存在的文件）。这样升级过程中新建的文件会被清理，真正回到 pre-state。
+*/
+function restoreFeishuPlugins(opts) {
+	const { workspaceDir, configPath, backupDir } = opts;
+	const log = opts.log ?? NOOP_LOG;
+	try {
+		if (node_fs.default.existsSync(configPath)) {
+			node_fs.default.rmSync(configPath, { force: true });
+			log(`  deleted: openclaw.json`);
+		}
+		const extDst = node_path.default.join(workspaceDir, "extensions");
+		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
+			const dst = node_path.default.join(extDst, pluginDir);
+			if (node_fs.default.existsSync(dst)) {
+				node_fs.default.rmSync(dst, {
+					recursive: true,
+					force: true
+				});
+				log(`  deleted: extensions/${pluginDir}`);
+			}
+		}
+		const configBackup = node_path.default.join(backupDir, "openclaw.json");
+		if (node_fs.default.existsSync(configBackup)) {
+			node_fs.default.copyFileSync(configBackup, configPath);
+			log(`  restored: openclaw.json`);
+		} else log(`  skipped restore: openclaw.json (not in backup — was not present before upgrade)`);
+		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
+			const backupSrc = node_path.default.join(backupDir, "extensions", pluginDir);
+			if (node_fs.default.existsSync(backupSrc)) {
+				node_fs.default.cpSync(backupSrc, node_path.default.join(extDst, pluginDir), { recursive: true });
+				log(`  restored: extensions/${pluginDir}`);
+			} else log(`  skipped restore: extensions/${pluginDir} (not in backup — was not present before upgrade)`);
+		}
+		return true;
+	} catch (e) {
+		log(`  restore error: ${e.message}`);
+		return false;
+	}
+}
+/**
+* 执行 `npx -y @larksuite/openclaw-lark-tools update`，自动按当前 openclaw 内核选择
+* 适配的 openclaw-lark 版本。stdout/stderr 已 trim；exitCode 缺失时归一为 1。
+*/
+function runLarkToolsUpdate(opts) {
+	const log = opts.log ?? NOOP_LOG;
+	const r = (0, node_child_process.spawnSync)("npx", [
+		"-y",
+		"@larksuite/openclaw-lark-tools",
+		"update"
+	], {
+		cwd: opts.cwd,
+		encoding: "utf-8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		timeout: opts.timeoutMs ?? 6e5
+	});
+	const stdout = r.stdout?.trim() ?? "";
+	const stderr = r.stderr?.trim() ?? "";
+	const exitCode = r.status ?? 1;
+	if (stdout) log(`npx stdout:\n${stdout}`);
+	if (stderr) log(`npx stderr:\n${stderr}`);
+	log(`npx exit: ${exitCode}${r.error ? ` error: ${r.error.message}` : ""}`);
+	return {
+		exitCode,
+		stdout,
+		stderr,
+		spawnError: r.error?.message
+	};
+}
 async function installExtension(tag, ossFileMap, opts = {}) {
 	const homeBase = resolveHomeBase(opts.homeBase);
 	const hasAll = !!opts.all;
@@ -5159,6 +5361,24 @@ async function installExtension(tag, ossFileMap, opts = {}) {
 	}
 	console.error(`[install-extension] tag=${tag} targets=${targets.length}`);
 	const t0 = Date.now();
+	const larkTarget = opts.skipConfigUpdate ? void 0 : targets.find((p) => p.name === LARK_PLUGIN_NAME$1);
+	if (larkTarget) {
+		if (await installLarkPluginWithCompatCheck({
+			tag,
+			pkg: larkTarget,
+			homeBase,
+			configPath: opts.configPath ?? node_path.default.join(homeBase, "workspace/agent/openclaw.json"),
+			workspaceDir: node_path.default.join(homeBase, "workspace", "agent"),
+			ossFileMap,
+			downloadOpts: opts
+		})) {
+			targets = targets.filter((p) => p.name !== LARK_PLUGIN_NAME$1);
+			if (targets.length === 0) {
+				console.error(`[install-extension] done in ${Date.now() - t0}ms`);
+				return;
+			}
+		}
+	}
 	const tarballs = await Promise.all(targets.map(async (p) => {
 		const tb = await downloadWithCache(p, ossFileMap, opts);
 		console.error(`[install-extension]   ${p.name}: downloaded`);
@@ -5175,6 +5395,7 @@ async function installExtension(tag, ossFileMap, opts = {}) {
 	else console.error(`[install-extension] skipConfigUpdate=true — not touching openclaw.json`);
 	console.error(`[install-extension] done ${targets.length}/${targets.length} in ${Date.now() - t0}ms`);
 }
+const LARK_PLUGIN_NAME$1 = "openclaw-lark";
 const MEM0_PLUGIN_NAME = "openclaw-mem0-plugin";
 const PLUGINS_TO_AUTO_ENABLE = ["openclaw-lark", "openclaw-extension-miaoda"];
 /**
@@ -5264,6 +5485,105 @@ function installOne$1(pkg, tarball, homeBase) {
 		force: true
 	});
 }
+/**
+* Install openclaw-lark with a pre-flight compatibility check.
+*
+* When the recommended version in the manifest is incompatible with the currently
+* running openclaw, falls back to `npx @larksuite/openclaw-lark-tools update` which
+* selects the correct plugin version automatically.
+*
+* Returns true when the lark plugin was handled by this function (either path),
+* false when it should fall through to the standard tarball install (e.g. when the
+* current openclaw version cannot be read).
+*/
+async function installLarkPluginWithCompatCheck(opts) {
+	const { tag, pkg, homeBase, configPath, workspaceDir } = opts;
+	const ocCur = readOpenclawRuntimeVersion();
+	if (!ocCur) {
+		console.error("[install-extension] WARN: cannot read openclaw version — falling back to direct tarball install for openclaw-lark");
+		return false;
+	}
+	const compatible = pkg.version ? effectiveCompatible(pkg.version, ocCur) : true;
+	console.error(`[install-extension] openclaw-lark@${pkg.version ?? "unknown"} compat with openclaw@${ocCur}: ${compatible}`);
+	if (compatible) return false;
+	console.error(`[install-extension] openclaw-lark@${pkg.version} incompatible with openclaw@${ocCur} — using openclaw-lark-tools update`);
+	const log = (msg) => console.error(`[install-extension] ${msg}`);
+	const backupDir = node_path.default.join(homeBase, `.openclaw-lark-backup-${tag}`);
+	const backupOk = backupFeishuPlugins({
+		workspaceDir,
+		configPath,
+		backupDir,
+		log
+	}).ok;
+	if (!backupOk) console.error("[install-extension] WARN: backup failed — proceeding without backup for openclaw-lark-tools path");
+	try {
+		const { exitCode } = runLarkToolsUpdate({
+			cwd: workspaceDir,
+			log
+		});
+		if (exitCode !== 0) {
+			console.error("[install-extension] openclaw-lark-tools failed — attempting rollback");
+			if (backupOk) restoreFeishuPlugins({
+				workspaceDir,
+				configPath,
+				backupDir,
+				log
+			});
+			throw new Error(`openclaw-lark-tools update exited with code ${exitCode}`);
+		}
+		const validation = validateLarkPluginInstall({
+			homeBase,
+			configPath
+		});
+		if (!validation.ok) {
+			console.error(`[install-extension] post-install validation failed: ${validation.error} — rolling back`);
+			if (backupOk) restoreFeishuPlugins({
+				workspaceDir,
+				configPath,
+				backupDir,
+				log
+			});
+			throw new Error(`openclaw-lark post-install validation failed: ${validation.error}`);
+		}
+		console.error("[install-extension] openclaw-lark-tools update succeeded");
+		return true;
+	} finally {
+		if (backupOk && node_fs.default.existsSync(backupDir)) try {
+			node_fs.default.rmSync(backupDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+/**
+* Post-install validation for the tools-based upgrade path.
+* Checks: plugin directory exists + plugin is enabled in openclaw.json.
+*/
+function validateLarkPluginInstall(opts) {
+	const { homeBase, configPath } = opts;
+	const pkgJson = node_path.default.join(homeBase, "workspace", "agent", "extensions", LARK_PLUGIN_NAME$1, "package.json");
+	if (!node_fs.default.existsSync(pkgJson)) return {
+		ok: false,
+		error: `plugin directory missing: ${pkgJson}`
+	};
+	if (!node_fs.default.existsSync(configPath)) return {
+		ok: false,
+		error: `openclaw.json not found at ${configPath}`
+	};
+	try {
+		if (asRecord(getNestedMap(loadJSON5().parse(node_fs.default.readFileSync(configPath, "utf-8")), "plugins", "entries")?.[LARK_PLUGIN_NAME$1])?.enabled !== true) return {
+			ok: false,
+			error: `plugins.entries["${LARK_PLUGIN_NAME$1}"].enabled is not true`
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: `config parse error: ${e.message}`
+		};
+	}
+	return { ok: true };
+}
 //#endregion
 //#region ../../openclaw-slardar/lib/client.js
 var import_index_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
@@ -6547,6 +6867,31 @@ function reportError(params) {
 const LARK_CLI_NAME = "lark-cli";
 const AGENT_SKILLS_NAME = "agent-skills";
 const WORKSPACE_AGENT_REL = "workspace/agent";
+const LARK_PLUGIN_NAME = "openclaw-lark";
+/**
+* openclaw-lark tools that overlap with lark-cli functionality.
+* Written to channels.feishu.tools.deny after lark-cli is installed so that
+* openclaw-lark's shouldRegisterTool() skips them, avoiding duplicate tools.
+* Supports trailing-* wildcards (handled by openclaw-lark's matchesAnyPattern).
+*
+* Kept: feishu_chat*, feishu_get_user, feishu_search_user, feishu_im_*,
+*       feishu_oauth*, feishu_auth, feishu_diagnose, feishu_doctor
+*/
+const LARK_CLI_OVERLAP_TOOL_DENY = Object.freeze([
+	"feishu_create_doc",
+	"feishu_fetch_doc",
+	"feishu_update_doc",
+	"feishu_doc_comments",
+	"feishu_doc_media",
+	"feishu_drive_file",
+	"feishu_wiki_space",
+	"feishu_wiki_space_node",
+	"feishu_search_doc_wiki",
+	"feishu_bitable_*",
+	"feishu_calendar_*",
+	"feishu_task_*",
+	"feishu_sheet"
+]);
 async function installClis(tag, ossFileMap, opts) {
 	const homeBase = resolveHomeBase(opts.homeBase);
 	if (opts.names.length === 0) throw new Error("install-cli: must provide at least one --cli=<name>");
@@ -6611,6 +6956,7 @@ async function installClis(tag, ossFileMap, opts) {
 				}
 			});
 		}
+		disableLarkCliOverlapTools(node_path.default.join(homeBase, WORKSPACE_AGENT_REL, "openclaw.json"), homeBase);
 	}
 	console.error(`[install-cli] done ${targets.length}/${targets.length} in ${Date.now() - t0}ms`);
 }
@@ -6785,6 +7131,42 @@ function installOne(pkg, tarball, homeBase, tmpRoot) {
 		} catch {}
 	}
 }
+/**
+* Write overlapping tool names to channels.feishu.tools.deny in openclaw.json so that
+* openclaw-lark's shouldRegisterTool() skips them when lark-cli is present.
+*
+* Only runs when openclaw-lark is installed (extensions/openclaw-lark/ exists).
+* Idempotent: merges with any existing deny entries.
+* Failures are non-fatal (logged as warnings).
+*/
+function disableLarkCliOverlapTools(configPath, homeBase) {
+	const larkPluginDir = node_path.default.join(homeBase, WORKSPACE_AGENT_REL, "extensions", LARK_PLUGIN_NAME);
+	if (!node_fs.default.existsSync(larkPluginDir)) {
+		console.error(`[install-cli] disableLarkCliOverlapTools: ${LARK_PLUGIN_NAME} not installed — skipping`);
+		return;
+	}
+	if (!node_fs.default.existsSync(configPath)) {
+		console.error(`[install-cli] disableLarkCliOverlapTools: config not found at ${configPath} — skipping`);
+		return;
+	}
+	try {
+		const config = loadJSON5().parse(node_fs.default.readFileSync(configPath, "utf-8"));
+		if (!config.channels || typeof config.channels !== "object") config.channels = {};
+		const channels = config.channels;
+		if (!channels.feishu || typeof channels.feishu !== "object") channels.feishu = {};
+		const feishu = channels.feishu;
+		if (!feishu.tools || typeof feishu.tools !== "object") feishu.tools = {};
+		const tools = feishu.tools;
+		const existing = Array.isArray(tools.deny) ? tools.deny : [];
+		tools.deny = [...new Set([...existing, ...LARK_CLI_OVERLAP_TOOL_DENY])];
+		const tmp = configPath + ".lark-cli-deny-tmp";
+		node_fs.default.writeFileSync(tmp, JSON.stringify(config, null, 2), "utf-8");
+		moveSafe(tmp, configPath);
+		console.error(`[install-cli] disableLarkCliOverlapTools: channels.feishu.tools.deny updated (${LARK_CLI_OVERLAP_TOOL_DENY.length} patterns)`);
+	} catch (e) {
+		console.error(`[install-cli] WARN: disableLarkCliOverlapTools failed: ${e.message}`);
+	}
+}
 //#endregion
 //#region src/download-resource.ts
 /**
@@ -10720,7 +11102,7 @@ async function reportCliRun(opts) {
 //#region src/help.ts
 const BIN = "mclaw-diagnose";
 function versionBanner() {
-	return `v0.1.17`;
+	return `v0.1.18-alpha.1`;
 }
 const COMMANDS = [
 	{
@@ -11406,83 +11788,6 @@ function buildUpgradeLarkResultSummary(result, checkOnly) {
 }
 //#endregion
 //#region src/upgrade-lark.ts
-/** 升级前需备份的 extensions/ 下的插件目录 */
-const FEISHU_PLUGIN_DIRS = ["openclaw-lark", "feishu-openclaw-plugin"];
-function backupFiles(opts) {
-	const { workspaceDir, configPath, backupDir, log } = opts;
-	try {
-		node_fs.default.mkdirSync(backupDir, { recursive: true });
-		log(`backup dir: ${backupDir}`);
-		if (node_fs.default.existsSync(configPath)) {
-			const stat = node_fs.default.statSync(configPath);
-			node_fs.default.copyFileSync(configPath, node_path.default.join(backupDir, "openclaw.json"));
-			log(`  backed up: openclaw.json (${stat.size} bytes)`);
-		} else log(`  skipped: openclaw.json (not found)`);
-		node_fs.default.mkdirSync(node_path.default.join(backupDir, "extensions"), { recursive: true });
-		const extSrc = node_path.default.join(workspaceDir, "extensions");
-		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
-			const src = node_path.default.join(extSrc, pluginDir);
-			if (node_fs.default.existsSync(src)) {
-				const dst = node_path.default.join(backupDir, "extensions", pluginDir);
-				node_fs.default.cpSync(src, dst, { recursive: true });
-				const version = readPkgVersion(node_path.default.join(src, "package.json"));
-				log(`  backed up: extensions/${pluginDir}${version ? ` (version: ${version})` : ""}`);
-			} else log(`  skipped: extensions/${pluginDir} (not found)`);
-		}
-		return { ok: true };
-	} catch (e) {
-		const msg = `backup failed: ${e.message}`;
-		log(`ERROR: ${msg}`);
-		return {
-			ok: false,
-			error: msg
-		};
-	}
-}
-function restoreFiles(opts) {
-	const { workspaceDir, configPath, backupDir, log } = opts;
-	try {
-		if (node_fs.default.existsSync(configPath)) {
-			node_fs.default.rmSync(configPath, { force: true });
-			log(`  deleted: openclaw.json`);
-		}
-		const extDst = node_path.default.join(workspaceDir, "extensions");
-		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
-			const dst = node_path.default.join(extDst, pluginDir);
-			if (node_fs.default.existsSync(dst)) {
-				node_fs.default.rmSync(dst, {
-					recursive: true,
-					force: true
-				});
-				log(`  deleted: extensions/${pluginDir}`);
-			}
-		}
-		const configBackup = node_path.default.join(backupDir, "openclaw.json");
-		if (node_fs.default.existsSync(configBackup)) {
-			node_fs.default.copyFileSync(configBackup, configPath);
-			log(`  restored: openclaw.json`);
-		} else log(`  skipped restore: openclaw.json (not in backup — was not present before upgrade)`);
-		for (const pluginDir of FEISHU_PLUGIN_DIRS) {
-			const backupSrc = node_path.default.join(backupDir, "extensions", pluginDir);
-			if (node_fs.default.existsSync(backupSrc)) {
-				node_fs.default.cpSync(backupSrc, node_path.default.join(extDst, pluginDir), { recursive: true });
-				log(`  restored: extensions/${pluginDir}`);
-			} else log(`  skipped restore: extensions/${pluginDir} (not in backup — was not present before upgrade)`);
-		}
-		return true;
-	} catch (e) {
-		log(`  restore error: ${e.message}`);
-		return false;
-	}
-}
-function readPkgVersion(pkgPath) {
-	try {
-		const pkg = JSON.parse(node_fs.default.readFileSync(pkgPath, "utf-8"));
-		return typeof pkg.version === "string" ? pkg.version : null;
-	} catch {
-		return null;
-	}
-}
 function snapshotVersions(cwd, log) {
 	const ocResult = (0, node_child_process.spawnSync)("openclaw", ["--version"], {
 		cwd,
@@ -11738,7 +12043,7 @@ function runUpgradeLark(opts) {
 	log("── [1/6] 文件备份 ────────────────────────────────────────");
 	log(`before-state: botCount=${countFeishuBots(configPath)}`);
 	const t_backupStart = Date.now();
-	const backup = backupFiles(fsOpts);
+	const backup = backupFeishuPlugins(fsOpts);
 	timing.backupMs = Date.now() - t_backupStart;
 	if (!backup.ok) {
 		log(`ERROR: ${backup.error}`);
@@ -11765,27 +12070,11 @@ function runUpgradeLark(opts) {
 	log("");
 	log("── [3/6] npx install (@larksuite/openclaw-lark-tools update) ──");
 	const t_npxStart = Date.now();
-	const npxResult = (0, node_child_process.spawnSync)("npx", [
-		"-y",
-		"@larksuite/openclaw-lark-tools",
-		"update"
-	], {
+	const { exitCode: npxExitCode, stdout: npxStdout, stderr: npxStderr } = runLarkToolsUpdate({
 		cwd,
-		encoding: "utf-8",
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		],
-		timeout: 6e5
+		log
 	});
 	timing.npxInstallMs = Date.now() - t_npxStart;
-	const npxStdout = npxResult.stdout?.trim() ?? "";
-	const npxStderr = npxResult.stderr?.trim() ?? "";
-	const npxExitCode = npxResult.status ?? 1;
-	if (npxStdout) log(`npx stdout:\n${npxStdout}`);
-	if (npxStderr) log(`npx stderr:\n${npxStderr}`);
-	log(`npx exit: ${npxExitCode}${npxResult.error ? ` error: ${npxResult.error.message}` : ""}`);
 	if (statusCheckDelayMs > 0) {
 		log("");
 		log(`── 等待 ${statusCheckDelayMs / 1e3}s（让 openclaw 服务完成重启） ─────────────`);
@@ -11794,7 +12083,7 @@ function runUpgradeLark(opts) {
 	}
 	const doRollback = (reason) => {
 		log(`ERROR: ${reason}`);
-		const rollbackOk = restoreFiles(fsOpts);
+		const rollbackOk = restoreFeishuPlugins(fsOpts);
 		log(`rollback: ${rollbackOk ? "ok" : "FAILED"}`);
 		return finalReturn({
 			status: "failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/openclaw-scripts-diagnose-cli",
-  "version": "0.1.17",
+  "version": "0.1.18-alpha.1",
   "description": "CLI for OpenClaw config diagnose and repair with JSON5 support",
   "main": "dist/index.cjs",
   "bin": {