@lark-apaas/openclaw-scripts-diagnose-cli 0.1.1-alpha.17 → 0.1.1-alpha.18

package/dist/index.cjs

@@ -996,20 +996,6 @@ function runRepair(input) {
 	}
 }
 //#endregion
-//#region src/logger.ts
-function makeLogger(logFile) {
-	try {
-		const dir = node_path.default.dirname(logFile);
-		if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
-	} catch {}
-	return (msg) => {
-		const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}\n`;
-		try {
-			node_fs.default.appendFileSync(logFile, line);
-		} catch {}
-	};
-}
-//#endregion
 //#region src/paths.ts
 /**
 * Central directory for all ephemeral diagnose/reset artifacts: task status
@@ -1017,10 +1003,6 @@ function makeLogger(logFile) {
 * (`reset-<taskId>.log`). Having everything under one dir makes debugging a
 * stuck reset much easier — `ls /tmp/openclaw-diagnose/` shows every recent
 * run, and each run's log is right next to its state.
-*
-* This dir is ephemeral (/tmp). Long-lived artifacts (e.g. core-backup.json
-* used by reset to restore agents/bindings) live under the agent's .spark/
-* directory instead, see CORE_BACKUP_PATH in reset.ts.
 */
 const DIAGNOSE_DIR = "/tmp/openclaw-diagnose";
 function resetResultFile(taskId) {
@@ -1029,131 +1011,19 @@ function resetResultFile(taskId) {
 function resetLogFile(taskId) {
 	return `${DIAGNOSE_DIR}/reset-${taskId}.log`;
 }
-function backupLogFile(taskId) {
-	return `${DIAGNOSE_DIR}/backup-${taskId}.log`;
-}
 //#endregion
-//#region src/backup.ts
-const BACKUP_PATH = "/home/gem/workspace/agent/.spark/core-backup.json";
-/**
-* Async entry: spawn a detached worker that does the actual backup, return
-* immediately with `{success: true}` (or `{success: false}` if spawn itself
-* fails). The caller (Go side) treats backup as fire-and-forget, so it doesn't
-* need to wait for completion. Each run gets a per-task log under
-* /tmp/openclaw-diagnose/backup-<taskId>.log for postmortem debugging.
-*/
-function startAsyncBackup(ctxBase64) {
-	const taskId = (0, node_crypto.randomUUID)();
-	const log = makeLogger(backupLogFile(taskId));
-	log(`=== startAsyncBackup spawning worker for taskId=${taskId} ===`);
-	try {
-		const child = (0, node_child_process.spawn)(process.execPath, [
-			process.argv[1],
-			"backup",
-			"--worker",
-			`--task-id=${taskId}`,
-			`--ctx=${ctxBase64}`
-		], {
-			detached: true,
-			stdio: "ignore"
-		});
-		child.on("error", (err) => {
-			log(`FATAL worker failed to start: ${err.message}`);
-		});
-		child.unref();
-		log(`spawned worker pid=${child.pid}`);
-		return {
-			success: true,
-			taskId
-		};
-	} catch (e) {
-		log(`spawn threw: ${e.message}`);
-		return {
-			success: false,
-			error: "spawn backup worker failed: " + e.message,
-			taskId
-		};
-	}
-}
-/**
-* Worker: actually do the backup. Each step is logged so a stuck or failing
-* backup can be diagnosed by `cat /tmp/openclaw-diagnose/backup-<taskId>.log`.
-*
-* The real time sink here is `openclaw config validate --json` which can sit
-* for tens of seconds when the sandbox is under load — that's why backup is
-* async (Go callers don't have to block waiting on it).
-*/
-function runBackup(input, taskId) {
-	const log = taskId ? makeLogger(backupLogFile(taskId)) : (() => {});
-	const startedAt = Date.now();
-	log(`=== runBackup started, configPath=${input.configPath}, pid=${process.pid} ===`);
+//#region src/logger.ts
+function makeLogger(logFile) {
 	try {
-		const { configPath } = input;
-		log("step 1: openclaw config validate --json");
-		const t1 = Date.now();
-		let validation;
+		const dir = node_path.default.dirname(logFile);
+		if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+	} catch {}
+	return (msg) => {
+		const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}\n`;
 		try {
-			const validateOutput = shell("openclaw config validate --json");
-			validation = JSON.parse(validateOutput);
-		} catch (e) {
-			const msg = "config validate command failed: " + e.message;
-			log(`step 1 FAIL after ${Date.now() - t1}ms: ${msg}`);
-			return {
-				success: false,
-				error: msg
-			};
-		}
-		log(`step 1 done in ${Date.now() - t1}ms, valid=${validation.valid}`);
-		if (!validation.valid) return {
-			success: false,
-			error: "config validation failed"
-		};
-		log("step 2: read + parse config");
-		if (!fileExists(configPath)) {
-			const msg = "config file not found: " + configPath;
-			log(`step 2 FAIL: ${msg}`);
-			return {
-				success: false,
-				error: msg
-			};
-		}
-		const config = loadJSON5().parse(readFile(configPath));
-		const backup = { _backup_meta: { created_at: (/* @__PURE__ */ new Date()).toISOString() } };
-		const kept = [];
-		if (config.agents) {
-			backup.agents = config.agents;
-			kept.push("agents");
-		}
-		if (config.bindings) {
-			backup.bindings = config.bindings;
-			kept.push("bindings");
-		}
-		if (config.tools) {
-			backup.tools = config.tools;
-			kept.push("tools");
-		}
-		const feishu = config.channels?.feishu;
-		if (feishu?.accounts) {
-			backup.channels = { feishu: { accounts: feishu.accounts } };
-			kept.push("channels.feishu.accounts");
-		}
-		log(`step 3: extracted [${kept.join(", ") || "nothing"}]`);
-		const backupDir = node_path.default.dirname(BACKUP_PATH);
-		if (!node_fs.default.existsSync(backupDir)) node_fs.default.mkdirSync(backupDir, { recursive: true });
-		const tmpPath = BACKUP_PATH + ".tmp";
-		node_fs.default.writeFileSync(tmpPath, JSON.stringify(backup, null, 2), "utf-8");
-		node_fs.default.renameSync(tmpPath, BACKUP_PATH);
-		log(`step 4: wrote ${BACKUP_PATH} (${JSON.stringify(backup).length} bytes)`);
-		log(`=== runBackup completed in ${Date.now() - startedAt}ms ===`);
-		return { success: true };
-	} catch (e) {
-		const msg = "backup failed: " + e.message;
-		log(`FATAL after ${Date.now() - startedAt}ms: ${msg}\n${e.stack ?? ""}`);
-		return {
-			success: false,
-			error: msg
-		};
-	}
+			node_fs.default.appendFileSync(logFile, line);
+		} catch {}
+	};
 }
 //#endregion
 //#region src/reset-async.ts
@@ -1215,14 +1085,15 @@ const STEPS = [
 	"生成默认配置",
 	"杀掉 openclaw 进程",
 	"等待沙箱初始化完成",
-	"重装 openclaw",
+	"确认 openclaw 版本",
 	"合并核心备份配置",
 	"复制启动脚本",
-	"重装内置插件",
+	"安装扩展",
 	"启动并验证"
 ];
 const TOTAL_STEPS = STEPS.length;
-const CORE_BACKUP_PATH = "/home/gem/workspace/agent/.spark/core-backup.json";
+/** Pre-packed extensions archive on OSS. Update this URL when releasing a new version. */
+const EXTENSIONS_OSS_URL = "https://miaoda-template-online.oss-cn-beijing.aliyuncs.com/builtin/tool/pkg/openclaw-extensions-2026.4.9.tar.gz";
 /**
 * Directory holding the bundled openclaw template (openclaw.json + scripts/).
 * Synced from git@code.byted.org:apaas/miaoda-openclaw-template.git via
@@ -1347,33 +1218,48 @@ function waitForInitNpm(maxWaitMs, log) {
 /**
 * Step 5: Ensure openclaw binary is at the template's recommended version.
 *
-* Fast path (common): if `openclaw --version` already matches the version
-* declared in the bundled template's openclaw.json, skip uninstall+install
-* entirely and just run `openclaw doctor --fix` to realign config state.
-*
-* Slow path (rare — only triggers if version mismatched or binary missing):
-* uninstall + reinstall + doctor --fix. This is intentionally kept as a
-* last resort because a transitive dep (matrix-sdk-crypto-nodejs) runs a
-* postinstall hook that downloads a 22MB native binary from GitHub
-* Releases, and the BOE sandbox's egress to objects.githubusercontent.com
-* is throttled to ~10KB/s — a full reinstall can legitimately take 30+
-* minutes. Hence we only pay that cost when version actually needs to change.
+* Only checks/installs the binary — does NOT run `doctor --fix` any more.
+* Extensions are installed separately via OSS tar.gz (Step 8), which means
+* the openclaw-lark extension schema is already in place when openclaw
+* starts, avoiding the schema-priority mismatch that caused doctor to
+* reject valid config fields like threadSession / footer.
 */
-function reinstallOpenclaw(srcDir, log) {
+function ensureOpenclawBinary(srcDir, log) {
 	const targetVersion = loadJSON5().parse(node_fs.default.readFileSync(node_path.default.join(srcDir, "openclaw.json"), "utf-8")).meta?.lastTouchedVersion;
 	log(`target openclaw version: ${targetVersion ?? "<unset>"}`);
 	if (targetVersion && isOpenclawAtVersion(targetVersion)) {
-		log("fast path: openclaw already at target version, skipping uninstall+install");
-		const t = Date.now();
-		shell("openclaw doctor --fix", 10 * 6e4);
-		log(`doctor --fix done in ${Date.now() - t}ms`);
+		log("openclaw already at target version, nothing to do");
 		return;
 	}
-	log("version mismatched or binary missing, running full reinstall (may take 30+ min under slow network)");
-	try {
+	if (isOpenclawInstalled()) {
+		const updateCmd = `openclaw update${targetVersion ? " --tag v" + targetVersion : ""}`;
+		log(`openclaw installed but version mismatched, running: ${updateCmd}`);
 		const t = Date.now();
+		try {
+			shell(updateCmd, 10 * 6e4);
+			log(`openclaw update done in ${Date.now() - t}ms`);
+		} catch (e) {
+			log(`openclaw update failed after ${Date.now() - t}ms: ${e.message}, falling back to full reinstall`);
+			fullReinstall(targetVersion, log);
+		}
+	} else {
+		log("openclaw binary not found, running full reinstall");
+		fullReinstall(targetVersion, log);
+	}
+}
+/** Check if openclaw command exists (regardless of version). */
+function isOpenclawInstalled() {
+	try {
+		shell("which openclaw 2>/dev/null", 5e3);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Full uninstall + reinstall from npm (slow path, triggers postinstall). */
+function fullReinstall(targetVersion, log) {
+	try {
 		shell("npm uninstall -g openclaw 2>/dev/null || true", 6e4);
-		log(`npm uninstall done in ${Date.now() - t}ms`);
 	} catch {}
 	try {
 		shell("rm -rf /home/gem/.npm-global/lib/node_modules/openclaw /home/gem/.npm-global/bin/openclaw 2>/dev/null || true", 1e4);
@@ -1381,12 +1267,9 @@ function reinstallOpenclaw(srcDir, log) {
 	} catch {}
 	const installCmd = `npm i -g openclaw@${targetVersion || "latest"}`;
 	log(`running: ${installCmd}`);
-	const installStart = Date.now();
+	const t = Date.now();
 	shell(installCmd, 30 * 6e4);
-	log(`npm install done in ${Date.now() - installStart}ms`);
-	const docStart = Date.now();
-	shell("openclaw doctor --fix", 10 * 6e4);
-	log(`doctor --fix done in ${Date.now() - docStart}ms`);
+	log(`npm install done in ${Date.now() - t}ms`);
 }
 /** Return true if `openclaw --version` output contains `targetVersion`. */
 function isOpenclawAtVersion(targetVersion) {
@@ -1396,42 +1279,60 @@ function isOpenclawAtVersion(targetVersion) {
 		return false;
 	}
 }
-/** Step 6: Merge core-backup.json into config + ensure allowedOrigins. */
-function mergeCoreBackupAndOrigins(configPath, vars, log) {
+/** Step 6: Merge coreBackup from resetData + ensure allowedOrigins. */
+function mergeCoreBackupAndOrigins(configPath, vars, resetData, log) {
 	const JSON5 = loadJSON5();
-	if (fileExists(CORE_BACKUP_PATH)) {
-		const backup = JSON.parse(node_fs.default.readFileSync(CORE_BACKUP_PATH, "utf-8"));
+	const backup = resetData.coreBackup;
+	if (backup) {
 		const config = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
 		const merged = [];
-		if (backup.agents) {
-			config.agents = backup.agents;
-			merged.push("agents");
+		if (backup.agents && backup.agents.length > 0) {
+			if (!config.agents) config.agents = {};
+			const agents = config.agents;
+			if (!Array.isArray(agents.list)) agents.list = [];
+			agents.list.push(...backup.agents);
+			merged.push(`agents(+${backup.agents.length})`);
+			const list = agents.list;
+			const mainIdx = list.findIndex((a) => a.id === "main");
+			if (mainIdx >= 0) {
+				list[mainIdx].subagents = { allowAgents: ["*"] };
+				list[mainIdx].default = true;
+				merged.push("main-team-mode");
+			}
+			const feishu = config.channels?.feishu;
+			if (feishu) {
+				if (!feishu.accounts) feishu.accounts = {};
+				const accounts = feishu.accounts;
+				const defaultAccount = {};
+				for (const key of [
+					"dmPolicy",
+					"allowFrom",
+					"groupPolicy",
+					"groupAllowFrom"
+				]) if (feishu[key] !== void 0) defaultAccount[key] = feishu[key];
+				if (Object.keys(defaultAccount).length > 0) {
+					accounts.default = defaultAccount;
+					merged.push("accounts.default");
+				}
+			}
 		}
-		if (backup.bindings) {
+		if (backup.bindings && backup.bindings.length > 0) {
 			config.bindings = backup.bindings;
 			merged.push("bindings");
 		}
-		const backupAccounts = backup.channels?.feishu;
-		if (backupAccounts?.accounts) {
+		const backupAccounts = backup.channels?.feishu?.accounts;
+		if (backupAccounts && Object.keys(backupAccounts).length > 0) {
 			if (!config.channels) config.channels = {};
 			const ch = config.channels;
 			if (!ch.feishu) ch.feishu = {};
-			ch.feishu.accounts = backupAccounts.accounts;
+			const feishu = ch.feishu;
+			if (!feishu.accounts) feishu.accounts = {};
+			Object.assign(feishu.accounts, backupAccounts);
 			merged.push("channels.feishu.accounts");
 		}
-		const backupDeny = backup.tools?.deny;
-		if ((Array.isArray(backupDeny) ? backupDeny.filter((o) => typeof o === "string") : []).includes("agents_list")) {
-			if (!config.tools) config.tools = {};
-			const tools = config.tools;
-			const currentDeny = Array.isArray(tools.deny) ? tools.deny.filter((o) => typeof o === "string") : [];
-			if (!currentDeny.includes("agents_list")) {
-				tools.deny = [...currentDeny, "agents_list"];
-				merged.push("tools.deny+=agents_list");
-			}
-		}
 		node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-		log(`merged from ${CORE_BACKUP_PATH}: [${merged.join(", ") || "nothing"}]`);
-	} else log(`no backup at ${CORE_BACKUP_PATH}, skip merge`);
+		log(`merged from coreBackup: [${merged.join(", ") || "nothing"}]`);
+	} else log("no coreBackup in resetData, skip multi-agent merge");
 	const expectedOrigins = Array.isArray(vars.expectedOrigins) ? vars.expectedOrigins : [];
 	if (expectedOrigins.length === 0) {
 		log("no expectedOrigins provided");
@@ -1472,20 +1373,69 @@ function copyStartupScripts(srcDir, configDir, log) {
 	log(`copied scripts/* -> ${targetScriptsDir}`);
 }
 /**
-* Step 8: Reinstall all plugins via openclaw CLI.
+* Step 8: Install extensions from OSS tar.gz or fall back to `openclaw plugins update`.
+*
+*   1. Derive the OSS URL from the openclaw version in the template config
+*   2. Download tar.gz → extract to a staging dir
+*   3. For each included extension, backup (mv) the user's existing copy
+*      to a temp dir — extensions NOT in the archive are left untouched
+*   4. Move the fresh extensions from staging to the target dir
 *
-* Simple execSync with a generous wall-clock timeout (15min). By now
-* init_sandbox's npm should have finished (Step 4 waited for it), so we
-* have exclusive npm access. Non-fatal — a plugin update failure shouldn't
-* stop the reset from restarting the gateway.
+* This bypasses npm entirely and avoids the schema-priority mismatch where
+* `openclaw doctor --fix` would validate config against the bundled feishu
+* plugin's strict schema before openclaw-lark is installed.
+*
+* Falls back to `openclaw plugins update --all` if the OSS download fails.
 */
-function reinstallPlugins(log) {
-	const t = Date.now();
+function installExtensions(configDir, log) {
+	const ossUrl = EXTENSIONS_OSS_URL;
+	const targetExtDir = node_path.default.join(configDir, "extensions");
+	const tmpBase = `/tmp/openclaw-ext-reset-${Date.now()}`;
+	const stagingDir = node_path.default.join(tmpBase, "staging");
+	const backupDir = node_path.default.join(tmpBase, "backup");
+	const tarPath = node_path.default.join(tmpBase, "extensions.tar.gz");
+	node_fs.default.mkdirSync(stagingDir, { recursive: true });
+	node_fs.default.mkdirSync(backupDir, { recursive: true });
 	try {
-		shell("openclaw plugins update --all", 15 * 6e4);
-		log(`plugins update --all done in ${Date.now() - t}ms`);
-	} catch (e) {
-		log(`plugins update failed after ${Date.now() - t}ms: ${e.message} (non-fatal, continuing)`);
+		log(`downloading extensions from ${ossUrl}`);
+		const dlStart = Date.now();
+		shell(`curl -fsSL '${ossUrl}' -o '${tarPath}'`, 5 * 6e4);
+		const size = node_fs.default.statSync(tarPath).size;
+		log(`download done in ${Date.now() - dlStart}ms (${(size / 1024 / 1024).toFixed(1)}MB)`);
+		shell(`tar -xzf '${tarPath}' -C '${stagingDir}'`, 6e4);
+		const stagedExtDir = node_path.default.join(stagingDir, "extensions");
+		if (!node_fs.default.existsSync(stagedExtDir)) throw new Error("tar.gz does not contain an extensions/ directory");
+		const extNames = node_fs.default.readdirSync(stagedExtDir).filter((name) => node_fs.default.statSync(node_path.default.join(stagedExtDir, name)).isDirectory());
+		log(`archive contains ${extNames.length} extension(s): ${extNames.join(", ")}`);
+		if (!node_fs.default.existsSync(targetExtDir)) node_fs.default.mkdirSync(targetExtDir, { recursive: true });
+		for (const name of extNames) {
+			const target = node_path.default.join(targetExtDir, name);
+			const staged = node_path.default.join(stagedExtDir, name);
+			if (node_fs.default.existsSync(target)) {
+				const backupDest = node_path.default.join(backupDir, name);
+				node_fs.default.renameSync(target, backupDest);
+				log(`  ${name}: backed up existing to ${backupDest}`);
+			}
+			node_fs.default.renameSync(staged, target);
+			log(`  ${name}: installed`);
+		}
+		const packinfo = node_path.default.join(stagedExtDir, ".packinfo.json");
+		if (node_fs.default.existsSync(packinfo)) {
+			const info = node_fs.default.readFileSync(packinfo, "utf-8");
+			node_fs.default.copyFileSync(packinfo, node_path.default.join(targetExtDir, ".packinfo.json"));
+			log(`packinfo: ${info.trim()}`);
+		}
+		log("extensions installed from OSS successfully");
+	} finally {
+		try {
+			node_fs.default.unlinkSync(tarPath);
+		} catch {}
+		try {
+			node_fs.default.rmSync(stagingDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
 	}
 }
 /** Step 9: Write secrets/provider key files and restart openclaw. */
@@ -1559,13 +1509,13 @@ function runReset(input, taskId, resultFile) {
 		step(4);
 		waitForInitNpm(10 * 6e4, log);
 		step(5);
-		reinstallOpenclaw(srcDir, log);
+		ensureOpenclawBinary(srcDir, log);
 		step(6);
-		mergeCoreBackupAndOrigins(configPath, vars, log);
+		mergeCoreBackupAndOrigins(configPath, vars, resetData, log);
 		step(7);
 		copyStartupScripts(srcDir, configDir, log);
 		step(8);
-		reinstallPlugins(log);
+		installExtensions(configDir, log);
 		step(9);
 		writeSecretsAndRestart(vars, resetData, configDir, log);
 		log(`step 9 "${STEPS[8]}" done in ${Date.now() - stepStartedAt}ms`);
@@ -1633,18 +1583,6 @@ switch (mode) {
 		else console.log(JSON.stringify(runRepair(input)));
 		break;
 	}
-	case "backup": {
-		const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
-		if (!ctx) {
-			console.error("Error: --ctx=<base64> is required");
-			node_process.default.exit(1);
-		}
-		if (args.includes("--worker")) {
-			const taskId = args.find((a) => a.startsWith("--task-id="))?.slice(10);
-			runBackup(JSON.parse(Buffer.from(ctx, "base64").toString("utf-8")), taskId);
-		} else console.log(JSON.stringify(startAsyncBackup(ctx)));
-		break;
-	}
 	case "reset":
 		if (args.includes("--async")) {
 			const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
@@ -1677,7 +1615,7 @@ switch (mode) {
 		break;
 	}
 	default:
-		console.error("Usage: mclaw-diagnose <check|repair|backup|reset|get_reset_task> [options]");
+		console.error("Usage: mclaw-diagnose <check|repair|reset|get_reset_task> [options]");
 		node_process.default.exit(1);
 }
 //#endregion

package/package.json

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