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

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.0";
 }
 //#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);
@@ -5159,6 +5228,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 +5262,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 +5352,147 @@ 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 backupDir = node_path.default.join(homeBase, `.openclaw-lark-backup-${tag}`);
+	const backupOk = backupLarkPlugin({
+		workspaceDir,
+		configPath,
+		backupDir
+	});
+	if (!backupOk) console.error("[install-extension] WARN: backup failed — proceeding without backup for openclaw-lark-tools path");
+	try {
+		const npxResult = (0, node_child_process.spawnSync)("npx", [
+			"-y",
+			"@larksuite/openclaw-lark-tools",
+			"update"
+		], {
+			cwd: workspaceDir,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: 6e5
+		});
+		const npxExit = npxResult.status ?? 1;
+		if (npxResult.stdout?.trim()) console.error(`[install-extension] openclaw-lark-tools stdout:\n${npxResult.stdout.trim()}`);
+		if (npxResult.stderr?.trim()) console.error(`[install-extension] openclaw-lark-tools stderr:\n${npxResult.stderr.trim()}`);
+		console.error(`[install-extension] openclaw-lark-tools exit: ${npxExit}`);
+		if (npxExit !== 0) {
+			console.error("[install-extension] openclaw-lark-tools failed — attempting rollback");
+			if (backupOk) restoreLarkPlugin({
+				workspaceDir,
+				configPath,
+				backupDir
+			});
+			throw new Error(`openclaw-lark-tools update exited with code ${npxExit}`);
+		}
+		const validation = validateLarkPluginInstall({
+			homeBase,
+			configPath
+		});
+		if (!validation.ok) {
+			console.error(`[install-extension] post-install validation failed: ${validation.error} — rolling back`);
+			if (backupOk) restoreLarkPlugin({
+				workspaceDir,
+				configPath,
+				backupDir
+			});
+			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 {}
+	}
+}
+function backupLarkPlugin(opts) {
+	const { workspaceDir, configPath, backupDir } = opts;
+	try {
+		node_fs.default.mkdirSync(backupDir, { recursive: true });
+		if (node_fs.default.existsSync(configPath)) node_fs.default.copyFileSync(configPath, node_path.default.join(backupDir, "openclaw.json"));
+		const pluginSrc = node_path.default.join(workspaceDir, "extensions", LARK_PLUGIN_NAME$1);
+		if (node_fs.default.existsSync(pluginSrc)) node_fs.default.cpSync(pluginSrc, node_path.default.join(backupDir, LARK_PLUGIN_NAME$1), { recursive: true });
+		return true;
+	} catch (e) {
+		console.error(`[install-extension] backup error: ${e.message}`);
+		return false;
+	}
+}
+function restoreLarkPlugin(opts) {
+	const { workspaceDir, configPath, backupDir } = opts;
+	try {
+		const configBak = node_path.default.join(backupDir, "openclaw.json");
+		if (node_fs.default.existsSync(configBak)) node_fs.default.copyFileSync(configBak, configPath);
+		const pluginBak = node_path.default.join(backupDir, LARK_PLUGIN_NAME$1);
+		const pluginDst = node_path.default.join(workspaceDir, "extensions", LARK_PLUGIN_NAME$1);
+		if (node_fs.default.existsSync(pluginBak)) {
+			if (node_fs.default.existsSync(pluginDst)) node_fs.default.rmSync(pluginDst, {
+				recursive: true,
+				force: true
+			});
+			node_fs.default.cpSync(pluginBak, pluginDst, { recursive: true });
+		}
+		console.error("[install-extension] rollback complete");
+	} catch (e) {
+		console.error(`[install-extension] rollback error: ${e.message}`);
+	}
+}
+/**
+* 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 +6776,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 +6865,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 +7040,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 +11011,7 @@ async function reportCliRun(opts) {
 //#region src/help.ts
 const BIN = "mclaw-diagnose";
 function versionBanner() {
-	return `v0.1.17`;
+	return `v0.1.18-alpha.0`;
 }
 const COMMANDS = [
 	{

package/package.json

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