@lark-apaas/openclaw-scripts-diagnose-cli 0.1.1-alpha.13 → 0.1.1-alpha.15

package/dist/index.cjs

@@ -245,11 +245,15 @@ function findBackupFiles(configPath) {
 }
 /**
 * Among backup files, find the one with the highest numeric suffix.
-* `.bak` (no number) is treated as 0, `.bak1` as 1, `.bak2` as 2, etc.
+* Supports all three naming styles used by the current backup code and its
+* older variants:
+*   `.bak`      → n = 0  (legacy single-slot backup)
+*   `.bakN`     → n = N  (older style, dot-less)
+*   `.bak.N`    → n = N  (current style written by reset Step 1)
 */
 function findHighestBackup(backupFiles) {
 	if (backupFiles.length === 0) return null;
-	const bakRegex = /\.bak(\d*)$/;
+	const bakRegex = /\.bak\.?(\d*)$/;
 	let best = null;
 	for (const f of backupFiles) {
 		const match = bakRegex.exec(f);
@@ -992,81 +996,166 @@ 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
+* files (`reset-<taskId>.json`) and human-readable step logs
+* (`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) {
+	return `${DIAGNOSE_DIR}/reset-${taskId}.json`;
+}
+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";
-function runBackup(input) {
+/**
+* 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} ===`);
 	try {
 		const { configPath } = input;
+		log("step 1: openclaw config validate --json");
+		const t1 = Date.now();
+		let validation;
 		try {
 			const validateOutput = shell("openclaw config validate --json");
-			if (!JSON.parse(validateOutput).valid) return {
-				success: false,
-				error: "config validation failed"
-			};
+			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: "config validate command failed: " + e.message
+				error: msg
 			};
 		}
-		if (!fileExists(configPath)) return {
+		log(`step 1 done in ${Date.now() - t1}ms, valid=${validation.valid}`);
+		if (!validation.valid) return {
 			success: false,
-			error: "config file not found: " + configPath
+			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() } };
-		if (config.agents) backup.agents = config.agents;
-		if (config.bindings) backup.bindings = config.bindings;
+		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 } };
+		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: "backup failed: " + e.message
+			error: msg
 		};
 	}
 }
 //#endregion
-//#region src/paths.ts
-/**
-* Central directory for all ephemeral diagnose/reset artifacts: task status
-* files (`reset-<taskId>.json`) and human-readable step logs
-* (`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) {
-	return `${DIAGNOSE_DIR}/reset-${taskId}.json`;
-}
-function resetLogFile(taskId) {
-	return `${DIAGNOSE_DIR}/reset-${taskId}.log`;
-}
-//#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/reset-async.ts
 /**
 * Start an async reset task: spawn a detached child process and return the taskId.
@@ -1256,34 +1345,40 @@ function waitForInitNpm(maxWaitMs, log) {
 	log(`deadline (${maxWaitMs}ms) hit after ${polls} poll(s), proceeding anyway`);
 }
 /**
-* Step 5: Reinstall openclaw to the version specified in template.
+* 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.
 *
-* Simple: if already at target version, skip. Otherwise uninstall+install
-* with a generous wall-clock timeout and trust npm's exit code (0 = success,
-* anything else = real failure, bubble up and fail the reset). No retries,
-* no idle-detection heuristics — waitForInitNpm above removes the main
-* source of contention so this step should run cleanly.
+* 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.
 */
 function reinstallOpenclaw(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: already at target version, running doctor --fix only");
+		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`);
 		return;
 	}
-	log("target version missing or mismatched, running full reinstall");
+	log("version mismatched or binary missing, running full reinstall (may take 30+ min under slow network)");
 	try {
 		const t = Date.now();
 		shell("npm uninstall -g openclaw 2>/dev/null || true", 6e4);
 		log(`npm uninstall done in ${Date.now() - t}ms`);
 	} catch {}
-	const installCmd = `npm i -g openclaw@${targetVersion || "latest"} --prefer-offline --fetch-timeout=60000 --fetch-retries=2`;
+	const installCmd = `npm i -g openclaw@${targetVersion || "latest"} --prefer-offline`;
 	log(`running: ${installCmd}`);
 	const installStart = Date.now();
-	shell(installCmd, 15 * 6e4);
+	shell(installCmd, 30 * 6e4);
 	log(`npm install done in ${Date.now() - installStart}ms`);
 	const docStart = Date.now();
 	shell("openclaw doctor --fix", 10 * 6e4);
@@ -1320,6 +1415,16 @@ function mergeCoreBackupAndOrigins(configPath, vars, log) {
 			ch.feishu.accounts = backupAccounts.accounts;
 			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`);
@@ -1530,8 +1635,10 @@ switch (mode) {
 			console.error("Error: --ctx=<base64> is required");
 			node_process.default.exit(1);
 		}
-		const input = JSON.parse(Buffer.from(ctx, "base64").toString("utf-8"));
-		console.log(JSON.stringify(runBackup(input)));
+		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":

package/package.json

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