@lark-apaas/openclaw-scripts-diagnose-cli 0.1.5 → 0.1.6-alpha.1

package/dist/index.cjs

@@ -53,7 +53,7 @@ let json_diff = require("json-diff");
 * it terse and parseable.
 */
 function getVersion() {
-	return "0.1.5";
+	return "0.1.6-alpha.1";
 }
 //#endregion
 //#region src/rule-engine/base.ts
@@ -1381,11 +1381,11 @@ OldMiaodaPluginsCleanupRule = __decorate([Rule({
 //#region src/rules/lark-plugin-allow.ts
 const LARK_PLUGIN = "openclaw-lark";
 const LEGACY_LARK_PLUGIN = "feishu-openclaw-plugin";
-const LARK_PLUGIN_NAMES = [LARK_PLUGIN, LEGACY_LARK_PLUGIN];
+const LARK_PLUGIN_NAMES$1 = [LARK_PLUGIN, LEGACY_LARK_PLUGIN];
 let LarkPluginAllowRule = class LarkPluginAllowRule extends DiagnoseRule {
 	validate(ctx) {
 		const allow = getAllow(ctx.config);
-		if (LARK_PLUGIN_NAMES.some((name) => allow.includes(name))) return { pass: true };
+		if (LARK_PLUGIN_NAMES$1.some((name) => allow.includes(name))) return { pass: true };
 		const installed = detectInstalledLarkPlugin(getExtensionsDir(ctx.configPath));
 		if (installed == null) return { pass: true };
 		return {
@@ -1404,7 +1404,7 @@ let LarkPluginAllowRule = class LarkPluginAllowRule extends DiagnoseRule {
 		const rawAllow = pluginsMap.allow;
 		const original = Array.isArray(rawAllow) ? rawAllow : [];
 		const stringAllow = original.filter((e) => typeof e === "string");
-		if (LARK_PLUGIN_NAMES.some((name) => stringAllow.includes(name))) return;
+		if (LARK_PLUGIN_NAMES$1.some((name) => stringAllow.includes(name))) return;
 		original.push(installed);
 		pluginsMap.allow = original;
 	}
@@ -4210,6 +4210,210 @@ function finalize(results, aborted) {
 	};
 }
 //#endregion
+//#region src/lark-cli-init.ts
+const LARK_PLUGIN_NAMES = ["openclaw-lark", "feishu-openclaw-plugin"];
+const PE_XML_TAG = "lark-pe";
+const PE_PLACEHOLDER = `\n<${PE_XML_TAG}>\n<!-- TODO: replace with actual prompt engineering content -->\n</${PE_XML_TAG}>\n`;
+function isLarkPluginInstalled(configPath) {
+	const extDir = getExtensionsDir(configPath);
+	return LARK_PLUGIN_NAMES.some((name) => {
+		try {
+			return node_fs.default.existsSync(node_path.default.join(extDir, name, "package.json"));
+		} catch {
+			return false;
+		}
+	});
+}
+function isLarkCliAvailable() {
+	try {
+		return (0, node_child_process.spawnSync)("lark-cli", ["--version"], {
+			encoding: "utf-8",
+			timeout: 5e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).status === 0;
+	} catch {
+		return false;
+	}
+}
+function readConfig(configPath) {
+	try {
+		const raw = node_fs.default.readFileSync(configPath, "utf-8");
+		const parsed = loadJSON5().parse(raw);
+		return parsed != null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Resolve the feishu app secret for the given appId.
+*
+* Lookup order:
+*   1. channels.feishu.appSecret  (single-agent: feishu.appId === appId)
+*   2. channels.feishu.accounts[key].appSecret  (multi-agent: account.appId === appId)
+*
+* Value interpretation:
+*   - string  → use directly
+*   - object  → secret is managed by a provider; use `feishuAppSecret` param instead
+*
+* Returns null when the secret cannot be determined.
+*/
+function resolveAppSecret(appId, config, feishuAppSecret) {
+	const feishu = getNestedMap(config, "channels", "feishu");
+	if (!feishu) return null;
+	let rawSecret;
+	if (typeof feishu.appId === "string" && feishu.appId === appId) rawSecret = feishu.appSecret;
+	else {
+		const accounts = asRecord(feishu.accounts);
+		if (accounts) for (const [, val] of Object.entries(accounts)) {
+			const account = asRecord(val);
+			if (account?.appId === appId) {
+				rawSecret = account.appSecret;
+				break;
+			}
+		}
+	}
+	if (typeof rawSecret === "string" && rawSecret) return rawSecret;
+	if (rawSecret != null && typeof rawSecret === "object") return feishuAppSecret ?? null;
+	return null;
+}
+/**
+* Resolve the agents.md path for the given appId from the openclaw config.
+*
+* Case 1: appId matches channels.feishu.appId (single-agent path)
+*   → WORKSPACE_DIR/AGENTS.md
+*
+* Case 2: appId found in channels.feishu.accounts (multi-agent path)
+*   → find account key where account.appId === appId
+*   → find binding where match.channel=feishu && match.accountId=that key
+*   → if agentId === 'main'  → WORKSPACE_DIR/agents.md
+*   → else find agent in agents.list by id → agent.workspace/agents.md
+*
+* Returns null when the path cannot be determined.
+*/
+function resolveAgentsMdPath(appId, config) {
+	const feishu = getNestedMap(config, "channels", "feishu");
+	if (!feishu) return null;
+	if (typeof feishu.appId === "string" && feishu.appId === appId) return node_path.default.join(WORKSPACE_DIR, "AGENTS.md");
+	const accounts = asRecord(feishu.accounts);
+	if (!accounts) return null;
+	let accountId;
+	for (const [key, val] of Object.entries(accounts)) if (asRecord(val)?.appId === appId) {
+		accountId = key;
+		break;
+	}
+	if (!accountId) return null;
+	const bindings = Array.isArray(config.bindings) ? config.bindings : [];
+	let agentId;
+	for (const b of bindings) {
+		const binding = asRecord(b);
+		if (!binding) continue;
+		const match = asRecord(binding.match);
+		if (match?.channel === "feishu" && match?.accountId === accountId) {
+			if (typeof binding.agentId === "string") {
+				agentId = binding.agentId;
+				break;
+			}
+		}
+	}
+	if (!agentId) return null;
+	if (agentId === "main") return node_path.default.join(WORKSPACE_DIR, "agents.md");
+	const agentsObj = asRecord(config.agents);
+	const list = Array.isArray(agentsObj?.list) ? agentsObj.list : [];
+	for (const a of list) {
+		const agent = asRecord(a);
+		if (agent?.id === agentId && typeof agent.workspace === "string") return node_path.default.join(agent.workspace, "agents.md");
+	}
+	return null;
+}
+function appendPeToAgentsMd(agentsMdPath) {
+	const dir = node_path.default.dirname(agentsMdPath);
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+	const existing = node_fs.default.existsSync(agentsMdPath) ? node_fs.default.readFileSync(agentsMdPath, "utf-8") : "";
+	if (existing.includes(`<${PE_XML_TAG}>`)) {
+		console.error(`lark-cli-init: <${PE_XML_TAG}> already present in ${agentsMdPath}, skipping`);
+		return;
+	}
+	const sep = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+	node_fs.default.appendFileSync(agentsMdPath, `${sep}${PE_PLACEHOLDER}`, "utf-8");
+	console.error(`lark-cli-init: appended PE placeholder to ${agentsMdPath}`);
+}
+function runLarkCliInit(opts) {
+	const configPath = opts.configPath ?? CONFIG_PATH;
+	if (!isLarkPluginInstalled(configPath)) {
+		console.error("lark-cli-init: skipping — openclaw-lark plugin not installed");
+		return {
+			ok: true,
+			skipped: true,
+			skipReason: "openclaw-lark plugin not installed"
+		};
+	}
+	if (!isLarkCliAvailable()) {
+		console.error("lark-cli-init: skipping — lark-cli command not found");
+		return {
+			ok: true,
+			skipped: true,
+			skipReason: "lark-cli command not found"
+		};
+	}
+	const config = readConfig(configPath);
+	if (!config) return {
+		ok: false,
+		error: `could not read config at ${configPath}`
+	};
+	const agentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.appId, config);
+	if (!agentsMdPath) return {
+		ok: false,
+		error: `could not resolve agents.md path for appId=${opts.appId}`
+	};
+	console.error(`lark-cli-init: agents.md path=${agentsMdPath}`);
+	const appSecret = resolveAppSecret(opts.appId, config, opts.feishuAppSecret);
+	if (!appSecret) return {
+		ok: false,
+		error: `could not resolve appSecret for appId=${opts.appId}`
+	};
+	console.error(`lark-cli-init: running lark-cli config init --app-id=${opts.appId}`);
+	const initRes = (0, node_child_process.spawnSync)("lark-cli", [
+		"config",
+		"init",
+		"--name",
+		opts.appId,
+		"--app-id",
+		opts.appId,
+		"--brand",
+		"feishu",
+		"--app-secret-stdin"
+	], {
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		encoding: "utf-8",
+		input: appSecret
+	});
+	if (initRes.stdout?.trim()) console.error(`lark-cli config init stdout: ${initRes.stdout.trim()}`);
+	if (initRes.stderr?.trim()) console.error(`lark-cli config init stderr: ${initRes.stderr.trim()}`);
+	if (initRes.error) return {
+		ok: false,
+		error: `lark-cli config init spawn error: ${initRes.error.message}`
+	};
+	if (initRes.status !== 0) return {
+		ok: false,
+		configInitExitCode: initRes.status ?? void 0,
+		error: `lark-cli config init exited with code ${initRes.status}`
+	};
+	appendPeToAgentsMd(agentsMdPath);
+	return {
+		ok: true,
+		configInitExitCode: 0,
+		agentsMdPath
+	};
+}
+//#endregion
 //#region src/innerapi/reportCliRun.ts
 /**
 * CLI-side client for studio_server's `openclaw.report_cli_run` inner
@@ -4289,7 +4493,7 @@ async function reportCliRun(opts) {
 //#region src/help.ts
 const BIN = "mclaw-diagnose";
 function versionBanner() {
-	return `v0.1.5`;
+	return `v0.1.6-alpha.1`;
 }
 const COMMANDS = [
 	{
@@ -4498,6 +4702,58 @@ OPTIONS
   --skip-config-update Leave plugins.installs in openclaw.json untouched.
   --ctx=<base64>       Opaque ctx; see install-openclaw for semantics.
   --oss_file_map=...   Pre-built OSS URL map (base64 JSON).
+`
+	},
+	{
+		name: "lark-cli-init",
+		hidden: false,
+		summary: "Initialize lark-cli bot config and append PE to agents.md",
+		help: `USAGE
+  ${BIN} lark-cli-init --app-id=<app-id> [--feishu-app-secret=<secret>] [--agents-md=<path>]
+
+DESCRIPTION
+  Two-step initialization for a Lark (Feishu) bot when prerequisites are met:
+
+    Prerequisites (both must be satisfied, otherwise the command exits 0 with
+    skipped=true and no side effects):
+      1. openclaw-lark plugin installed under extensions/.
+      2. lark-cli command available on PATH.
+
+  The app secret is resolved from config before running lark-cli:
+    - channels.feishu.appSecret (single-agent) or
+      channels.feishu.accounts[key].appSecret (multi-agent, matched by appId)
+    - If the value is a plain string → used directly.
+    - If the value is a provider-ref object → --feishu-app-secret must be supplied.
+
+  Step 1 — lark-cli config init:
+    Pipes the resolved secret via stdin and runs:
+      lark-cli config init \\
+        --name <app-id> \\
+        --app-id <app-id> \\
+        --brand feishu \\
+        --app-secret-stdin
+
+  Step 2 — append PE to agents.md:
+    Resolves the target agents.md from config (see path resolution below)
+    and appends a <lark-pe> placeholder block (idempotent: skipped if already present).
+
+  agents.md path resolution:
+    - channels.feishu.appId === appId  → WORKSPACE/AGENTS.md  (single-agent)
+    - accounts[key].appId === appId    → look up binding by accountId:
+        agentId === 'main'             → WORKSPACE/agents.md
+        otherwise                     → agents.list[agentId].workspace/agents.md
+
+ARGUMENTS
+  --app-id=<app-id>              Required. Bot app ID, e.g. cli_a9659e1f0ab89ccd.
+
+OPTIONS
+  --feishu-app-secret=<secret>   Required when config stores appSecret as a
+                                 provider-ref object (ctx.vars.feishuAppSecret).
+  --agents-md=<path>             Override the resolved agents.md path.
+
+EXIT CODES
+  0    Success or skipped (prerequisites not met).
+  1    Secret/path unresolvable, lark-cli failed, or config unreadable.
 `
 	},
 	{
@@ -4977,6 +5233,26 @@ async function main() {
 			if (error) throw error;
 			break;
 		}
+		case "lark-cli-init": {
+			const appId = getFlag(args, "app-id");
+			if (!appId) {
+				console.error("Usage: lark-cli-init --app-id=<app-id> [--agents-md=<path>]");
+				node_process.default.exit(1);
+			}
+			const result = runLarkCliInit({
+				appId,
+				agentsMdPath: getFlag(args, "agents-md"),
+				feishuAppSecret: getFlag(args, "feishu-app-secret")
+			});
+			console.error(`lark-cli-init: result=${JSON.stringify(result)}`);
+			await reportRun("lark-cli-init", rc, void 0, args.join(" "), Date.now() - t0, {
+				success: result.ok,
+				result,
+				error: result.ok ? void 0 : new Error(result.error ?? "lark-cli-init failed")
+			});
+			if (!result.ok) node_process.default.exit(1);
+			break;
+		}
 		default:
 			node_process.default.stderr.write(`Unknown command: ${mode}\n\n`);
 			node_process.default.stderr.write(formatTopLevelHelp(helpFlags.expert));

package/package.json

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