@lark-apaas/openclaw-scripts-diagnose-cli 0.1.1-alpha.8 → 0.1.1-alpha.9

package/dist/index.cjs

@@ -198,6 +198,74 @@ function shell(cmd, timeoutMs = 1e4) {
 		timeout: timeoutMs
 	}).trim();
 }
+/**
+* Run a long-lived command and kill it only when it goes idle (no stdout/stderr
+* for `idleMs`) or hits the total deadline `maxTotalMs`. Suited to commands like
+* `npm install` that may be slow but keep streaming progress — we don't want to
+* kill them just because they exceeded some fixed wall-clock budget, only when
+* they actually stall (e.g. blocked on a cache / lockfile held by another npm).
+*/
+function shellUntilIdle(cmd, opts = {}) {
+	const idleMs = opts.idleMs ?? 9e4;
+	const maxTotalMs = opts.maxTotalMs ?? 9e5;
+	return new Promise((resolve, reject) => {
+		const proc = (0, node_child_process.spawn)("bash", ["-c", cmd], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		const startedAt = Date.now();
+		let lastOutputAt = Date.now();
+		let killed = null;
+		const bump = () => {
+			lastOutputAt = Date.now();
+		};
+		proc.stdout.on("data", bump);
+		proc.stderr.on("data", bump);
+		const timer = setInterval(() => {
+			const now = Date.now();
+			if (now - lastOutputAt > idleMs) {
+				killed = `idle > ${idleMs}ms`;
+				proc.kill("SIGKILL");
+			} else if (now - startedAt > maxTotalMs) {
+				killed = `total > ${maxTotalMs}ms`;
+				proc.kill("SIGKILL");
+			}
+		}, 5e3);
+		proc.on("exit", (code, signal) => {
+			clearInterval(timer);
+			if (killed) return reject(/* @__PURE__ */ new Error(`shellUntilIdle killed (${killed}): ${cmd}`));
+			if (code === 0) return resolve();
+			reject(/* @__PURE__ */ new Error(`shellUntilIdle exit code=${code} signal=${signal}: ${cmd}`));
+		});
+		proc.on("error", (err) => {
+			clearInterval(timer);
+			reject(err);
+		});
+	});
+}
+/**
+* Retry a Promise-returning runner until it succeeds or the overall deadline
+* passes. Designed to pair with `shellUntilIdle` for npm-style operations that
+* may need several attempts if a concurrent npm is holding a lock.
+*/
+async function retryUntilDeadline(run, opts) {
+	const betweenAttemptsMs = opts.betweenAttemptsMs ?? 1e4;
+	const deadline = Date.now() + opts.maxTotalMs;
+	let lastErr;
+	let attempt = 0;
+	while (Date.now() < deadline) {
+		attempt++;
+		try {
+			return await run();
+		} catch (e) {
+			lastErr = e;
+			if (Date.now() + betweenAttemptsMs >= deadline) break;
+			await new Promise((r) => setTimeout(r, betweenAttemptsMs));
+		}
+	}
+	throw new Error(`retryUntilDeadline gave up after ${attempt} attempt(s): ${lastErr?.message ?? lastErr}`);
+}
 //#endregion
 //#region \0@oxc-project+runtime@0.121.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -1164,13 +1232,29 @@ function killOpenclawProcesses() {
 	} catch {}
 	shell("sleep 2", 5e3);
 }
-/** Step 4: Reinstall openclaw to the version specified in template. */
-function reinstallOpenclaw(srcDir) {
+/**
+* Step 4: Reinstall openclaw to the version specified in template.
+*
+* `npm i -g` contends on ~/.npm cache/lock with any concurrent npm (e.g. the
+* sandbox's own init_sandbox.sh busy installing plugin deps). Using
+* `shellUntilIdle` lets slow-but-progressing installs run freely (we only kill
+* on genuine idleness), and `retryUntilDeadline` recovers when we *are* killed
+* because another npm was holding the lock — the next attempt is likely to
+* succeed once that npm completes.
+*/
+async function reinstallOpenclaw(srcDir) {
 	const version = loadJSON5().parse(node_fs.default.readFileSync(node_path.default.join(srcDir, "openclaw.json"), "utf-8")).meta?.lastTouchedVersion;
 	try {
 		shell("npm uninstall -g openclaw 2>/dev/null || true", 3e4);
 	} catch {}
-	shell(`npm i -g openclaw@${version || "latest"}`, 6e5);
+	const installCmd = `npm i -g openclaw@${version || "latest"} --loglevel=http --prefer-offline`;
+	await retryUntilDeadline(() => shellUntilIdle(installCmd, {
+		idleMs: 9e4,
+		maxTotalMs: 6e5
+	}), {
+		maxTotalMs: 12e5,
+		betweenAttemptsMs: 1e4
+	});
 	shell("openclaw doctor --fix", 12e4);
 }
 /** Step 5: Merge core-backup.json into config + ensure allowedOrigins. */
@@ -1216,10 +1300,21 @@ function copyStartupScripts(srcDir, configDir) {
 	if (!node_fs.default.existsSync(targetScriptsDir)) node_fs.default.mkdirSync(targetScriptsDir, { recursive: true });
 	shell(`cp -r '${srcScriptsDir}'/* '${targetScriptsDir}/'`, 1e4);
 }
-/** Step 7: Reinstall all plugins via openclaw CLI. */
-function reinstallPlugins() {
+/**
+* Step 7: Reinstall all plugins via openclaw CLI.
+*
+* Same contention story as Step 4 — under the hood this shells out to npm, so
+* we apply the same idle-timeout + retry strategy.
+*/
+async function reinstallPlugins() {
 	try {
-		shell("openclaw plugins update --all", 3e5);
+		await retryUntilDeadline(() => shellUntilIdle("openclaw plugins update --all", {
+			idleMs: 12e4,
+			maxTotalMs: 6e5
+		}), {
+			maxTotalMs: 9e5,
+			betweenAttemptsMs: 1e4
+		});
 	} catch {}
 }
 /** Step 8: Write secrets/provider key files and restart openclaw. */
@@ -1239,7 +1334,7 @@ function writeSecretsAndRestart(vars, resetData, configDir) {
 * (see TEMPLATE_DIR) and synced from the miaoda-openclaw-template repo via
 * scripts/sync-template.sh, so no runtime download is required.
 */
-function runReset(input, taskId, resultFile) {
+async function runReset(input, taskId, resultFile) {
 	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const { configPath, vars, resetData } = input;
 	const configDir = node_path.default.dirname(configPath);
@@ -1270,13 +1365,13 @@ function runReset(input, taskId, resultFile) {
 		step(3);
 		killOpenclawProcesses();
 		step(4);
-		reinstallOpenclaw(srcDir);
+		await reinstallOpenclaw(srcDir);
 		step(5);
 		mergeCoreBackupAndOrigins(configPath, vars);
 		step(6);
 		copyStartupScripts(srcDir, configDir);
 		step(7);
-		reinstallPlugins();
+		await reinstallPlugins();
 		step(8);
 		writeSecretsAndRestart(vars, resetData, configDir);
 		markDone(resultFile, startedAt);
@@ -1366,7 +1461,10 @@ switch (mode) {
 				node_process.default.exit(1);
 			}
 			const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
-			runReset(JSON.parse(Buffer.from(ctx, "base64").toString("utf-8")), taskId, resultFile);
+			runReset(JSON.parse(Buffer.from(ctx, "base64").toString("utf-8")), taskId, resultFile).catch((e) => {
+				console.error("runReset failed:", e);
+				node_process.default.exit(1);
+			});
 		} else {
 			console.error("Usage: reset --async --ctx=<base64> | reset --worker --task-id=<id> --ctx=<base64>");
 			node_process.default.exit(1);

package/package.json

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