denchclaw 2.0.1 → 2.0.4

package/dist/{program-DhxRjAOe.js → program-BjjW6tCn.js}

@@ -1,5 +1,6 @@
-import { c as hasFlag, d as applyCliProfileEnv, f as expandHomePrefix, i as defaultRuntime, p as resolveRequiredHomeDir, s as getPrimaryCommand, t as isTruthyEnvValue, u as hasRootVersionAlias } from "./entry.js";
-import { a as hasEmittedCliBanner, c as theme, i as formatCliBannerLine, n as resolveCliName, o as VERSION, s as isRich, t as replaceCliName } from "./cli-name-8WJ6gVD5.js";
+import { a as readTelemetryConfig, i as markNoticeShown, o as writeTelemetryConfig, r as track, t as isTelemetryEnabled } from "./telemetry-Drjj3hin.js";
+import { a as defaultRuntime, c as getPrimaryCommand, d as hasRootVersionAlias, f as applyCliProfileEnv, l as hasFlag, m as resolveRequiredHomeDir, p as expandHomePrefix, t as isTruthyEnvValue } from "./entry.js";
+import { a as hasEmittedCliBanner, c as theme, i as formatCliBannerLine, n as resolveCliName, o as VERSION, s as isRich, t as replaceCliName } from "./cli-name-yhDyCrts.js";
 import { execFileSync, spawn } from "node:child_process";
 import process$1 from "node:process";
 import os from "node:os";
@@ -681,7 +682,7 @@ Your browser automation behavior is defined by the Browser skill at:
 
 ## Links
 
-- Website: https://denchclaw.sh
+- Website: https://denchclaw.com
 - GitHub: https://github.com/DenchHQ/denchclaw
 - Skills Store: https://skills.sh
 
@@ -833,6 +834,10 @@ const MAX_PORT_SCAN_ATTEMPTS = 100;
 const DEFAULT_BOOTSTRAP_ROLLOUT_STAGE = "default";
 const DEFAULT_GATEWAY_LAUNCH_AGENT_LABEL = "ai.openclaw.gateway";
 const REQUIRED_TOOLS_PROFILE = "full";
+const OPENCLAW_CLI_CHECK_CACHE_TTL_MS = 5 * 6e4;
+const OPENCLAW_UPDATE_PROMPT_SUPPRESS_AFTER_INSTALL_MS = 5 * 6e4;
+const OPENCLAW_CLI_CHECK_CACHE_FILE = "openclaw-cli-check.json";
+const OPENCLAW_SETUP_PROGRESS_BAR_WIDTH = 16;
 function resolveCommandForPlatform(command) {
 	if (process$1.platform !== "win32") return command;
 	if (path.extname(command)) return command;
@@ -869,10 +874,20 @@ async function runCommandWithTimeout(argv, options) {
 			child.kill("SIGKILL");
 		}, options.timeoutMs);
 		child.stdout?.on("data", (chunk) => {
-			stdout += String(chunk);
+			const text = String(chunk);
+			stdout += text;
+			if (options.onOutputLine) for (const segment of text.split(/\r?\n/)) {
+				const line = segment.trim();
+				if (line.length > 0) options.onOutputLine(line, "stdout");
+			}
 		});
 		child.stderr?.on("data", (chunk) => {
-			stderr += String(chunk);
+			const text = String(chunk);
+			stderr += text;
+			if (options.onOutputLine) for (const segment of text.split(/\r?\n/)) {
+				const line = segment.trim();
+				if (line.length > 0) options.onOutputLine(line, "stderr");
+			}
 		});
 		child.once("error", (error) => {
 			if (settled) return;
@@ -1042,11 +1057,12 @@ async function ensureToolsProfile(openclawCommand, profile) {
 		errorMessage: `Failed to set tools.profile=${REQUIRED_TOOLS_PROFILE}.`
 	});
 }
-async function runOpenClaw(openclawCommand, args, timeoutMs, ioMode = "capture", env) {
+async function runOpenClaw(openclawCommand, args, timeoutMs, ioMode = "capture", env, onOutputLine) {
 	return await runCommandWithTimeout([openclawCommand, ...args], {
 		timeoutMs,
 		ioMode,
-		env
+		env,
+		onOutputLine
 	});
 }
 async function runOpenClawOrThrow(params) {
@@ -1143,7 +1159,92 @@ function parseJsonPayload(raw) {
 		}
 	}
 }
-async function detectGlobalOpenClawInstall() {
+function resolveOpenClawCliCheckCachePath(stateDir) {
+	return path.join(stateDir, "cache", OPENCLAW_CLI_CHECK_CACHE_FILE);
+}
+function readOpenClawCliCheckCache(stateDir) {
+	const cachePath = resolveOpenClawCliCheckCachePath(stateDir);
+	if (!existsSync(cachePath)) return;
+	try {
+		const parsed = JSON.parse(readFileSync(cachePath, "utf-8"));
+		if (typeof parsed.checkedAt !== "number" || !Number.isFinite(parsed.checkedAt) || typeof parsed.pathEnv !== "string" || parsed.pathEnv !== (process$1.env.PATH ?? "") || typeof parsed.available !== "boolean" || !parsed.available || typeof parsed.command !== "string" || parsed.command.length === 0) return;
+		const ageMs = Date.now() - parsed.checkedAt;
+		if (ageMs < 0 || ageMs > OPENCLAW_CLI_CHECK_CACHE_TTL_MS) return;
+		if ((parsed.command.includes(path.sep) || parsed.command.includes("/") || parsed.command.includes("\\")) && !existsSync(parsed.command)) return;
+		return {
+			checkedAt: parsed.checkedAt,
+			pathEnv: parsed.pathEnv,
+			available: parsed.available,
+			command: parsed.command,
+			version: typeof parsed.version === "string" ? parsed.version : void 0,
+			globalBinDir: typeof parsed.globalBinDir === "string" ? parsed.globalBinDir : void 0,
+			shellCommandPath: typeof parsed.shellCommandPath === "string" ? parsed.shellCommandPath : void 0,
+			installedAt: typeof parsed.installedAt === "number" ? parsed.installedAt : void 0
+		};
+	} catch {
+		return;
+	}
+}
+function writeOpenClawCliCheckCache(stateDir, cache) {
+	try {
+		const cachePath = resolveOpenClawCliCheckCachePath(stateDir);
+		mkdirSync(path.dirname(cachePath), { recursive: true });
+		const payload = {
+			...cache,
+			checkedAt: Date.now(),
+			pathEnv: process$1.env.PATH ?? ""
+		};
+		writeFileSync(cachePath, JSON.stringify(payload, null, 2), "utf-8");
+	} catch {}
+}
+function createOpenClawSetupProgress(params) {
+	if (!params.enabled || params.totalStages <= 0 || !process$1.stdout.isTTY) {
+		const noop = () => void 0;
+		return {
+			startStage: noop,
+			output: noop,
+			completeStage: noop,
+			finish: noop,
+			fail: noop
+		};
+	}
+	const s = spinner();
+	let completedStages = 0;
+	let activeLabel = "";
+	const renderBar = () => {
+		const ratio = completedStages / params.totalStages;
+		const filled = Math.max(0, Math.min(OPENCLAW_SETUP_PROGRESS_BAR_WIDTH, Math.round(ratio * OPENCLAW_SETUP_PROGRESS_BAR_WIDTH)));
+		return `[${`${"#".repeat(filled)}${"-".repeat(OPENCLAW_SETUP_PROGRESS_BAR_WIDTH - filled)}`}] ${completedStages}/${params.totalStages}`;
+	};
+	const truncate = (value, max = 84) => value.length > max ? `${value.slice(0, max - 3)}...` : value;
+	const renderStageLine = (detail) => {
+		const base = `${renderBar()} ${activeLabel}`.trim();
+		if (!detail) return base;
+		return truncate(`${base} -> ${detail}`);
+	};
+	return {
+		startStage: (label) => {
+			activeLabel = label;
+			s.start(renderStageLine());
+		},
+		output: (line) => {
+			if (!line) return;
+			s.message(renderStageLine(line));
+		},
+		completeStage: (suffix) => {
+			completedStages = Math.min(params.totalStages, completedStages + 1);
+			s.stop(renderStageLine(suffix ?? "done"));
+		},
+		finish: (message) => {
+			completedStages = params.totalStages;
+			s.stop(`${renderBar()} ${truncate(message)}`.trim());
+		},
+		fail: (message) => {
+			s.stop(`${renderBar()} ${truncate(message)}`.trim());
+		}
+	};
+}
+async function detectGlobalOpenClawInstall(onOutputLine) {
 	const result = await runCommandWithTimeout([
 		"npm",
 		"ls",
@@ -1152,7 +1253,10 @@ async function detectGlobalOpenClawInstall() {
 		"--depth=0",
 		"--json",
 		"--silent"
-	], { timeoutMs: 15e3 }).catch(() => null);
+	], {
+		timeoutMs: 15e3,
+		onOutputLine
+	}).catch(() => null);
 	const installedVersion = (parseJsonPayload(result?.stdout ?? result?.stderr)?.dependencies)?.openclaw?.version;
 	if (typeof installedVersion === "string" && installedVersion.length > 0) return {
 		installed: true,
@@ -1160,12 +1264,15 @@ async function detectGlobalOpenClawInstall() {
 	};
 	return { installed: false };
 }
-async function resolveNpmGlobalBinDir() {
+async function resolveNpmGlobalBinDir(onOutputLine) {
 	const result = await runCommandWithTimeout([
 		"npm",
 		"prefix",
 		"-g"
-	], { timeoutMs: 8e3 }).catch(() => null);
+	], {
+		timeoutMs: 8e3,
+		onOutputLine
+	}).catch(() => null);
 	if (!result || result.code !== 0) return;
 	const prefix = firstNonEmptyLine$1(result.stdout);
 	if (!prefix) return;
@@ -1175,8 +1282,11 @@ function resolveGlobalOpenClawCommand(globalBinDir) {
 	if (!globalBinDir) return;
 	return (process$1.platform === "win32" ? [path.join(globalBinDir, "openclaw.cmd"), path.join(globalBinDir, "openclaw.exe")] : [path.join(globalBinDir, "openclaw")]).find((candidate) => existsSync(candidate));
 }
-async function resolveShellOpenClawPath() {
-	const result = await runCommandWithTimeout([process$1.platform === "win32" ? "where" : "which", "openclaw"], { timeoutMs: 4e3 }).catch(() => null);
+async function resolveShellOpenClawPath(onOutputLine) {
+	const result = await runCommandWithTimeout([process$1.platform === "win32" ? "where" : "which", "openclaw"], {
+		timeoutMs: 4e3,
+		onOutputLine
+	}).catch(() => null);
 	if (!result || result.code !== 0) return;
 	return firstNonEmptyLine$1(result.stdout);
 }
@@ -1184,33 +1294,98 @@ function isProjectLocalOpenClawPath(commandPath) {
 	if (!commandPath) return false;
 	return commandPath.replaceAll("\\", "/").includes("/node_modules/.bin/openclaw");
 }
-async function ensureOpenClawCliAvailable() {
-	const globalBefore = await detectGlobalOpenClawInstall();
+async function ensureOpenClawCliAvailable(params) {
+	const cached = readOpenClawCliCheckCache(params.stateDir);
+	if (cached) {
+		const ageSeconds = Math.max(0, Math.floor((Date.now() - cached.checkedAt) / 1e3));
+		const progress = createOpenClawSetupProgress({
+			enabled: params.showProgress,
+			totalStages: 1
+		});
+		progress.startStage("Reusing cached OpenClaw install check");
+		progress.completeStage(`cache hit (${ageSeconds}s old)`);
+		return {
+			available: true,
+			installed: false,
+			installedAt: cached.installedAt,
+			version: cached.version,
+			command: cached.command,
+			globalBinDir: cached.globalBinDir,
+			shellCommandPath: cached.shellCommandPath
+		};
+	}
+	const progress = createOpenClawSetupProgress({
+		enabled: params.showProgress,
+		totalStages: 5
+	});
+	progress.startStage("Checking global OpenClaw install");
+	const globalBefore = await detectGlobalOpenClawInstall((line) => {
+		progress.output(`npm ls: ${line}`);
+	});
+	progress.completeStage(globalBefore.installed ? `found ${globalBefore.version ?? "installed"}` : "missing");
 	let installed = false;
+	let installedAt;
+	progress.startStage("Ensuring openclaw@latest is installed globally");
 	if (!globalBefore.installed) {
 		const install = await runCommandWithTimeout([
 			"npm",
 			"install",
 			"-g",
 			"openclaw@latest"
-		], { timeoutMs: 10 * 6e4 }).catch(() => null);
-		if (!install || install.code !== 0) return {
-			available: false,
-			installed: false,
-			version: void 0,
-			command: "openclaw"
-		};
+		], {
+			timeoutMs: 10 * 6e4,
+			onOutputLine: (line) => {
+				progress.output(`npm install: ${line}`);
+			}
+		}).catch(() => null);
+		if (!install || install.code !== 0) {
+			progress.fail("OpenClaw global install failed.");
+			return {
+				available: false,
+				installed: false,
+				version: void 0,
+				command: "openclaw"
+			};
+		}
 		installed = true;
-	}
-	const globalAfter = installed ? await detectGlobalOpenClawInstall() : globalBefore;
-	const globalBinDir = await resolveNpmGlobalBinDir();
+		installedAt = Date.now();
+		progress.completeStage("installed openclaw@latest");
+	} else progress.completeStage("already installed; skipping install");
+	progress.startStage("Resolving global and shell OpenClaw paths");
+	const [globalBinDir, shellCommandPath] = await Promise.all([resolveNpmGlobalBinDir((line) => {
+		progress.output(`npm prefix: ${line}`);
+	}), resolveShellOpenClawPath((line) => {
+		progress.output(`${process$1.platform === "win32" ? "where" : "which"}: ${line}`);
+	})]);
+	progress.completeStage("path discovery complete");
+	const globalAfter = installed ? {
+		installed: true,
+		version: globalBefore.version
+	} : globalBefore;
 	const command = resolveGlobalOpenClawCommand(globalBinDir) ?? "openclaw";
-	const check = await runOpenClaw(command, ["--version"], 4e3).catch(() => null);
-	const shellCommandPath = await resolveShellOpenClawPath();
+	progress.startStage("Verifying OpenClaw CLI responsiveness");
+	const check = await runOpenClaw(command, ["--version"], 4e3, "capture", void 0, (line) => {
+		progress.output(`openclaw --version: ${line}`);
+	}).catch(() => null);
+	progress.completeStage(check?.code === 0 ? "OpenClaw responded" : "OpenClaw version probe failed");
 	const version = normalizeVersionOutput(check?.stdout || check?.stderr || globalAfter.version);
+	const available = Boolean(globalAfter.installed && check && check.code === 0);
+	progress.startStage("Caching OpenClaw check result");
+	if (available) {
+		writeOpenClawCliCheckCache(params.stateDir, {
+			available,
+			command,
+			version,
+			globalBinDir,
+			shellCommandPath,
+			installedAt
+		});
+		progress.completeStage(`saved (${Math.floor(OPENCLAW_CLI_CHECK_CACHE_TTL_MS / 6e4)}m TTL)`);
+	} else progress.fail("OpenClaw CLI check failed (cache not written).");
 	return {
-		available: Boolean(globalAfter.installed && check && check.code === 0),
+		available,
 		installed,
+		installedAt,
 		version,
 		command,
 		globalBinDir,
@@ -1515,6 +1690,10 @@ function logBootstrapChecklist(diagnostics, runtime) {
 async function shouldRunUpdate(params) {
 	if (params.opts.updateNow) return true;
 	if (params.opts.skipUpdate || params.opts.nonInteractive || params.opts.json || !process$1.stdin.isTTY) return false;
+	if (params.installResult.installed || typeof params.installResult.installedAt === "number" && Date.now() - params.installResult.installedAt <= OPENCLAW_UPDATE_PROMPT_SUPPRESS_AFTER_INSTALL_MS) {
+		params.runtime.log(theme.muted("Skipping update prompt because OpenClaw was installed moments ago."));
+		return false;
+	}
 	const decision = await confirm({
 		message: stylePromptMessage("Check and install OpenClaw updates now?"),
 		initialValue: false
@@ -1531,8 +1710,21 @@ async function bootstrapCommand(opts, runtime = defaultRuntime) {
 	const legacyFallbackEnabled = isLegacyFallbackEnabled();
 	const appliedProfile = applyCliProfileEnv({ profile: opts.profile });
 	const profile = appliedProfile.effectiveProfile;
+	const stateDir = resolveProfileStateDir(profile);
+	const workspaceDir = resolveBootstrapWorkspaceDir(stateDir);
 	if (appliedProfile.warning && !opts.json) runtime.log(theme.warn(appliedProfile.warning));
-	const installResult = await ensureOpenClawCliAvailable();
+	const bootstrapStartTime = Date.now();
+	track("cli_bootstrap_started", { version: VERSION });
+	if (!opts.json) {
+		if (!readTelemetryConfig().noticeShown) {
+			runtime.log(theme.muted("DenchClaw collects anonymous telemetry to improve the product.\nNo personal data is ever collected. Disable anytime:\n  denchclaw telemetry disable\n  DENCHCLAW_TELEMETRY_DISABLED=1\n  DO_NOT_TRACK=1\nLearn more: https://github.com/openclaw/openclaw/blob/main/TELEMETRY.md\n"));
+			markNoticeShown();
+		}
+	}
+	const installResult = await ensureOpenClawCliAvailable({
+		stateDir,
+		showProgress: !opts.json
+	});
 	if (!installResult.available) throw new Error([
 		"OpenClaw CLI is required but unavailable.",
 		"Install it with: npm install -g openclaw",
@@ -1541,7 +1733,8 @@ async function bootstrapCommand(opts, runtime = defaultRuntime) {
 	const openclawCommand = installResult.command;
 	if (await shouldRunUpdate({
 		opts,
-		runtime
+		runtime,
+		installResult
 	})) await runOpenClawWithProgress({
 		openclawCommand,
 		args: ["update", "--yes"],
@@ -1561,8 +1754,6 @@ async function bootstrapCommand(opts, runtime = defaultRuntime) {
 		gatewayPort = availablePort;
 		portAutoAssigned = true;
 	}
-	const stateDir = resolveProfileStateDir(profile);
-	const workspaceDir = resolveBootstrapWorkspaceDir(stateDir);
 	if (portAutoAssigned && !opts.json) runtime.log(theme.muted(`Default gateway port ${DEFAULT_GATEWAY_PORT} is in use. Using auto-assigned port ${gatewayPort}.`));
 	await ensureDefaultWorkspacePath(openclawCommand, profile, workspaceDir);
 	const onboardArgv = [
@@ -1695,6 +1886,13 @@ async function bootstrapCommand(opts, runtime = defaultRuntime) {
 		webOpened: opened,
 		diagnostics
 	};
+	track("cli_bootstrap_completed", {
+		duration_ms: Date.now() - bootstrapStartTime,
+		workspace_created: Boolean(workspaceSeed),
+		gateway_reachable: gatewayProbe.ok,
+		web_reachable: webReachable,
+		version: VERSION
+	});
 	if (opts.json) runtime.log(JSON.stringify(summary, null, 2));
 	return summary;
 }
@@ -1967,6 +2165,63 @@ async function stopWebRuntimeCommand(opts, runtime = defaultRuntime) {
 	if (summary.skippedForeignPids.length > 0) runtime.log(theme.warn(`Left non-Dench listener(s) running on ${selectedPort}: ${summary.skippedForeignPids.join(", ")}`));
 	return summary;
 }
+async function startWebRuntimeCommand(opts, runtime = defaultRuntime) {
+	const appliedProfile = applyCliProfileEnv({ profile: opts.profile });
+	const profile = appliedProfile.effectiveProfile;
+	if (appliedProfile.warning && !opts.json) runtime.log(theme.warn(appliedProfile.warning));
+	const stateDir = resolveProfileStateDir(profile);
+	const selectedPort = parseOptionalPort(opts.webPort) ?? readLastKnownWebPort(stateDir);
+	const gatewayPort = resolveGatewayPort(stateDir);
+	const stopResult = await stopManagedWebRuntime({
+		stateDir,
+		port: selectedPort,
+		includeLegacyStandalone: true
+	});
+	if (stopResult.skippedForeignPids.length > 0) throw new Error(`Cannot start on ${selectedPort}; non-Dench listener(s) still own the port: ${stopResult.skippedForeignPids.join(", ")}`);
+	if (!startManagedWebRuntime({
+		stateDir,
+		port: selectedPort,
+		gatewayPort
+	}).started) {
+		const runtimeServerPath = resolveManagedWebRuntimeServerPath(stateDir);
+		throw new Error([`Managed web runtime is missing at ${runtimeServerPath}.`, "Run `dench update` (or `dench bootstrap`) to install/update the web runtime first."].join(" "));
+	}
+	const probe = await waitForWebRuntime(selectedPort);
+	const summary = {
+		profile,
+		webPort: selectedPort,
+		stoppedPids: stopResult.stoppedPids,
+		skippedForeignPids: stopResult.skippedForeignPids,
+		started: probe.ok,
+		reason: probe.reason
+	};
+	if (opts.json) {
+		runtime.log(JSON.stringify(summary, null, 2));
+		return summary;
+	}
+	runtime.log("");
+	runtime.log(theme.heading("Dench web start"));
+	runtime.log(`Profile: ${profile}`);
+	runtime.log(`Web port: ${selectedPort}`);
+	runtime.log(`Restarted managed web runtime: ${summary.started ? "yes" : "no"}`);
+	if (!summary.started) runtime.log(theme.warn(summary.reason));
+	if (!summary.started) throw new Error(`Web runtime failed readiness probe: ${summary.reason}`);
+	return summary;
+}
+
+//#endregion
+//#region src/cli/program/register.start.ts
+function registerStartCommand(program) {
+	program.command("start").description("Start Dench managed web runtime without updating assets").option("--profile <name>", "Compatibility flag; non-dench values are ignored with a warning").option("--web-port <port>", "Web runtime port override").option("--json", "Output summary as JSON", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			await startWebRuntimeCommand({
+				profile: opts.profile,
+				webPort: opts.webPort,
+				json: Boolean(opts.json)
+			});
+		});
+	});
+}
 
 //#endregion
 //#region src/cli/program/register.stop.ts
@@ -1982,6 +2237,30 @@ function registerStopCommand(program) {
 	});
 }
 
+//#endregion
+//#region src/cli/program/register.telemetry.ts
+function registerTelemetryCommand(program) {
+	const cmd = program.command("telemetry").description("Manage anonymous telemetry for DenchClaw");
+	cmd.command("status").description("Show current telemetry status").action(() => {
+		const config = readTelemetryConfig();
+		const envDisabled = process.env.DO_NOT_TRACK === "1" || process.env.DENCHCLAW_TELEMETRY_DISABLED === "1" || Boolean(process.env.CI);
+		const effective = isTelemetryEnabled();
+		console.log(`Telemetry config:  ${config.enabled ? "enabled" : "disabled"}`);
+		if (envDisabled) console.log("Environment override: disabled (DO_NOT_TRACK, DENCHCLAW_TELEMETRY_DISABLED, or CI)");
+		console.log(`Effective status:  ${effective ? "enabled" : "disabled"}`);
+		console.log("\nLearn more: https://github.com/openclaw/openclaw/blob/main/TELEMETRY.md");
+	});
+	cmd.command("disable").description("Disable anonymous telemetry").action(() => {
+		writeTelemetryConfig({ enabled: false });
+		console.log("Telemetry has been disabled.");
+		console.log("You can re-enable it anytime with: denchclaw telemetry enable");
+	});
+	cmd.command("enable").description("Enable anonymous telemetry").action(() => {
+		writeTelemetryConfig({ enabled: true });
+		console.log("Telemetry has been enabled. Thank you for helping improve DenchClaw!");
+	});
+}
+
 //#endregion
 //#region src/cli/program/register.update.ts
 function registerUpdateCommand(program) {
@@ -2021,6 +2300,20 @@ const CORE_CLI_ENTRIES = [
 		register: ({ program }) => {
 			registerStopCommand(program);
 		}
+	},
+	{
+		name: "start",
+		description: "Start Dench managed web runtime",
+		register: ({ program }) => {
+			registerStartCommand(program);
+		}
+	},
+	{
+		name: "telemetry",
+		description: "Manage anonymous telemetry",
+		register: ({ program }) => {
+			registerTelemetryCommand(program);
+		}
 	}
 ];
 const CORE_CLI_ENTRY_BY_NAME = new Map(CORE_CLI_ENTRIES.map((entry) => [entry.name, entry]));
@@ -2068,6 +2361,7 @@ const CLI_NAME_PATTERN = escapeRegExp(CLI_NAME);
 const ROOT_COMMANDS_WITH_SUBCOMMANDS = new Set(getCoreCliCommandsWithSubcommands());
 const ROOT_COMMANDS_HINT = "Hint: commands suffixed with * have subcommands. Run <command> --help for details.";
 const EXAMPLES = [
+	["openclaw start --web-port 3100", "Start the managed web runtime without replacing assets."],
 	["openclaw update", "Refresh the managed web runtime and enforce major upgrade gates."],
 	["openclaw stop --web-port 3100", "Stop only the managed web runtime on a specific port."],
 	["openclaw models --help", "Show detailed help for the models command."],

package/dist/{run-main-oHgYgpCR.js → run-main-CZ4r6_2T.js}

@@ -1,5 +1,5 @@
-import { a as normalizeWindowsArgv, l as hasHelpOrVersion, n as normalizeEnv, o as getCommandPath, s as getPrimaryCommand, t as isTruthyEnvValue } from "./entry.js";
-import { n as resolveCliName, o as VERSION, r as emitCliBanner } from "./cli-name-8WJ6gVD5.js";
+import { c as getPrimaryCommand, n as normalizeEnv, o as normalizeWindowsArgv, s as getCommandPath, t as isTruthyEnvValue, u as hasHelpOrVersion } from "./entry.js";
+import { n as resolveCliName, o as VERSION, r as emitCliBanner } from "./cli-name-yhDyCrts.js";
 import { spawn } from "node:child_process";
 import process$1 from "node:process";
 import os from "node:os";
@@ -174,7 +174,11 @@ function shouldDelegateToGlobalOpenClaw(argv, env = process$1.env) {
 	if (isDelegationDisabled(env)) return false;
 	const primary = getPrimaryCommand(argv);
 	if (!primary) return false;
-	return primary !== "bootstrap" && primary !== "update" && primary !== "stop";
+	return primary !== "bootstrap" && primary !== "update" && primary !== "stop" && primary !== "start";
+}
+function shouldHideCliBanner(argv, env = process$1.env) {
+	const commandPath = getCommandPath(argv, 2);
+	return isTruthyEnvValue(env.DENCHCLAW_HIDE_BANNER) || isTruthyEnvValue(env.OPENCLAW_HIDE_BANNER) || commandPath[0] === "completion" || commandPath[0] === "plugins" && commandPath[1] === "update";
 }
 async function delegateToGlobalOpenClaw(argv) {
 	if (isTruthyEnvValue(process$1.env.DENCHCLAW_DELEGATED) || isTruthyEnvValue(process$1.env.OPENCLAW_DELEGATED)) throw new Error("OpenClaw delegation loop detected. Check PATH so `openclaw` resolves to the global OpenClaw CLI.");
@@ -209,14 +213,13 @@ async function runCli(argv = process$1.argv) {
 	normalizeEnv();
 	if (shouldEnsureCliPath(normalizedArgv)) ensureOpenClawCliOnPath();
 	assertSupportedRuntime();
-	const commandPath = getCommandPath(normalizedArgv, 2);
-	if (!(isTruthyEnvValue(process$1.env.DENCHCLAW_HIDE_BANNER) || isTruthyEnvValue(process$1.env.OPENCLAW_HIDE_BANNER) || commandPath[0] === "update" || commandPath[0] === "stop" || commandPath[0] === "completion" || commandPath[0] === "plugins" && commandPath[1] === "update")) await emitCliBanner(VERSION, { argv: normalizedArgv });
+	if (!shouldHideCliBanner(normalizedArgv, process$1.env)) await emitCliBanner(VERSION, { argv: normalizedArgv });
 	const parseArgv = rewriteBareArgvToBootstrap(rewriteUpdateFlagArgv(normalizedArgv));
 	if (shouldDelegateToGlobalOpenClaw(parseArgv)) {
 		process$1.exitCode = await delegateToGlobalOpenClaw(parseArgv);
 		return;
 	}
-	const { buildProgram } = await import("./program-DhxRjAOe.js");
+	const { buildProgram } = await import("./program-BjjW6tCn.js");
 	await buildProgram().parseAsync(parseArgv);
 }
 

package/dist/telemetry-Drjj3hin.js

@@ -0,0 +1,118 @@
+import { r as resolveStateDir } from "./entry.js";
+import { createRequire } from "node:module";
+import os from "node:os";
+import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import "posthog-node";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/telemetry/config.ts
+const TELEMETRY_FILENAME = "telemetry.json";
+function telemetryConfigPath() {
+	return join(resolveStateDir(), TELEMETRY_FILENAME);
+}
+function readTelemetryConfig() {
+	const configPath = telemetryConfigPath();
+	try {
+		if (!existsSync(configPath)) return { enabled: true };
+		const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+		return {
+			enabled: raw.enabled !== false,
+			noticeShown: raw.noticeShown === true
+		};
+	} catch {
+		return { enabled: true };
+	}
+}
+function writeTelemetryConfig(config) {
+	const configPath = telemetryConfigPath();
+	const merged = {
+		...readTelemetryConfig(),
+		...config
+	};
+	try {
+		mkdirSync(dirname(configPath), { recursive: true });
+		writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+	} catch {}
+}
+function markNoticeShown() {
+	writeTelemetryConfig({ noticeShown: true });
+}
+
+//#endregion
+//#region src/telemetry/telemetry.ts
+var telemetry_exports = /* @__PURE__ */ __exportAll({
+	getAnonymousId: () => getAnonymousId,
+	isTelemetryEnabled: () => isTelemetryEnabled,
+	shutdownTelemetry: () => shutdownTelemetry,
+	track: () => track
+});
+let client = null;
+function isTelemetryEnabled() {
+	return false;
+}
+function getAnonymousId() {
+	try {
+		const raw = `${os.hostname()}:${os.userInfo().username}`;
+		return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+	} catch {
+		return "unknown";
+	}
+}
+function getMachineContext() {
+	return {
+		os: process.platform,
+		arch: process.arch,
+		node_version: process.version
+	};
+}
+function ensureClient() {
+	return null;
+}
+function track(event, properties) {
+	if (!isTelemetryEnabled()) return;
+	if (process.env.DENCHCLAW_TELEMETRY_DEBUG === "1") {
+		process.stderr.write(`[telemetry:debug] ${JSON.stringify({
+			event,
+			properties
+		}, null, 2)}\n`);
+		return;
+	}
+	const ph = ensureClient();
+	if (!ph) return;
+	ph.capture({
+		distinctId: getAnonymousId(),
+		event,
+		properties: {
+			...getMachineContext(),
+			...properties,
+			$process_person_profile: false
+		}
+	});
+}
+async function shutdownTelemetry() {
+	if (client) {
+		await client.shutdown();
+		client = null;
+	}
+}
+
+//#endregion
+export { readTelemetryConfig as a, markNoticeShown as i, telemetry_exports as n, writeTelemetryConfig as o, track as r, isTelemetryEnabled as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "denchclaw",
-  "version": "2.0.1",
+  "version": "2.0.4",
   "description": "AI-powered CRM platform with multi-channel agent gateway, DuckDB workspace, and knowledge management",
   "keywords": [],
   "homepage": "https://github.com/openclaw/openclaw#readme",
@@ -58,6 +58,7 @@
     "commander": "^14.0.3",
     "gradient-string": "^3.0.0",
     "json5": "^2.2.3",
+    "posthog-node": "^5.27.1",
     "tslog": "^4.10.2"
   },
   "devDependencies": {