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

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 {
@@ -191,7 +192,7 @@ function fileExists(filePath) {
 	return node_fs.default.existsSync(filePath);
 }
 /** Execute a shell command, return stdout. Throws on failure. */
-function shell(cmd, timeoutMs = 1e4) {
+function shell(cmd, timeoutMs = 6e4) {
 	return (0, node_child_process.execSync)(cmd, {
 		encoding: "utf-8",
 		timeout: timeoutMs
@@ -244,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);
@@ -685,7 +690,9 @@ let AllowedOriginsRule = class AllowedOriginsRule extends DiagnoseRule {
 	validate(ctx) {
 		const expected = getExpectedOrigins(ctx.vars);
 		if (expected.length === 0) return { pass: true };
-		const missing = findMissing(getCurrentOrigins(ctx.config), expected);
+		const current = getCurrentOrigins(ctx.config);
+		if (hasWildcard(current)) return { pass: true };
+		const missing = findMissing(current, expected);
 		if (missing.length === 0) return { pass: true };
 		return {
 			pass: false,
@@ -695,6 +702,7 @@ let AllowedOriginsRule = class AllowedOriginsRule extends DiagnoseRule {
 	repair(ctx) {
 		const expected = getExpectedOrigins(ctx.vars);
 		const current = getCurrentOrigins(ctx.config);
+		if (hasWildcard(current)) return;
 		const missing = findMissing(current, expected);
 		if (missing.length > 0) {
 			const seen = /* @__PURE__ */ new Set();
@@ -734,6 +742,10 @@ function findMissing(current, expected) {
 	const set = new Set(current);
 	return expected.filter((o) => !set.has(o));
 }
+/** Exact "*" entry means allow-all; pattern globs like "https://*.example.com" don't count. */
+function hasWildcard(origins) {
+	return origins.includes("*");
+}
 //#endregion
 //#region src/rules/jwt-token.ts
 let JwtTokenRule = class JwtTokenRule extends DiagnoseRule {
@@ -984,19 +996,640 @@ function runRepair(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.
+*/
+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.
+*
+* 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 = resetResultFile(taskId);
+	const log = makeLogger(resetLogFile(taskId));
+	log(`=== startAsyncReset spawning worker for taskId=${taskId} ===`);
+	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) => {
+		log(`FATAL worker failed to start: ${err.message}`);
+		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();
+	log(`spawned worker pid=${child.pid}`);
+	return { taskId };
+}
+//#endregion
+//#region src/reset.ts
+const STEPS = [
+	"备份当前配置",
+	"生成默认配置",
+	"杀掉 openclaw 进程",
+	"等待沙箱初始化完成",
+	"确认 openclaw 版本",
+	"合并核心备份配置",
+	"复制启动脚本",
+	"安装扩展",
+	"启动并验证"
+];
+const TOTAL_STEPS = STEPS.length;
+/** Pre-packed extensions archive on OSS. Update this URL when releasing a new version. */
+const EXTENSIONS_OSS_URL = "https://miaoda-template-online.oss-cn-beijing.aliyuncs.com/builtin/tool/pkg/openclaw-extensions-2026.4.9.tar.gz";
+/**
+* Directory holding the bundled openclaw template (openclaw.json + scripts/).
+* Synced from git@code.byted.org:apaas/miaoda-openclaw-template.git via
+* scripts/sync-template.sh and published alongside dist/.
+*
+* At runtime, __dirname points to dist/, so the template lives one level up.
+*/
+const TEMPLATE_DIR = node_path.default.resolve(__dirname, "..", "template");
+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);
+}
+function updateProgress(resultFile, step, startedAt) {
+	writeResultFile(resultFile, {
+		status: "running",
+		step,
+		totalSteps: TOTAL_STEPS,
+		progress: STEPS[step - 1],
+		startedAt
+	});
+}
+function markDone(resultFile, startedAt) {
+	writeResultFile(resultFile, {
+		status: "done",
+		step: TOTAL_STEPS,
+		totalSteps: TOTAL_STEPS,
+		progress: "重置完成",
+		startedAt,
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function markFailed(resultFile, step, error, startedAt) {
+	writeResultFile(resultFile, {
+		status: "failed",
+		step,
+		totalSteps: TOTAL_STEPS,
+		progress: step > 0 ? STEPS[step - 1] : "初始化",
+		error,
+		startedAt,
+		completedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/** Step 1: Backup current config as openclaw.json.bak.N */
+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 {
+		for (const f of node_fs.default.readdirSync(dir)) {
+			const match = f.match(/^openclaw\.json\.bak\.(\d+)$/);
+			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);
+	log(`backed up to ${bakPath}`);
+}
+/** Step 2: Replace $$__XXX__ placeholders and write default config. */
+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");
+	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(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
+* install) to finish before we start our own npm i -g. Two npm processes
+* sharing ~/.npm cache + competing for disk/network just makes everything
+* crawl; letting init finish first is the cleanest way to get exclusive
+* 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, 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;
+		}
+		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: Ensure openclaw binary is at the template's recommended version.
+*
+* Only checks/installs the binary — does NOT run `doctor --fix` any more.
+* Extensions are installed separately via OSS tar.gz (Step 8), which means
+* the openclaw-lark extension schema is already in place when openclaw
+* starts, avoiding the schema-priority mismatch that caused doctor to
+* reject valid config fields like threadSession / footer.
+*/
+function ensureOpenclawBinary(srcDir, configPath, 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("openclaw already at target version, nothing to do");
+		return;
+	}
+	if (isOpenclawInstalled()) {
+		const updateCmd = `openclaw update${targetVersion ? " --tag " + targetVersion : ""} --yes`;
+		log(`openclaw installed but version mismatched, running: ${updateCmd}`);
+		const timeout = 12 * 6e4;
+		const t = Date.now();
+		const tmpConfig = configPath + ".update-tmp";
+		const hadConfig = node_fs.default.existsSync(configPath);
+		if (hadConfig) {
+			node_fs.default.renameSync(configPath, tmpConfig);
+			log("temporarily hid config to bypass config guard");
+		}
+		try {
+			shell(updateCmd, timeout);
+			log(`openclaw update done in ${Date.now() - t}ms`);
+		} catch (e) {
+			const elapsed = Date.now() - t;
+			if (elapsed >= timeout - 1e3) log(`openclaw update timed out after ${elapsed}ms (non-fatal, continuing)`);
+			else throw e;
+		} finally {
+			if (hadConfig && node_fs.default.existsSync(tmpConfig)) {
+				node_fs.default.renameSync(tmpConfig, configPath);
+				log("restored config after update");
+			}
+		}
+	} else {
+		log("openclaw binary not found, running full reinstall");
+		fullReinstall(targetVersion, log);
+	}
+}
+/** Check if openclaw command exists (regardless of version). */
+function isOpenclawInstalled() {
+	try {
+		shell("which openclaw 2>/dev/null", 5e3);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Full uninstall + reinstall from npm (slow path, triggers postinstall). */
+function fullReinstall(targetVersion, log) {
+	try {
+		shell("npm uninstall -g openclaw 2>/dev/null || true", 6e4);
+	} catch {}
+	try {
+		shell("rm -rf /home/gem/.npm-global/lib/node_modules/openclaw /home/gem/.npm-global/bin/openclaw 2>/dev/null || true", 1e4);
+		log("force-cleaned residual openclaw global dir");
+	} catch {}
+	const installCmd = `npm i -g openclaw@${targetVersion || "latest"}`;
+	log(`running: ${installCmd}`);
+	const t = Date.now();
+	shell(installCmd, 30 * 6e4);
+	log(`npm install done in ${Date.now() - t}ms`);
+}
+/** Return true if `openclaw --version` output contains `targetVersion`. */
+function isOpenclawAtVersion(targetVersion) {
+	try {
+		return shell("openclaw --version 2>&1 || true", 1e4).includes(targetVersion);
+	} catch {
+		return false;
+	}
+}
+/** Step 6: Merge coreBackup from resetData + ensure allowedOrigins. */
+function mergeCoreBackupAndOrigins(configPath, vars, resetData, log) {
+	const JSON5 = loadJSON5();
+	const backup = resetData.coreBackup;
+	if (backup) {
+		const config = JSON5.parse(node_fs.default.readFileSync(configPath, "utf-8"));
+		const merged = [];
+		if (backup.agents && backup.agents.length > 0) {
+			if (!config.agents) config.agents = {};
+			const agents = config.agents;
+			if (!Array.isArray(agents.list)) agents.list = [];
+			const configDir = node_path.default.dirname(configPath);
+			for (const agent of backup.agents) {
+				const enriched = {
+					id: agent.id,
+					name: agent.id,
+					workspace: agent.workspace,
+					agentDir: configDir + "/agents/" + agent.id + "/agent"
+				};
+				agents.list.push(enriched);
+			}
+			merged.push(`agents(+${backup.agents.length})`);
+			const list = agents.list;
+			let mainIdx = list.findIndex((a) => a.id === "main");
+			if (mainIdx < 0) {
+				list.unshift({ id: "main" });
+				mainIdx = 0;
+			}
+			list[mainIdx].subagents = { allowAgents: ["*"] };
+			list[mainIdx].default = true;
+			merged.push("main-team-mode");
+			const feishu = config.channels?.feishu;
+			if (feishu) {
+				if (!feishu.accounts) feishu.accounts = {};
+				const accounts = feishu.accounts;
+				const defaultAccount = {};
+				for (const key of [
+					"dmPolicy",
+					"allowFrom",
+					"groupPolicy",
+					"groupAllowFrom"
+				]) if (feishu[key] !== void 0) defaultAccount[key] = feishu[key];
+				if (Object.keys(defaultAccount).length > 0) {
+					accounts.default = defaultAccount;
+					merged.push("accounts.default");
+				}
+			}
+		}
+		if (backup.bindings && backup.bindings.length > 0) {
+			config.bindings = backup.bindings;
+			merged.push("bindings");
+		}
+		const backupAccounts = backup.channels?.feishu?.accounts;
+		if (backupAccounts && Object.keys(backupAccounts).length > 0) {
+			if (!config.channels) config.channels = {};
+			const ch = config.channels;
+			if (!ch.feishu) ch.feishu = {};
+			const feishu = ch.feishu;
+			if (!feishu.accounts) feishu.accounts = {};
+			Object.assign(feishu.accounts, backupAccounts);
+			merged.push("channels.feishu.accounts");
+		}
+		node_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+		log(`merged from coreBackup: [${merged.join(", ") || "nothing"}]`);
+	} else log("no coreBackup in resetData, skip multi-agent 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, log) {
+	const srcScriptsDir = node_path.default.join(srcDir, "scripts");
+	const targetScriptsDir = node_path.default.join(configDir, "scripts");
+	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: Install extensions from OSS tar.gz or fall back to `openclaw plugins update`.
+*
+*   1. Derive the OSS URL from the openclaw version in the template config
+*   2. Download tar.gz → extract to a staging dir
+*   3. For each included extension, backup (mv) the user's existing copy
+*      to a temp dir — extensions NOT in the archive are left untouched
+*   4. Move the fresh extensions from staging to the target dir
+*
+* This bypasses npm entirely and avoids the schema-priority mismatch where
+* `openclaw doctor --fix` would validate config against the bundled feishu
+* plugin's strict schema before openclaw-lark is installed.
+*
+* Falls back to `openclaw plugins update --all` if the OSS download fails.
+*/
+function installExtensions(configDir, log) {
+	const ossUrl = EXTENSIONS_OSS_URL;
+	const targetExtDir = node_path.default.join(configDir, "extensions");
+	const tmpDir = node_path.default.join(configDir, `.ext-reset-tmp-${Date.now()}`);
+	const tarPath = node_path.default.join(tmpDir, "extensions.tar.gz");
+	node_fs.default.mkdirSync(tmpDir, { recursive: true });
+	try {
+		log(`downloading extensions from ${ossUrl}`);
+		const dlStart = Date.now();
+		shell(`curl -fsSL '${ossUrl}' -o '${tarPath}'`, 5 * 6e4);
+		const size = node_fs.default.statSync(tarPath).size;
+		log(`download done in ${Date.now() - dlStart}ms (${(size / 1024 / 1024).toFixed(1)}MB)`);
+		shell(`tar -xzf '${tarPath}' -C '${tmpDir}'`, 6e4);
+		const stagedExtDir = node_path.default.join(tmpDir, "extensions");
+		if (!node_fs.default.existsSync(stagedExtDir)) throw new Error("tar.gz does not contain an extensions/ directory");
+		const extNames = node_fs.default.readdirSync(stagedExtDir).filter((name) => node_fs.default.statSync(node_path.default.join(stagedExtDir, name)).isDirectory());
+		log(`archive contains ${extNames.length} extension(s): ${extNames.join(", ")}`);
+		for (const name of extNames) {
+			const target = node_path.default.join(targetExtDir, name);
+			if (node_fs.default.existsSync(target)) node_fs.default.rmSync(target, {
+				recursive: true,
+				force: true
+			});
+			node_fs.default.renameSync(node_path.default.join(stagedExtDir, name), target);
+			log(`  ${name}: installed`);
+		}
+		const packinfo = node_path.default.join(stagedExtDir, ".packinfo.json");
+		if (node_fs.default.existsSync(packinfo)) {
+			node_fs.default.copyFileSync(packinfo, node_path.default.join(targetExtDir, ".packinfo.json"));
+			log(`packinfo: ${node_fs.default.readFileSync(packinfo, "utf-8").trim()}`);
+		}
+		log("extensions installed from OSS successfully");
+	} finally {
+		try {
+			node_fs.default.rmSync(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+/** Step 9: Write secrets/provider key files and restart openclaw. */
+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)) {
+		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.
+*
+* Each step is an independent function. The orchestrator handles progress
+* reporting, error handling, and process-level exception guards.
+*
+* The openclaw.json / scripts/*.sh template files are bundled with this CLI
+* (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) {
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const { configPath, vars, resetData } = input;
+	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"))) {
+		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 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, log);
+		step(2);
+		generateDefaultConfig(srcDir, configPath, resetData.templateVars, log);
+		step(3);
+		killOpenclawProcesses(log);
+		step(4);
+		waitForInitNpm(10 * 6e4, log);
+		step(5);
+		ensureOpenclawBinary(srcDir, configPath, log);
+		step(6);
+		mergeCoreBackupAndOrigins(configPath, vars, resetData, log);
+		step(7);
+		copyStartupScripts(srcDir, configDir, log);
+		step(8);
+		installExtensions(configDir, log);
+		step(9);
+		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) {
+		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);
+	}
+}
+//#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 = resetResultFile(taskId);
+	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 "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 = 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>");
+			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|reset|get_reset_task> [options]");
+		node_process.default.exit(1);
+}
 //#endregion

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@lark-apaas/openclaw-scripts-diagnose-cli",
-  "version": "0.1.1-alpha.2",
+  "version": "0.1.1-alpha.21",
   "description": "CLI for OpenClaw config diagnose and repair with JSON5 support",
   "main": "dist/index.cjs",
   "bin": {
     "mclaw-diagnose": "./dist/index.cjs"
   },
   "files": [
-    "dist"
+    "dist",
+    "template"
   ],
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:integration": "vitest run --config vitest.integration.config.ts",
+    "sync:template": "bash scripts/sync-template.sh",
     "prepublishOnly": "npm run build"
   },
   "keywords": [

package/template/openclaw.json

@@ -0,0 +1,539 @@
+{
+  "meta": {
+    "lastTouchedVersion": "2026.4.9",
+    "lastTouchedAt": "2026-04-13T03:14:33.386Z"
+  },
+  "wizard": {
+    "lastRunAt": "2026-03-30T14:54:56.160Z",
+    "lastRunVersion": "2026.3.24",
+    "lastRunCommand": "doctor",
+    "lastRunMode": "local"
+  },
+  "update": {
+    "checkOnStart": false
+  },
+  "browser": {
+    "enabled": true,
+    "color": "#00AA00",
+    "executablePath": "/usr/bin/chromium-browser",
+    "headless": true,
+    "noSandbox": true,
+    "defaultProfile": "openclaw",
+    "extraArgs": [
+      "--window-size=1920,1080",
+      "--test-type",
+      "--disable-gpu",
+      "--no-sandbox"
+    ]
+  },
+  "secrets": {
+    "providers": {
+      "miaoda-provider": {
+        "source": "file",
+        "path": "$$__MIAODA_PROVIDER_FILEPATH__",
+        "mode": "singleValue"
+      },
+      "miaoda-secret-provider": {
+        "source": "file",
+        "path": "$$__MIAODA_OPENCLAW_SECRETS_FILEPATH__",
+        "mode": "json"
+      }
+    }
+  },
+  "models": {
+    "providers": {
+      "miaoda": {
+        "baseUrl": "$$__MIAODA_PROVIDER_BASE_URL__",
+        "apiKey": {
+          "source": "file",
+          "provider": "miaoda-provider",
+          "id": "value"
+        },
+        "api": "openai-completions",
+        "headers": {
+          "x-api-key": {
+            "source": "file",
+            "provider": "miaoda-secret-provider",
+            "id": "/models_providers_miaoda_headers_x_api_key"
+          }
+        },
+        "models": [
+          {
+            "id": "miaoda-model-auto",
+            "name": "妙搭",
+            "reasoning": false,
+            "input": [
+              "text"
+            ],
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            },
+            "contextWindow": 200000,
+            "maxTokens": 8192
+          },
+          {
+            "id": "miaoda-auto-multimodal",
+            "name": "妙搭多模态",
+            "reasoning": false,
+            "input": [
+              "text",
+              "image"
+            ],
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            },
+            "contextWindow": 200000,
+            "maxTokens": 8192
+          },
+          {
+            "id": "miaoda-model-flash",
+            "name": "妙搭 Flash",
+            "reasoning": false,
+            "input": [
+              "text"
+            ],
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            },
+            "contextWindow": 200000,
+            "maxTokens": 8192
+          }
+        ]
+      }
+    }
+  },
+  "agents": {
+    "defaults": {
+      "model": {
+        "primary": "miaoda/miaoda-model-auto"
+      },
+      "imageModel": "miaoda/miaoda-auto-multimodal",
+      "imageGenerationModel": {
+        "primary": "miaoda/miaoda-image-gen"
+      },
+      "models": {
+        "miaoda/miaoda-model-auto": {
+          "alias": "Miaoda Auto"
+        },
+        "miaoda/miaoda-auto-multimodal": {
+          "alias": "Miaoda Multimodal"
+        },
+        "miaoda/miaoda-model-flash": {
+          "alias": "Miaoda Flash"
+        }
+      },
+      "workspace": "$$__MIAODA_WORKSPACE_DIR__/workspace",
+      "compaction": {
+        "mode": "safeguard",
+        "reserveTokensFloor": 50000
+      },
+      "verboseDefault": "off",
+      "blockStreamingCoalesce": {
+        "minChars": 20,
+        "maxChars": 800,
+        "idleMs": 300
+      },
+      "humanDelay": {
+        "mode": "off"
+      },
+      "heartbeat": {
+        "every": "4h",
+        "activeHours": {
+          "start": "08:00",
+          "end": "22:00"
+        },
+        "model": "miaoda/miaoda-model-flash"
+      },
+      "maxConcurrent": 4,
+      "subagents": {
+        "maxConcurrent": 8
+      }
+    }
+  },
+  "tools": {
+    "profile": "full",
+    "alsoAllow": [
+      "feishu_bitable_app",
+      "feishu_bitable_app_table",
+      "feishu_bitable_app_table_field",
+      "feishu_bitable_app_table_record",
+      "feishu_bitable_app_table_view",
+      "feishu_calendar_calendar",
+      "feishu_calendar_event",
+      "feishu_calendar_event_attendee",
+      "feishu_calendar_freebusy",
+      "feishu_chat",
+      "feishu_chat_members",
+      "feishu_create_doc",
+      "feishu_doc_comments",
+      "feishu_doc_media",
+      "feishu_drive_file",
+      "feishu_fetch_doc",
+      "feishu_get_user",
+      "feishu_im_bot_image",
+      "feishu_im_user_fetch_resource",
+      "feishu_im_user_get_messages",
+      "feishu_im_user_get_thread_messages",
+      "feishu_im_user_message",
+      "feishu_im_user_search_messages",
+      "feishu_oauth",
+      "feishu_oauth_batch_auth",
+      "feishu_search_doc_wiki",
+      "feishu_search_user",
+      "feishu_sheet",
+      "feishu_task_comment",
+      "feishu_task_subtask",
+      "feishu_task_task",
+      "feishu_task_tasklist",
+      "feishu_update_doc",
+      "feishu_wiki_space",
+      "feishu_wiki_space_node"
+    ],
+    "deny": [
+      "web_fetch",
+      "tts",
+      "agents_list",
+      "feishu_task_task",
+      "feishu_task_tasklist",
+      "feishu_task_comment",
+      "feishu_task_subtask",
+      "feishu_bitable_app_table_view",
+      "feishu_doc_comments",
+      "feishu_doc_media",
+      "feishu_drive_file",
+      "feishu_wiki_space",
+      "feishu_wiki_space_node",
+      "feishu_sheet"
+    ],
+    "web": {
+      "search": {
+        "provider": "miaoda"
+      }
+    },
+    "media": {
+      "image": {
+        "models": [
+          {
+            "provider": "miaoda"
+          }
+        ]
+      },
+      "audio": {
+        "models": [
+          {
+            "provider": "miaoda"
+          }
+        ]
+      }
+    },
+    "sessions": {
+      "visibility": "all"
+    }
+  },
+  "messages": {
+    "ackReactionScope": "group-mentions"
+  },
+  "commands": {
+    "native": "auto",
+    "nativeSkills": "auto",
+    "restart": true,
+    "ownerDisplay": "raw"
+  },
+  "session": {
+    "dmScope": "per-channel-peer"
+  },
+  "channels": {
+    "feishu": {
+      "enabled": true,
+      "appId": "$$__FEISHU_APP_ID__",
+      "appSecret": {
+        "source": "file",
+        "provider": "miaoda-secret-provider",
+        "id": "/channels_feishu_app_secret"
+      },
+      "domain": "feishu",
+      "requireMention": true,
+      "dmPolicy": "allowlist",
+      "allowFrom": [
+        "$$__FEISHU_OPEN_ID__"
+      ],
+      "groupPolicy": "allowlist",
+      "groupAllowFrom": [
+        "$$__FEISHU_OPEN_ID__"
+      ],
+      "groups": {
+        "*": {
+          "enabled": true
+        }
+      },
+      "streaming": true,
+      "threadSession": true,
+      "footer": {
+        "elapsed": false,
+        "status": false
+      }
+    }
+  },
+  "discovery": {
+    "mdns": {
+      "mode": "off"
+    }
+  },
+  "gateway": {
+    "port": 18789,
+    "mode": "local",
+    "bind": "loopback",
+    "controlUi": {
+      "allowedOrigins": [
+        "$$__MIAODA_DOMAIN__",
+        "$$__MIAODA_ORIGIN__"
+      ],
+      "dangerouslyDisableDeviceAuth": true
+    },
+    "auth": {
+      "mode": "token",
+      "token": "$$__CLAW_TOKEN__"
+    },
+    "trustedProxies": [
+      "::1",
+      "127.0.0.1"
+    ],
+    "tailscale": {
+      "mode": "off",
+      "resetOnExit": false
+    }
+  },
+  "skills": {
+    "install": {
+      "nodeManager": "npm"
+    },
+    "entries": {
+      "1password": {
+        "enabled": false
+      },
+      "apple-notes": {
+        "enabled": false
+      },
+      "apple-reminders": {
+        "enabled": false
+      },
+      "bear-notes": {
+        "enabled": false
+      },
+      "bluebubbles": {
+        "enabled": false
+      },
+      "blucli": {
+        "enabled": false
+      },
+      "camsnap": {
+        "enabled": false
+      },
+      "coding-agent": {
+        "enabled": false
+      },
+      "discord": {
+        "enabled": false
+      },
+      "eightctl": {
+        "enabled": false
+      },
+      "gemini": {
+        "enabled": false
+      },
+      "gifgrep": {
+        "enabled": false
+      },
+      "gog": {
+        "enabled": false
+      },
+      "goplaces": {
+        "enabled": false
+      },
+      "imsg": {
+        "enabled": false
+      },
+      "model-usage": {
+        "enabled": false
+      },
+      "notion": {
+        "enabled": false
+      },
+      "openai-image-gen": {
+        "enabled": false
+      },
+      "openai-whisper": {
+        "enabled": false
+      },
+      "openai-whisper-api": {
+        "enabled": false
+      },
+      "openhue": {
+        "enabled": false
+      },
+      "oracle": {
+        "enabled": false
+      },
+      "ordercli": {
+        "enabled": false
+      },
+      "peekaboo": {
+        "enabled": false
+      },
+      "sag": {
+        "enabled": false
+      },
+      "slack": {
+        "enabled": false
+      },
+      "sonoscli": {
+        "enabled": false
+      },
+      "spotify-player": {
+        "enabled": false
+      },
+      "summarize": {
+        "enabled": false
+      },
+      "things-mac": {
+        "enabled": false
+      },
+      "trello": {
+        "enabled": false
+      },
+      "voice-call": {
+        "enabled": false
+      },
+      "wacli": {
+        "enabled": false
+      },
+      "xurl": {
+        "enabled": false
+      },
+      "feishu-task": {
+        "enabled": false
+      },
+      "gh-issues": {
+        "enabled": false
+      },
+      "github": {
+        "enabled": false
+      },
+      "tmux": {
+        "enabled": false
+      },
+      "blogwatcher": {
+        "enabled": false
+      },
+      "himalaya": {
+        "enabled": false
+      },
+      "video-frames": {
+        "enabled": false
+      },
+      "obsidian": {
+        "enabled": false
+      }
+    }
+  },
+  "plugins": {
+    "allow": [
+      "openclaw-lark",
+      "openclaw-extension-miaoda-coding",
+      "browser",
+      "openclaw-mem0-plugin",
+      "openclaw-extension-miaoda"
+    ],
+    "entries": {
+      "feishu": {
+        "enabled": false
+      },
+      "openclaw-lark": {
+        "enabled": true
+      },
+      "openclaw-extension-miaoda-coding": {
+        "enabled": true
+      },
+      "browser": {
+        "enabled": true
+      },
+      "openclaw-mem0-plugin": {
+        "enabled": false
+      },
+      "openclaw-extension-miaoda": {
+        "enabled": true,
+        "config": {
+          "greeting": {
+            "message": "👋 Hi，我是**$$__MIAODA_CLAW_NAME__**，一只生活在飞书里的 🦞 小龙虾，打个招呼，我们开始认识一下？",
+            "targets": [
+              "$$__FEISHU_OPEN_ID__"
+            ]
+          }
+        }
+      }
+    },
+    "installs": {
+      "openclaw-lark": {
+        "source": "npm",
+        "spec": "@lark-apaas/openclaw-lark",
+        "installPath": "./extensions/openclaw-lark",
+        "version": "2026.4.3",
+        "resolvedName": "@lark-apaas/openclaw-lark",
+        "resolvedVersion": "2026.4.3",
+        "resolvedSpec": "@lark-apaas/openclaw-lark@2026.4.3",
+        "integrity": "sha512-1eJ2WCvAYsnM9TPwPbEoD3nJtqNSOP2zOBV/3Vb9YQRg1kJJspEly5yCjiZt1wew4UhyN8Tcrp/XV78Qn747GA==",
+        "shasum": "e8d8cf05f8cb96cf5de4bca097c527eb9116e655",
+        "resolvedAt": "2026-04-03T06:27:44.706Z",
+        "installedAt": "2026-04-03T06:28:10.547Z"
+      },
+      "openclaw-extension-miaoda-coding": {
+        "source": "npm",
+        "spec": "@lark-apaas/openclaw-extension-miaoda-coding",
+        "installPath": "./extensions/openclaw-extension-miaoda-coding",
+        "version": "1.0.11",
+        "resolvedName": "@lark-apaas/openclaw-extension-miaoda-coding",
+        "resolvedVersion": "1.0.11",
+        "resolvedSpec": "@lark-apaas/openclaw-extension-miaoda-coding@1.0.11",
+        "integrity": "sha512-B2i3n367cR37UVJrDCTZSBljxUYzDZ4gWf3dw79XBdaZcq0G88XnkgyFmJoZijQd/HQP13xNBlfcLk4Lz2c6Bg==",
+        "shasum": "a6bf5efcec70bbd139ee7a75ea183e4f9751fd39",
+        "resolvedAt": "2026-04-13T14:40:18.926Z",
+        "installedAt": "2026-04-13T14:40:18.926Z"
+      },
+      "openclaw-mem0-plugin": {
+        "source": "npm",
+        "spec": "@shareclz/openclaw-mem0-plugin@1.1.2",
+        "installPath": "./extensions/openclaw-mem0-plugin",
+        "installedAt": "2026-04-13T03:13:10.564Z",
+        "version": "1.1.2",
+        "resolvedVersion": "1.1.2",
+        "resolvedName": "@shareclz/openclaw-mem0-plugin",
+        "resolvedSpec": "@shareclz/openclaw-mem0-plugin@1.1.2",
+        "resolvedAt": "2026-04-13T03:13:10.564Z",
+        "integrity": "sha512-j6m8oN6ykVc3a1/Bw0o7LmXmNApiGk6wxafrT0zW9m4UiqZe8LM4Y2LzvGEAnKwFdkUIkaSzpl/8Qp7MPy/zcQ==",
+        "shasum": "b1bdaa44917ce9535ba1acddb145ea0ed5d26bae"
+      },
+      "openclaw-extension-miaoda": {
+        "source": "npm",
+        "installPath": "./extensions/openclaw-extension-miaoda",
+        "version": "1.0.10",
+        "installedAt": "2026-04-14T12:21:23.090Z",
+        "spec": "@lark-apaas/openclaw-extension-miaoda@1.0.10",
+        "resolvedVersion": "1.0.10",
+        "resolvedName": "@lark-apaas/openclaw-extension-miaoda",
+        "resolvedSpec": "@lark-apaas/openclaw-extension-miaoda@1.0.10",
+        "resolvedAt": "2026-04-14T12:21:23.090Z",
+        "integrity": "sha512-aWXIBdzcjUQAdthiUjLhgGp8G0TMVB3wpAzR3wjscDRX7XAo1zhpmcWkBM0JNdrle1i3e5eB4hxVcLfn1yooNw==",
+        "shasum": "5ef5f6ef972d90b43091c79e8a1038a3052cc1f5"
+      }
+    }
+  }
+}

package/template/scripts/restart.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+log() { echo "[restart.sh] $(date '+%Y-%m-%d %H:%M:%S') $*"; }
+
+gw_alive() {
+    pgrep -f "openclaw-gateway|openclaw gateway" | grep -vw "$$" >/dev/null 2>&1
+}
+
+if [ -d "/run/systemd/system/" ]; then
+    log "systemd detected, restarting via systemctl..."
+    sudo systemctl restart openclaw
+    log "systemctl restart exit code: $?"
+else
+    log "killing openclaw-gateway processes..."
+    PIDS_GW=$(pgrep -f "openclaw-gateway|openclaw gateway" | grep -vw "$$" || true)
+    if [ -n "$PIDS_GW" ]; then
+        log "killing gateway pids: $(echo $PIDS_GW | tr '\n' ' ')"
+        kill -9 $PIDS_GW 2>&1
+    else
+        log "no openclaw-gateway processes found"
+    fi
+
+    for i in $(seq 1 50); do
+        gw_alive || break
+        sleep 0.1
+    done
+
+    if gw_alive; then
+        log "ERROR: openclaw-gateway still alive after 5s, abort"
+        exit 1
+    fi
+    log "openclaw-gateway stopped"
+
+    log "starting openclaw gateway..."
+    nohup openclaw gateway run --port 18789 > /tmp/openclaw-gateway.log 2>&1 &
+    log "gateway started (pid=$!)"
+fi

package/template/scripts/start.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+if [ -d "/run/systemd/system/" ]; then
+    sudo systemctl start openclaw
+else
+    nohup openclaw gateway run --port 18789 > /tmp/openclaw-gateway.log 2>&1 &
+fi

package/template/scripts/stop.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+lsof -nP -iTCP:18789 -sTCP:LISTEN -t | xargs -r kill -9