@lark-apaas/openclaw-scripts-diagnose-cli 0.1.1-alpha.12 → 0.1.1-alpha.14

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,43 +996,162 @@ 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/.force/openclaw/core-backup.json";
-function runBackup(input) {
+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} ===`);
 	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
 		};
 	}
 }
@@ -1041,7 +1164,9 @@ function runBackup(input) {
 */
 function startAsyncReset(ctxBase64) {
 	const taskId = (0, node_crypto.randomUUID)();
-	const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
+	const resultFile = resetResultFile(taskId);
+	const log = makeLogger(resetLogFile(taskId));
+	log(`=== startAsyncReset spawning worker for taskId=${taskId} ===`);
 	const initial = {
 		status: "running",
 		step: 0,
@@ -1065,6 +1190,7 @@ function startAsyncReset(ctxBase64) {
 		stdio: "ignore"
 	});
 	child.on("error", (err) => {
+		log(`FATAL worker failed to start: ${err.message}`);
 		const failResult = {
 			status: "failed",
 			step: 0,
@@ -1079,6 +1205,7 @@ function startAsyncReset(ctxBase64) {
 		node_fs.default.renameSync(errTmpPath, resultFile);
 	});
 	child.unref();
+	log(`spawned worker pid=${child.pid}`);
 	return { taskId };
 }
 //#endregion
@@ -1095,7 +1222,7 @@ const STEPS = [
 	"启动并验证"
 ];
 const TOTAL_STEPS = STEPS.length;
-const CORE_BACKUP_PATH = "/home/gem/workspace/.force/openclaw/core-backup.json";
+const CORE_BACKUP_PATH = "/home/gem/workspace/agent/.spark/core-backup.json";
 /**
 * Directory holding the bundled openclaw template (openclaw.json + scripts/).
 * Synced from git@code.byted.org:apaas/miaoda-openclaw-template.git via
@@ -1142,8 +1269,11 @@ function markFailed(resultFile, step, error, startedAt) {
 	});
 }
 /** Step 1: Backup current config as openclaw.json.bak.N */
-function backupCurrentConfig(configPath) {
-	if (!fileExists(configPath)) return;
+function backupCurrentConfig(configPath, log) {
+	if (!fileExists(configPath)) {
+		log("no existing config, skip backup");
+		return;
+	}
 	const dir = node_path.default.dirname(configPath);
 	let maxN = 0;
 	try {
@@ -1155,22 +1285,31 @@ function backupCurrentConfig(configPath) {
 			}
 		}
 	} catch {}
-	node_fs.default.copyFileSync(configPath, configPath + ".bak." + (maxN + 1));
+	const bakPath = configPath + ".bak." + (maxN + 1);
+	node_fs.default.copyFileSync(configPath, bakPath);
+	log(`backed up to ${bakPath}`);
 }
 /** Step 2: Replace $$__XXX__ placeholders and write default config. */
-function generateDefaultConfig(srcDir, configPath, templateVars) {
+function generateDefaultConfig(srcDir, configPath, templateVars, log) {
 	const srcConfigPath = node_path.default.join(srcDir, "openclaw.json");
 	if (!fileExists(srcConfigPath)) throw new Error("template openclaw.json not found at " + srcConfigPath);
 	let content = node_fs.default.readFileSync(srcConfigPath, "utf-8");
-	for (const [placeholder, value] of Object.entries(templateVars)) content = content.split(placeholder).join(value);
+	let replaced = 0;
+	for (const [placeholder, value] of Object.entries(templateVars)) {
+		const parts = content.split(placeholder);
+		if (parts.length > 1) replaced += parts.length - 1;
+		content = parts.join(value);
+	}
 	node_fs.default.writeFileSync(configPath, content, "utf-8");
+	log(`wrote ${configPath} (${replaced} placeholder(s) replaced, ${Object.keys(templateVars).length} provided)`);
 }
 /** Step 3: Kill all openclaw processes. */
-function killOpenclawProcesses() {
+function killOpenclawProcesses(log) {
 	try {
 		shell("pkill -f openclaw-gateway || true", 5e3);
 	} catch {}
 	shell("sleep 2", 5e3);
+	log("killed openclaw-gateway processes");
 }
 /**
 * Step 4: Wait for the sandbox's own init (init_sandbox.sh / concurrent npm
@@ -1180,22 +1319,30 @@ function killOpenclawProcesses() {
 * access. Polls every 10s up to `maxWaitMs`. If the deadline is hit we fall
 * through anyway — better to try than to fail the reset outright.
 */
-function waitForInitNpm(maxWaitMs) {
+function waitForInitNpm(maxWaitMs, log) {
 	const deadline = Date.now() + maxWaitMs;
 	const ownPid = String(process.pid);
+	let polls = 0;
 	while (Date.now() < deadline) {
+		polls++;
 		let running = 0;
 		try {
 			const out = shell(`pgrep -af "init_sandbox.sh|npm install|npm i " | grep -v -- "${ownPid}" | wc -l`, 1e4);
 			running = parseInt(out.trim(), 10) || 0;
 		} catch {
+			log(`poll ${polls}: no concurrent npm, proceeding`);
+			return;
+		}
+		if (running === 0) {
+			log(`poll ${polls}: no concurrent npm, proceeding`);
 			return;
 		}
-		if (running === 0) return;
+		log(`poll ${polls}: ${running} concurrent npm/init process(es) still running, waiting 10s`);
 		try {
 			shell("sleep 10", 12e3);
 		} catch {}
 	}
+	log(`deadline (${maxWaitMs}ms) hit after ${polls} poll(s), proceeding anyway`);
 }
 /**
 * Step 5: Reinstall openclaw to the version specified in template.
@@ -1206,17 +1353,30 @@ function waitForInitNpm(maxWaitMs) {
 * no idle-detection heuristics — waitForInitNpm above removes the main
 * source of contention so this step should run cleanly.
 */
-function reinstallOpenclaw(srcDir) {
+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");
+		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");
 	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 {}
-	shell(`npm i -g openclaw@${targetVersion || "latest"} --prefer-offline --fetch-timeout=60000 --fetch-retries=2`, 15 * 6e4);
+	const installCmd = `npm i -g openclaw@${targetVersion || "latest"} --prefer-offline --fetch-timeout=60000 --fetch-retries=2`;
+	log(`running: ${installCmd}`);
+	const installStart = Date.now();
+	shell(installCmd, 15 * 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`);
 }
 /** Return true if `openclaw --version` output contains `targetVersion`. */
 function isOpenclawAtVersion(targetVersion) {
@@ -1227,48 +1387,79 @@ function isOpenclawAtVersion(targetVersion) {
 	}
 }
 /** Step 6: Merge core-backup.json into config + ensure allowedOrigins. */
-function mergeCoreBackupAndOrigins(configPath, vars) {
+function mergeCoreBackupAndOrigins(configPath, vars, log) {
 	const JSON5 = loadJSON5();
 	if (fileExists(CORE_BACKUP_PATH)) {
 		const backup = JSON.parse(node_fs.default.readFileSync(CORE_BACKUP_PATH, "utf-8"));
 		const config = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
-		if (backup.agents) config.agents = backup.agents;
-		if (backup.bindings) config.bindings = backup.bindings;
+		const merged = [];
+		if (backup.agents) {
+			config.agents = backup.agents;
+			merged.push("agents");
+		}
+		if (backup.bindings) {
+			config.bindings = backup.bindings;
+			merged.push("bindings");
+		}
 		const backupAccounts = backup.channels?.feishu;
 		if (backupAccounts?.accounts) {
 			if (!config.channels) config.channels = {};
 			const ch = config.channels;
 			if (!ch.feishu) ch.feishu = {};
 			ch.feishu.accounts = backupAccounts.accounts;
+			merged.push("channels.feishu.accounts");
 		}
-		node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-	}
-	const expectedOrigins = Array.isArray(vars.expectedOrigins) ? vars.expectedOrigins : [];
-	if (expectedOrigins.length > 0) {
-		const config = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
-		if (!config.gateway) config.gateway = {};
-		const gw = config.gateway;
-		if (!gw.controlUi) gw.controlUi = {};
-		const cui = gw.controlUi;
-		const current = Array.isArray(cui.allowedOrigins) ? cui.allowedOrigins.filter((o) => typeof o === "string") : [];
-		if (current.includes("*")) return;
-		const seen = new Set(current);
-		const merged = [...current];
-		for (const o of expectedOrigins) if (!seen.has(o)) {
-			merged.push(o);
-			seen.add(o);
+		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");
+			}
 		}
-		cui.allowedOrigins = merged;
 		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`);
+	const expectedOrigins = Array.isArray(vars.expectedOrigins) ? vars.expectedOrigins : [];
+	if (expectedOrigins.length === 0) {
+		log("no expectedOrigins provided");
+		return;
 	}
+	const config = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
+	if (!config.gateway) config.gateway = {};
+	const gw = config.gateway;
+	if (!gw.controlUi) gw.controlUi = {};
+	const cui = gw.controlUi;
+	const current = Array.isArray(cui.allowedOrigins) ? cui.allowedOrigins.filter((o) => typeof o === "string") : [];
+	if (current.includes("*")) {
+		log("allowedOrigins already contains \"*\", skip origin merge");
+		return;
+	}
+	const seen = new Set(current);
+	const added = [];
+	const mergedOrigins = [...current];
+	for (const o of expectedOrigins) if (!seen.has(o)) {
+		mergedOrigins.push(o);
+		seen.add(o);
+		added.push(o);
+	}
+	cui.allowedOrigins = mergedOrigins;
+	node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+	log(`allowedOrigins: added ${added.length} (${JSON.stringify(added)}), total now ${mergedOrigins.length}`);
 }
 /** Step 7: Copy startup scripts from template to agent dir. */
-function copyStartupScripts(srcDir, configDir) {
+function copyStartupScripts(srcDir, configDir, log) {
 	const srcScriptsDir = node_path.default.join(srcDir, "scripts");
 	const targetScriptsDir = node_path.default.join(configDir, "scripts");
-	if (!node_fs.default.existsSync(srcScriptsDir)) return;
+	if (!node_fs.default.existsSync(srcScriptsDir)) {
+		log(`no scripts/ in template, skip`);
+		return;
+	}
 	if (!node_fs.default.existsSync(targetScriptsDir)) node_fs.default.mkdirSync(targetScriptsDir, { recursive: true });
 	shell(`cp -r '${srcScriptsDir}'/* '${targetScriptsDir}/'`, 1e4);
+	log(`copied scripts/* -> ${targetScriptsDir}`);
 }
 /**
 * Step 8: Reinstall all plugins via openclaw CLI.
@@ -1278,17 +1469,31 @@ function copyStartupScripts(srcDir, configDir) {
 * have exclusive npm access. Non-fatal — a plugin update failure shouldn't
 * stop the reset from restarting the gateway.
 */
-function reinstallPlugins() {
+function reinstallPlugins(log) {
+	const t = Date.now();
 	try {
 		shell("openclaw plugins update --all", 15 * 6e4);
-	} catch {}
+		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)`);
+	}
 }
 /** Step 9: Write secrets/provider key files and restart openclaw. */
-function writeSecretsAndRestart(vars, resetData, configDir) {
-	if (resetData.secretsContent && vars.secretsFilePath) writeFile(vars.secretsFilePath, resetData.secretsContent);
-	if (resetData.providerKeyContent && vars.providerFilePath) writeFile(vars.providerFilePath, resetData.providerKeyContent);
+function writeSecretsAndRestart(vars, resetData, configDir, log) {
+	if (resetData.secretsContent && vars.secretsFilePath) {
+		writeFile(vars.secretsFilePath, resetData.secretsContent);
+		log(`wrote secrets to ${vars.secretsFilePath}`);
+	}
+	if (resetData.providerKeyContent && vars.providerFilePath) {
+		writeFile(vars.providerFilePath, resetData.providerKeyContent);
+		log(`wrote provider key to ${vars.providerFilePath}`);
+	}
 	const restartScript = node_path.default.join(configDir, "scripts", "restart.sh");
-	if (fileExists(restartScript)) shell(`bash '${restartScript}'`, 3e4);
+	if (fileExists(restartScript)) {
+		const t = Date.now();
+		shell(`bash '${restartScript}'`, 3e4);
+		log(`restart.sh done in ${Date.now() - t}ms`);
+	} else log(`no restart.sh at ${restartScript}, skip`);
 }
 /**
 * Run the 9-step reset process. Called from the worker entry point.
@@ -1306,45 +1511,60 @@ function runReset(input, taskId, resultFile) {
 	const configDir = node_path.default.dirname(configPath);
 	const srcDir = TEMPLATE_DIR;
 	let currentStep = 0;
+	let stepStartedAt = Date.now();
+	const log = makeLogger(resetLogFile(taskId));
+	log(`=== reset started, taskId=${taskId}, pid=${process.pid} ===`);
+	log(`configPath=${configPath}, configDir=${configDir}, templateDir=${srcDir}`);
 	if (!node_fs.default.existsSync(node_path.default.join(srcDir, "openclaw.json"))) {
-		markFailed(resultFile, 0, `bundled template not found at ${srcDir}`, startedAt);
+		const err = `bundled template not found at ${srcDir}`;
+		log(`ERROR: ${err}`);
+		markFailed(resultFile, 0, err, startedAt);
 		process.exit(1);
 	}
 	process.on("uncaughtException", (err) => {
+		log(`FATAL uncaughtException: ${err.message}\n${err.stack ?? ""}`);
 		markFailed(resultFile, currentStep, `uncaught exception: ${err.message}`, startedAt);
 		process.exit(1);
 	});
 	process.on("unhandledRejection", (reason) => {
+		log(`FATAL unhandledRejection: ${String(reason)}`);
 		markFailed(resultFile, currentStep, `unhandled rejection: ${reason}`, startedAt);
 		process.exit(1);
 	});
-	/** Advance to the next step, updating the progress file. */
+	/** Advance to the next step, updating the progress file and logging a boundary. */
 	const step = (n) => {
+		if (currentStep > 0) log(`step ${currentStep} "${STEPS[currentStep - 1]}" done in ${Date.now() - stepStartedAt}ms`);
 		currentStep = n;
+		stepStartedAt = Date.now();
+		log(`--- step ${n}/${TOTAL_STEPS}: ${STEPS[n - 1]} ---`);
 		updateProgress(resultFile, n, startedAt);
 	};
 	try {
 		step(1);
-		backupCurrentConfig(configPath);
+		backupCurrentConfig(configPath, log);
 		step(2);
-		generateDefaultConfig(srcDir, configPath, resetData.templateVars);
+		generateDefaultConfig(srcDir, configPath, resetData.templateVars, log);
 		step(3);
-		killOpenclawProcesses();
+		killOpenclawProcesses(log);
 		step(4);
-		waitForInitNpm(10 * 6e4);
+		waitForInitNpm(10 * 6e4, log);
 		step(5);
-		reinstallOpenclaw(srcDir);
+		reinstallOpenclaw(srcDir, log);
 		step(6);
-		mergeCoreBackupAndOrigins(configPath, vars);
+		mergeCoreBackupAndOrigins(configPath, vars, log);
 		step(7);
-		copyStartupScripts(srcDir, configDir);
+		copyStartupScripts(srcDir, configDir, log);
 		step(8);
-		reinstallPlugins();
+		reinstallPlugins(log);
 		step(9);
-		writeSecretsAndRestart(vars, resetData, configDir);
+		writeSecretsAndRestart(vars, resetData, configDir, log);
+		log(`step 9 "${STEPS[8]}" done in ${Date.now() - stepStartedAt}ms`);
+		log("=== reset completed successfully ===");
 		markDone(resultFile, startedAt);
 	} catch (e) {
-		markFailed(resultFile, currentStep, e.message, startedAt);
+		const err = e.message;
+		log(`ERROR in step ${currentStep} "${STEPS[currentStep - 1] ?? "init"}" after ${Date.now() - stepStartedAt}ms: ${err}\n${e.stack ?? ""}`);
+		markFailed(resultFile, currentStep, err, startedAt);
 		process.exit(1);
 	}
 }
@@ -1356,7 +1576,7 @@ function runReset(input, taskId, resultFile) {
 * Returns immediately on terminal states (done/failed).
 */
 function getResetTask(taskId) {
-	const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
+	const resultFile = resetResultFile(taskId);
 	const deadline = Date.now() + 3e4;
 	while (Date.now() < deadline) {
 		if (!node_fs.default.existsSync(resultFile)) {
@@ -1409,8 +1629,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":
@@ -1428,7 +1650,7 @@ switch (mode) {
 				console.error("Error: --ctx=<base64> and --task-id=<id> are required for worker");
 				node_process.default.exit(1);
 			}
-			const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
+			const resultFile = resetResultFile(taskId);
 			runReset(JSON.parse(Buffer.from(ctx, "base64").toString("utf-8")), taskId, resultFile);
 		} else {
 			console.error("Usage: reset --async --ctx=<base64> | reset --worker --task-id=<id> --ctx=<base64>");

package/package.json

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