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

package/dist/index.cjs

@@ -993,7 +993,7 @@ function runRepair(input) {
 }
 //#endregion
 //#region src/backup.ts
-const BACKUP_PATH = "/home/gem/workspace/.force/openclaw/core-backup.json";
+const BACKUP_PATH = "/home/gem/workspace/agent/.spark/core-backup.json";
 function runBackup(input) {
 	try {
 		const { configPath } = input;
@@ -1033,6 +1033,40 @@ function runBackup(input) {
 	}
 }
 //#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.
@@ -1041,7 +1075,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 +1101,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 +1116,7 @@ function startAsyncReset(ctxBase64) {
 		node_fs.default.renameSync(errTmpPath, resultFile);
 	});
 	child.unref();
+	log(`spawned worker pid=${child.pid}`);
 	return { taskId };
 }
 //#endregion
@@ -1095,7 +1133,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 +1180,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 +1196,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 +1230,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 +1264,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)) {
-		shell("openclaw doctor --fix", 12e4);
+		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);
-	shell("openclaw doctor --fix", 12e4);
+	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 +1298,69 @@ 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");
-	}
+		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) {
-		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);
-		}
-		cui.allowedOrigins = merged;
-		node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+	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 +1370,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 +1412,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 +1477,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)) {
@@ -1428,7 +1549,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.11",
+  "version": "0.1.1-alpha.13",
   "description": "CLI for OpenClaw config diagnose and repair with JSON5 support",
   "main": "dist/index.cjs",
   "bin": {