@lark-apaas/openclaw-scripts-diagnose-cli 0.1.1-alpha.2 → 0.1.1-alpha.3

package/dist/index.cjs

@@ -30,6 +30,7 @@ node_fs = __toESM(node_fs);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
 let node_child_process = require("node:child_process");
+let node_crypto = require("node:crypto");
 //#region src/rule-engine/base.ts
 /** Abstract base class for all diagnose rules */
 var DiagnoseRule = class {
@@ -984,19 +985,385 @@ function runRepair(input) {
 	}
 }
 //#endregion
+//#region src/backup.ts
+const BACKUP_PATH = "/home/gem/workspace/.force/openclaw/core-backup.json";
+function runBackup(input) {
+	try {
+		const { configPath } = input;
+		try {
+			const validateOutput = shell("openclaw config validate --json");
+			if (!JSON.parse(validateOutput).valid) return {
+				success: false,
+				error: "config validation failed"
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: "config validate command failed: " + e.message
+			};
+		}
+		if (!fileExists(configPath)) return {
+			success: false,
+			error: "config file not found: " + configPath
+		};
+		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 feishu = config.channels?.feishu;
+		if (feishu?.accounts) backup.channels = { feishu: { accounts: feishu.accounts } };
+		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);
+		return { success: true };
+	} catch (e) {
+		return {
+			success: false,
+			error: "backup failed: " + e.message
+		};
+	}
+}
+//#endregion
+//#region src/reset-async.ts
+/**
+* Start an async reset task: spawn a detached child process and return the taskId.
+*
+* The child process runs: node cli.js reset --worker --task-id=xxx --ctx=base64
+*/
+function startAsyncReset(ctxBase64) {
+	const taskId = (0, node_crypto.randomUUID)();
+	const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
+	const initial = {
+		status: "running",
+		step: 0,
+		totalSteps: 9,
+		progress: "初始化...",
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const tmpPath = resultFile + ".tmp";
+	const dir = node_path.default.dirname(resultFile);
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+	node_fs.default.writeFileSync(tmpPath, JSON.stringify(initial), "utf-8");
+	node_fs.default.renameSync(tmpPath, resultFile);
+	const child = (0, node_child_process.spawn)(process.execPath, [
+		process.argv[1],
+		"reset",
+		"--worker",
+		`--task-id=${taskId}`,
+		`--ctx=${ctxBase64}`
+	], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.on("error", (err) => {
+		const failResult = {
+			status: "failed",
+			step: 0,
+			totalSteps: 9,
+			progress: "Worker process failed to start",
+			error: err.message,
+			startedAt: initial.startedAt,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const errTmpPath = resultFile + ".tmp";
+		node_fs.default.writeFileSync(errTmpPath, JSON.stringify(failResult));
+		node_fs.default.renameSync(errTmpPath, resultFile);
+	});
+	child.unref();
+	return { taskId };
+}
+//#endregion
+//#region src/reset.ts
+const STEPS = [
+	"备份当前配置",
+	"下载技术栈模板",
+	"生成默认配置",
+	"杀掉 openclaw 进程",
+	"重装 openclaw",
+	"合并核心备份配置",
+	"复制启动脚本",
+	"重装内置插件",
+	"启动并验证"
+];
+const TOTAL_STEPS = STEPS.length;
+const CORE_BACKUP_PATH = "/home/gem/workspace/.force/openclaw/core-backup.json";
+const TMP_RESET_DIR = "/tmp/openclaw-reset";
+/**
+* Atomically write the result file (write .tmp + rename).
+*/
+function writeResultFile(resultFile, result) {
+	const dir = node_path.default.dirname(resultFile);
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+	const tmpPath = resultFile + ".tmp";
+	node_fs.default.writeFileSync(tmpPath, JSON.stringify(result), "utf-8");
+	node_fs.default.renameSync(tmpPath, resultFile);
+}
+/**
+* Update progress in the result file.
+*/
+function updateProgress(resultFile, step, progress, startedAt) {
+	writeResultFile(resultFile, {
+		status: "running",
+		step,
+		totalSteps: TOTAL_STEPS,
+		progress,
+		startedAt
+	});
+}
+/**
+* Mark the task as done.
+*/
+function markDone(resultFile, startedAt) {
+	writeResultFile(resultFile, {
+		status: "done",
+		step: TOTAL_STEPS,
+		totalSteps: TOTAL_STEPS,
+		progress: "重置完成",
+		startedAt,
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/**
+* Mark the task as failed.
+*/
+function markFailed(resultFile, step, progress, error, startedAt) {
+	writeResultFile(resultFile, {
+		status: "failed",
+		step,
+		totalSteps: TOTAL_STEPS,
+		progress,
+		error,
+		startedAt,
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/**
+* Run the 9-step reset process. Called from the worker entry point.
+*/
+function runReset(input, taskId, resultFile) {
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const { configPath, resetData } = input;
+	const configDir = node_path.default.dirname(configPath);
+	let currentStep = 0;
+	process.on("uncaughtException", (err) => {
+		const stepName = currentStep > 0 ? STEPS[currentStep - 1] : "初始化";
+		markFailed(resultFile, currentStep, stepName, `uncaught exception: ${err.message}`, startedAt);
+		process.exit(1);
+	});
+	process.on("unhandledRejection", (reason) => {
+		const stepName = currentStep > 0 ? STEPS[currentStep - 1] : "初始化";
+		markFailed(resultFile, currentStep, stepName, `unhandled rejection: ${reason}`, startedAt);
+		process.exit(1);
+	});
+	try {
+		currentStep = 1;
+		updateProgress(resultFile, currentStep, STEPS[0], startedAt);
+		if (fileExists(configPath)) {
+			let maxN = 0;
+			try {
+				const files = node_fs.default.readdirSync(configDir);
+				const bakPattern = /^openclaw\.json\.bak\.(\d+)$/;
+				for (const f of files) {
+					const match = f.match(bakPattern);
+					if (match) {
+						const n = parseInt(match[1], 10);
+						if (n > maxN) maxN = n;
+					}
+				}
+			} catch {}
+			const bakPath = configPath + ".bak." + (maxN + 1);
+			node_fs.default.copyFileSync(configPath, bakPath);
+		}
+		currentStep = 2;
+		updateProgress(resultFile, currentStep, STEPS[1], startedAt);
+		if (!node_fs.default.existsSync(TMP_RESET_DIR)) node_fs.default.mkdirSync(TMP_RESET_DIR, { recursive: true });
+		const zipPath = node_path.default.join(TMP_RESET_DIR, "template.zip");
+		const zipSource = resetData.zipDownloadURL;
+		if (zipSource.startsWith("http://") || zipSource.startsWith("https://")) shell(`curl -sSL -o '${zipPath}' '${zipSource}'`, 12e4);
+		else shell(`cp '${zipSource}' '${zipPath}'`, 1e4);
+		shell(`unzip -o '${zipPath}' -d '${TMP_RESET_DIR}'`, 6e4);
+		const srcDir = findSrcDir(TMP_RESET_DIR);
+		currentStep = 3;
+		updateProgress(resultFile, currentStep, STEPS[2], startedAt);
+		const srcConfigPath = node_path.default.join(srcDir, "openclaw.json");
+		if (!fileExists(srcConfigPath)) throw new Error("template openclaw.json not found in downloaded zip at " + srcConfigPath);
+		let configContent = node_fs.default.readFileSync(srcConfigPath, "utf-8");
+		for (const [placeholder, value] of Object.entries(resetData.templateVars)) configContent = configContent.split(placeholder).join(value);
+		node_fs.default.writeFileSync(configPath, configContent, "utf-8");
+		currentStep = 4;
+		updateProgress(resultFile, currentStep, STEPS[3], startedAt);
+		try {
+			shell("pkill -f openclaw-gateway || true", 5e3);
+		} catch {}
+		shell("sleep 2", 5e3);
+		currentStep = 5;
+		updateProgress(resultFile, currentStep, STEPS[4], startedAt);
+		const JSON5 = loadJSON5();
+		const version = JSON5.parse(node_fs.default.readFileSync(srcConfigPath, "utf-8")).meta?.lastTouchedVersion;
+		if (version) shell(`npm install -g @anthropic-ai/openclaw@${version}`, 3e5);
+		else shell("npm install -g @anthropic-ai/openclaw@latest", 3e5);
+		currentStep = 6;
+		updateProgress(resultFile, currentStep, STEPS[5], startedAt);
+		if (fileExists(CORE_BACKUP_PATH)) {
+			const backup = JSON.parse(node_fs.default.readFileSync(CORE_BACKUP_PATH, "utf-8"));
+			const mergeConfig = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
+			if (backup.agents) mergeConfig.agents = backup.agents;
+			if (backup.bindings) mergeConfig.bindings = backup.bindings;
+			const backupFeishu = backup.channels?.feishu;
+			if (backupFeishu?.accounts) {
+				if (!mergeConfig.channels) mergeConfig.channels = {};
+				const ch = mergeConfig.channels;
+				if (!ch.feishu) ch.feishu = {};
+				const feishu = ch.feishu;
+				feishu.accounts = backupFeishu.accounts;
+			}
+			node_fs.default.writeFileSync(configPath, JSON.stringify(mergeConfig, null, 2), "utf-8");
+		}
+		currentStep = 7;
+		updateProgress(resultFile, currentStep, STEPS[6], startedAt);
+		const srcScriptsDir = node_path.default.join(srcDir, "scripts");
+		const targetScriptsDir = node_path.default.join(configDir, "scripts");
+		if (node_fs.default.existsSync(srcScriptsDir)) {
+			if (!node_fs.default.existsSync(targetScriptsDir)) node_fs.default.mkdirSync(targetScriptsDir, { recursive: true });
+			shell(`cp -r '${srcScriptsDir}'/* '${targetScriptsDir}/'`, 1e4);
+		}
+		currentStep = 8;
+		updateProgress(resultFile, currentStep, STEPS[7], startedAt);
+		try {
+			shell("openclaw plugins install --all", 3e5);
+		} catch (e) {}
+		currentStep = 9;
+		updateProgress(resultFile, currentStep, STEPS[8], startedAt);
+		if (resetData.secretsContent && input.vars.secretsFilePath) writeFile(input.vars.secretsFilePath, resetData.secretsContent);
+		if (resetData.providerKeyContent && input.vars.providerFilePath) writeFile(input.vars.providerFilePath, resetData.providerKeyContent);
+		const restartScript = node_path.default.join(configDir, "scripts", "restart.sh");
+		if (fileExists(restartScript)) shell(`bash '${restartScript}'`, 3e4);
+		try {
+			node_fs.default.rmSync(TMP_RESET_DIR, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		markDone(resultFile, startedAt);
+	} catch (e) {
+		const stepName = currentStep > 0 ? STEPS[currentStep - 1] : "初始化";
+		markFailed(resultFile, currentStep, stepName, e.message, startedAt);
+		process.exit(1);
+	}
+}
+/**
+* Find the source directory within the extracted zip.
+* Looks for openclaw.json in TMP_RESET_DIR or one level deep.
+*/
+function findSrcDir(baseDir) {
+	if (node_fs.default.existsSync(node_path.default.join(baseDir, "openclaw.json"))) return baseDir;
+	const entries = node_fs.default.readdirSync(baseDir, { withFileTypes: true });
+	for (const entry of entries) if (entry.isDirectory()) {
+		const candidate = node_path.default.join(baseDir, entry.name);
+		if (node_fs.default.existsSync(node_path.default.join(candidate, "openclaw.json"))) return candidate;
+	}
+	return baseDir;
+}
+//#endregion
+//#region src/get-reset-task.ts
+/**
+* Long-poll for a reset task result.
+* Reads the result file every 1s for up to 30s.
+* Returns immediately on terminal states (done/failed).
+*/
+function getResetTask(taskId) {
+	const resultFile = `/tmp/openclaw-reset-${taskId}.json`;
+	const deadline = Date.now() + 3e4;
+	while (Date.now() < deadline) {
+		if (!node_fs.default.existsSync(resultFile)) {
+			sleepSync(1e3);
+			continue;
+		}
+		try {
+			const content = node_fs.default.readFileSync(resultFile, "utf-8");
+			const result = JSON.parse(content);
+			if (result.status === "done" || result.status === "failed") return result;
+		} catch {}
+		sleepSync(1e3);
+	}
+	if (node_fs.default.existsSync(resultFile)) try {
+		return JSON.parse(node_fs.default.readFileSync(resultFile, "utf-8"));
+	} catch {}
+	return {
+		status: "running",
+		progress: "等待中..."
+	};
+}
+/**
+* Synchronous sleep using Atomics.wait on a shared buffer.
+*/
+function sleepSync(ms) {
+	const buf = new SharedArrayBuffer(4);
+	const arr = new Int32Array(buf);
+	Atomics.wait(arr, 0, 0, ms);
+}
+//#endregion
 //#region src/index.ts
 const args = node_process.default.argv.slice(2);
 const mode = args.find((a) => !a.startsWith("--"));
-const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
-if (!mode || !["check", "repair"].includes(mode)) {
-	console.error("Usage: mclaw-diagnose <check|repair> --ctx=<base64>");
-	node_process.default.exit(1);
-}
-if (!ctx) {
-	console.error("Error: --ctx=<base64> is required");
-	node_process.default.exit(1);
-}
-const input = JSON.parse(Buffer.from(ctx, "base64").toString("utf-8"));
-if (mode === "check") console.log(JSON.stringify(runCheck(input)));
-else console.log(JSON.stringify(runRepair(input)));
+switch (mode) {
+	case "check":
+	case "repair": {
+		const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
+		if (!ctx) {
+			console.error("Error: --ctx=<base64> is required");
+			node_process.default.exit(1);
+		}
+		const input = JSON.parse(Buffer.from(ctx, "base64").toString("utf-8"));
+		if (mode === "check") console.log(JSON.stringify(runCheck(input)));
+		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);
+		}
+		const input = JSON.parse(Buffer.from(ctx, "base64").toString("utf-8"));
+		console.log(JSON.stringify(runBackup(input)));
+		break;
+	}
+	case "reset":
+		if (args.includes("--async")) {
+			const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
+			if (!ctx) {
+				console.error("Error: --ctx=<base64> is required");
+				node_process.default.exit(1);
+			}
+			console.log(JSON.stringify(startAsyncReset(ctx)));
+		} else if (args.includes("--worker")) {
+			const ctx = args.find((a) => a.startsWith("--ctx="))?.slice(6);
+			const taskId = args.find((a) => a.startsWith("--task-id="))?.slice(10);
+			if (!ctx || !taskId) {
+				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`;
+			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>");
+			node_process.default.exit(1);
+		}
+		break;
+	case "get_reset_task": {
+		const taskId = args.find((a) => a.startsWith("--task-id="))?.slice(10);
+		if (!taskId) {
+			console.error("Error: --task-id=<id> is required");
+			node_process.default.exit(1);
+		}
+		console.log(JSON.stringify(getResetTask(taskId)));
+		break;
+	}
+	default:
+		console.error("Usage: mclaw-diagnose <check|repair|backup|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.2",
+  "version": "0.1.1-alpha.3",
   "description": "CLI for OpenClaw config diagnose and repair with JSON5 support",
   "main": "dist/index.cjs",
   "bin": {