@latitude-data/openclaw-telemetry-cli 0.0.7

package/dist/cli.js

@@ -0,0 +1,1052 @@
+#!/usr/bin/env node
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { cancel, confirm, intro, isCancel, log, note, outro, password, spinner, text } from "@clack/prompts";
+import pc from "picocolors";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region src/config-dir.ts
+function resolveConfigDir(opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	const home = opts.home ?? homedir();
+	if (typeof opts.flag === "string" && opts.flag.length > 0) return {
+		dir: absolutize(opts.flag, cwd),
+		source: "flag"
+	};
+	const envValue = opts.env !== void 0 ? opts.env : process.env.OPENCLAW_HOME;
+	if (typeof envValue === "string" && envValue.length > 0) return {
+		dir: absolutize(envValue, cwd),
+		source: "env"
+	};
+	if (existsSync(join(cwd, "openclaw.json"))) return {
+		dir: cwd,
+		source: "cwd"
+	};
+	return {
+		dir: join(home, ".openclaw"),
+		source: "default"
+	};
+}
+function absolutize(p, cwd) {
+	return isAbsolute(p) ? p : resolve(cwd, p);
+}
+function pathsFor(configDir) {
+	return {
+		configDir,
+		settingsPath: join(configDir, "openclaw.json"),
+		settingsBackupPath: join(configDir, "openclaw.json.latitude-bak"),
+		installsPath: join(configDir, "plugins", "installs.json")
+	};
+}
+//#endregion
+//#region src/diff.ts
+/**
+* Tiny purpose-built JSON line-diff for `--dry-run` output. Renders changes
+* to `openclaw.json` in a human-readable unified-diff-ish format without
+* pulling in a real diff library (zero new deps).
+*
+* The shape of `openclaw.json` is small (a few hundred lines tops, with
+* stable key ordering after our edits), so the naive line-by-line approach
+* produces a perfectly readable output. We mark added lines with `+ ` and
+* removed lines with `- `, with a few lines of context around each change.
+*/
+const CONTEXT_LINES = 3;
+/**
+* Render a unified-ish diff between two unknown JSON values. Returns an
+* empty string if they're identical after normalization.
+*/
+function jsonDiff(before, after, opts = {}) {
+	const fromLabel = opts.fromLabel ?? "current";
+	const toLabel = opts.toLabel ?? "proposed";
+	const beforeJson = `${JSON.stringify(before ?? {}, null, 2)}\n`;
+	const afterJson = `${JSON.stringify(after ?? {}, null, 2)}\n`;
+	if (beforeJson === afterJson) return "";
+	const ops = lcsDiff(beforeJson.split("\n"), afterJson.split("\n"));
+	const out = [];
+	out.push(`--- ${fromLabel}`);
+	out.push(`+++ ${toLabel}`);
+	let i = 0;
+	while (i < ops.length) {
+		if (ops[i]?.kind === "eq") {
+			i++;
+			continue;
+		}
+		const hunkStart = Math.max(0, i - CONTEXT_LINES);
+		let hunkEnd = i;
+		while (hunkEnd < ops.length) {
+			if (ops[hunkEnd]?.kind === "eq") {
+				let runOfEq = 0;
+				let k = hunkEnd;
+				while (k < ops.length && ops[k]?.kind === "eq" && runOfEq < CONTEXT_LINES * 2) {
+					runOfEq++;
+					k++;
+				}
+				if (k >= ops.length || ops[k]?.kind === "eq") {
+					hunkEnd = Math.min(hunkEnd + CONTEXT_LINES, ops.length);
+					break;
+				}
+				hunkEnd = k;
+				continue;
+			}
+			hunkEnd++;
+		}
+		for (let j = hunkStart; j < hunkEnd && j < ops.length; j++) {
+			const op = ops[j];
+			if (!op) continue;
+			if (op.kind === "eq") out.push(`  ${op.line}`);
+			else if (op.kind === "add") out.push(`+ ${op.line}`);
+			else if (op.kind === "del") out.push(`- ${op.line}`);
+		}
+		i = hunkEnd;
+	}
+	return out.join("\n");
+}
+function lcsDiff(a, b) {
+	const n = a.length;
+	const m = b.length;
+	const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+	for (let i = 1; i <= n; i++) for (let j = 1; j <= m; j++) if (a[i - 1] === b[j - 1]) dp[i][j] = (dp[i - 1]?.[j - 1] ?? 0) + 1;
+	else dp[i][j] = Math.max(dp[i - 1]?.[j] ?? 0, dp[i]?.[j - 1] ?? 0);
+	const ops = [];
+	let i = n;
+	let j = m;
+	while (i > 0 && j > 0) if (a[i - 1] === b[j - 1]) {
+		ops.push({
+			kind: "eq",
+			line: a[i - 1]
+		});
+		i--;
+		j--;
+	} else if ((dp[i - 1]?.[j] ?? 0) >= (dp[i]?.[j - 1] ?? 0)) {
+		ops.push({
+			kind: "del",
+			line: a[i - 1]
+		});
+		i--;
+	} else {
+		ops.push({
+			kind: "add",
+			line: b[j - 1]
+		});
+		j--;
+	}
+	while (i > 0) {
+		ops.push({
+			kind: "del",
+			line: a[i - 1]
+		});
+		i--;
+	}
+	while (j > 0) {
+		ops.push({
+			kind: "add",
+			line: b[j - 1]
+		});
+		j--;
+	}
+	ops.reverse();
+	return ops;
+}
+//#endregion
+//#region src/openclaw-cli.ts
+/**
+* Lowest OpenClaw version we support. The reporter verified hook-dispatch
+* gating works correctly here; older versions either reject
+* `hooks.allowConversationAccess` outright (≤ 2026.4.21) or have unverified
+* gating behaviour (2026.4.22 – 2026.4.24). Refusing to install on older
+* versions is intentional — we'd rather fail loudly than ship a
+* config the gateway will quarantine or hooks the dispatcher will block.
+*/
+const MIN_OPENCLAW_VERSION = "2026.4.25";
+const DEFAULT_TIMEOUT_MS = 1e4;
+/**
+* Spawn `openclaw <args>` synchronously. Reports failure modes structurally so
+* callers can decide how to degrade (missing binary vs. timed out vs. exited
+* non-zero). Never throws; ENOENT becomes `{ reason: "enoent" }`.
+*
+* `opts.env` lets callers overlay environment variables on top of `process.env`
+* — used by the install flow to inject `OPENCLAW_HOME` so `openclaw plugins
+* install`, `openclaw config validate`, and `openclaw gateway restart` all
+* resolve the same config dir as our settings-file edits. The overlay is
+* additive: the caller passes only the keys to override and we merge them on
+* top of `process.env`.
+*/
+function runOpenclaw(args, opts = {}) {
+	const env = opts.env ? {
+		...process.env,
+		...opts.env
+	} : void 0;
+	const result = spawnSync("openclaw", args, {
+		encoding: "utf-8",
+		timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		input: opts.stdin,
+		...env ? { env } : {},
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	const err = result.error;
+	if (err?.code === "ENOENT") return {
+		ok: false,
+		reason: "enoent",
+		stdout: "",
+		stderr: "",
+		code: null
+	};
+	if (err?.code === "ETIMEDOUT" || result.signal === "SIGTERM" || result.signal === "SIGKILL") return {
+		ok: false,
+		reason: "timeout",
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? "",
+		code: null
+	};
+	if (err) return {
+		ok: false,
+		reason: "exit",
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? String(err),
+		code: typeof result.status === "number" ? result.status : 1
+	};
+	if (result.status === 0) return {
+		ok: true,
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? "",
+		code: 0
+	};
+	return {
+		ok: false,
+		reason: "exit",
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? "",
+		code: typeof result.status === "number" ? result.status : 1
+	};
+}
+/**
+* Run `openclaw --version` and parse out the version string.
+*
+* Banner format (per OpenClaw `src/cli/banner.ts` `formatCliBannerLine`):
+*   `🦞 OpenClaw <version> (<commit-sha>)`
+*
+* The banner is normally suppressed when `--version` is the flag, but the
+* version itself still goes to stdout. We accept either layout (with or
+* without the lobster + commit sha) so we don't break if OpenClaw later
+* prints just the bare version string.
+*/
+function getOpenclawVersion() {
+	const result = runOpenclaw(["--version"], { timeoutMs: 5e3 });
+	if (!result.ok) {
+		if (result.reason === "enoent") return {
+			ok: false,
+			error: "missing"
+		};
+		return {
+			ok: false,
+			error: "unparseable",
+			raw: result.stdout || result.stderr
+		};
+	}
+	const raw = result.stdout.trim();
+	const match = raw.match(/(\d{4}\.\d+\.\d+)/);
+	if (!match) return {
+		ok: false,
+		error: "unparseable",
+		raw
+	};
+	return {
+		ok: true,
+		version: match[1],
+		raw
+	};
+}
+/**
+* Compare two CalVer strings (`YYYY.M.PATCH`). Returns -1 if `a` < `b`,
+* 0 if equal, 1 if `a` > `b`. Strings with extra components or non-numeric
+* pieces fall back to a per-component string comparison so unexpected
+* formats don't crash the installer.
+*/
+function compareCalver(a, b) {
+	const ap = a.split(".");
+	const bp = b.split(".");
+	const len = Math.max(ap.length, bp.length);
+	for (let i = 0; i < len; i++) {
+		const ai = ap[i] ?? "0";
+		const bi = bp[i] ?? "0";
+		const an = Number(ai);
+		const bn = Number(bi);
+		if (Number.isFinite(an) && Number.isFinite(bn)) {
+			if (an < bn) return -1;
+			if (an > bn) return 1;
+			continue;
+		}
+		if (ai < bi) return -1;
+		if (ai > bi) return 1;
+	}
+	return 0;
+}
+//#endregion
+//#region src/settings-file.ts
+/** Plugin id used both as the npm package name and as the OpenClaw plugin id. */
+const PLUGIN_ID = "@latitude-data/openclaw-telemetry";
+function readSettings(settingsPath) {
+	if (!existsSync(settingsPath)) return {};
+	try {
+		const raw = readFileSync(settingsPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* Write `openclaw.json` atomically: serialize to a sibling tempfile, then
+* rename over the target. `rename` is atomic on POSIX and effectively atomic
+* on Windows for our case — a crash mid-serialization can no longer leave a
+* truncated `openclaw.json` (combined with `.latitude-bak`, recovery is
+* always possible).
+*
+* Earlier versions used `writeFileSync` directly; that left a corruption
+* window where SIGTERM between `open()` and the final `write()` would leave
+* a partial JSON file the gateway couldn't parse.
+*/
+function writeSettings(settingsPath, settings) {
+	const tmp = `${settingsPath}.tmp.${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+	renameSync(tmp, settingsPath);
+}
+function backupSettings(settingsPath, backupPath) {
+	if (existsSync(settingsPath)) copyFileSync(settingsPath, backupPath);
+}
+/**
+* Restore the backup over the live settings file. Used when a post-write
+* step (e.g. `openclaw config validate --json`) reports the new file is
+* invalid — better to roll back to a known-good state than leave a broken
+* config that'll fail at gateway-restart time.
+*/
+function restoreBackup(settingsPath, backupPath) {
+	if (!existsSync(backupPath)) return false;
+	copyFileSync(backupPath, settingsPath);
+	return true;
+}
+/**
+* Set the `plugins.entries[id]` block for our plugin.
+*
+* Two places in the entry get written:
+*
+*   - `.config` (free-form `record(string, unknown)`): credentials, baseUrl,
+*     and our copy of `allowConversationAccess`. This is what the plugin
+*     runtime reads via `api.pluginConfig`.
+*   - `.hooks.allowConversationAccess`: controls whether OpenClaw's hook
+*     dispatcher actually forwards `llm_input` / `llm_output` / tool /
+*     `agent_end` events to our handlers. Without it set to `true` on
+*     OpenClaw 2026.4.25+, every typed hook is blocked at the dispatcher
+*     and the plugin's handlers never fire.
+*
+* The two flags mean different things — `hooks.*` is the dispatch gate,
+* `config.*` is the payload-content gate — but for THIS plugin we always
+* couple them: dispatch off + payload on is useless (no payloads to gate),
+* and dispatch on + payload off is a legitimate "structural-only telemetry"
+* mode (timing, tokens, ids, agent name; no message bodies). Always writing
+* both from the same source keeps the operator's mental model simple.
+*
+* Re-install idempotency: only `apiKey` / `project` / `baseUrl` always
+* overwrite (these come from install prompts). `enabled`, `debug`, and
+* `allowConversationAccess` are preserved when not provided in the patch.
+*/
+function setPluginEntry(settings, patch) {
+	const plugins = settings.plugins ?? {};
+	const entries = plugins.entries ?? {};
+	const existing = entries["@latitude-data/openclaw-telemetry"] ?? {};
+	const existingConfig = existing.config ?? {};
+	const existingHooks = existing.hooks ?? {};
+	const nextConfig = {
+		...existingConfig,
+		apiKey: patch.apiKey,
+		project: patch.project
+	};
+	if (patch.baseUrl !== void 0) nextConfig.baseUrl = patch.baseUrl;
+	else delete nextConfig.baseUrl;
+	if (patch.allowConversationAccess !== void 0) nextConfig.allowConversationAccess = patch.allowConversationAccess;
+	if (patch.debug !== void 0) nextConfig.debug = patch.debug;
+	const effectiveAccess = typeof nextConfig.allowConversationAccess === "boolean" ? nextConfig.allowConversationAccess : typeof existingHooks.allowConversationAccess === "boolean" ? existingHooks.allowConversationAccess : true;
+	const nextHooks = {
+		...existingHooks,
+		allowConversationAccess: effectiveAccess
+	};
+	const nextEnabled = patch.enabled ?? existing.enabled ?? true;
+	entries[PLUGIN_ID] = {
+		...existing,
+		enabled: nextEnabled,
+		hooks: nextHooks,
+		config: nextConfig
+	};
+	plugins.entries = entries;
+	settings.plugins = plugins;
+}
+/** Remove the plugin entry entirely. Used by uninstall as defense-in-depth. */
+function removePluginEntry(settings) {
+	const plugins = settings.plugins;
+	if (!plugins?.entries) return false;
+	if (!("@latitude-data/openclaw-telemetry" in plugins.entries)) return false;
+	delete plugins.entries[PLUGIN_ID];
+	return true;
+}
+/**
+* Add the plugin id to `plugins.allow`. Idempotent — returns `true` only when
+* the array changed. OpenClaw warns at every gateway start when a non-bundled
+* plugin auto-loads without provenance via `plugins.allow` or an install
+* record. We get one warning cleared by going through `openclaw plugins
+* install` (provenance) and the other by adding ourselves to allow.
+*
+* Defensive against hand-edited non-array values: if `plugins.allow` is
+* present but not an array (e.g. someone wrote a string), we replace it
+* with a single-element array rather than spreading the bad value.
+*/
+function addToPluginsAllow(settings) {
+	const plugins = settings.plugins ?? {};
+	const existing = plugins.allow;
+	const allow = Array.isArray(existing) ? existing : [];
+	if (allow.includes("@latitude-data/openclaw-telemetry")) return false;
+	plugins.allow = [...allow, PLUGIN_ID];
+	settings.plugins = plugins;
+	return true;
+}
+/**
+* Inverse of `addToPluginsAllow`. Defense-in-depth — `openclaw plugins
+* uninstall` already strips the entry, but the install path can be skipped
+* (e.g. the user removed the plugin manually) and we want re-install/uninstall
+* round-trips to be tidy regardless.
+*/
+function removeFromPluginsAllow(settings) {
+	const allow = settings.plugins?.allow;
+	if (!Array.isArray(allow) || !allow.includes("@latitude-data/openclaw-telemetry")) return false;
+	if (settings.plugins) settings.plugins.allow = allow.filter((id) => id !== PLUGIN_ID);
+	return true;
+}
+function hasLatitudePlugin(settings) {
+	return Boolean(settings.plugins?.entries && "@latitude-data/openclaw-telemetry" in settings.plugins.entries);
+}
+/**
+* Strip leftover keys from older installers that the strict zod schema
+* rejects on current OpenClaw versions.
+*
+* 0.0.1 wrote `LATITUDE_*` keys directly under `settings.env`. OpenClaw's
+* root schema is strict; the `env` block accepts only `{shellEnv, vars}`,
+* so those keys cause the gateway to quarantine the config as
+* `clobbered.<ts>` and roll back. We sweep them on every install.
+*
+* Note: 0.0.1 also wrote `hooks.allowConversationAccess` (when that key was
+* not yet in the schema). We deliberately do NOT strip it anymore — on
+* OpenClaw 2026.4.25+ the key IS in the schema and IS load-bearing for
+* dispatch. `setPluginEntry` overwrites it on every install with the right
+* value, so any 0.0.1 leftover is reconciled there.
+*/
+function migrateLegacyEntries(settings) {
+	let changed = false;
+	const env = settings.env;
+	if (env && typeof env === "object" && !Array.isArray(env)) {
+		const envObj = env;
+		for (const key of [
+			"LATITUDE_API_KEY",
+			"LATITUDE_PROJECT",
+			"LATITUDE_BASE_URL"
+		]) if (key in envObj) {
+			delete envObj[key];
+			changed = true;
+		}
+		if (Object.keys(envObj).length === 0) delete settings.env;
+	}
+	return { changed };
+}
+/**
+* Read OpenClaw's plugins install record (`<configDir>/plugins/installs.json`)
+* and return the version recorded for our plugin id, if any. Used by the
+* install flow to render `Upgrading 0.0.6 → 0.0.7` UX.
+*
+* Best-effort: returns undefined on any read/parse error, on missing file,
+* on schemas we don't recognize. Callers must handle the undefined case
+* (typically by rendering a "fresh install" path).
+*/
+function readInstalledRuntimeVersion(installsPath) {
+	if (!existsSync(installsPath)) return void 0;
+	try {
+		const raw = readFileSync(installsPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+		const entries = parsed.entries;
+		if (!entries || typeof entries !== "object") return void 0;
+		const ours = entries[PLUGIN_ID];
+		if (!ours || typeof ours !== "object") return void 0;
+		const version = ours.version;
+		return typeof version === "string" ? version : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/version.ts
+/**
+* Read this CLI's own version from its `package.json`. Used by:
+*   - `cli.ts` for `--version`
+*   - `setup.ts` in the npm-registry-404 abort message, so the upgrade
+*     instruction shows the version the user is actually running. Earlier
+*     versions read `process.env.npm_package_version`, but that env var
+*     is only set by `npm run` — not by `npx`, not by globally-installed
+*     bins. The vast majority of `latitude-openclaw` invocations come
+*     through one of those, so the env-var approach printed
+*     `(this version)` instead of the real version every time.
+*/
+function readCliVersion() {
+	const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+	try {
+		return JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+//#endregion
+//#region src/setup.ts
+/**
+* The runtime version this CLI installs. Lockstep with the runtime — bump
+* both packages in the same commit. The CLI's npm-spec install is pinned to
+* this exact version (not a floating tag), so we never accidentally install
+* a runtime that doesn't match the contract this CLI was built against.
+*
+* Pinning also satisfies OpenClaw's `Pin install specs to exact versions`
+* supply-chain audit warning automatically.
+*/
+const RUNTIME_PACKAGE_NAME = "@latitude-data/openclaw-telemetry";
+const RUNTIME_VERSION = "0.0.7";
+const DOCS_URL = "https://docs.latitude.so/openclaw-telemetry";
+const PRODUCTION_ENV = {
+	name: "production",
+	label: "production",
+	app: "https://console.latitude.so",
+	ingest: "https://ingest.latitude.so"
+};
+const STAGING_ENV = {
+	name: "staging",
+	label: "staging",
+	app: "https://staging.latitude.so",
+	ingest: "https://staging-ingest.latitude.so"
+};
+const DEV_ENV = {
+	name: "dev",
+	label: "local dev",
+	app: "http://localhost:3000",
+	ingest: "http://localhost:3002"
+};
+function urlsFor(env) {
+	return {
+		apiKeys: `${env.app}/settings/api-keys`,
+		projects: env.app,
+		projectView: (slug) => `${env.app}/projects/${slug}`
+	};
+}
+/**
+* Flags that take a value (either `--key=value` or `--key value`). Bare
+* `--key` is reserved for booleans and shouldn't consume the next argv
+* token as its value — operators expect `--no-content` next to `--yes`
+* to mean two booleans, not "no-content takes the value `--yes`".
+*/
+const VALUE_FLAGS = new Set([
+	"api-key",
+	"project",
+	"openclaw-dir"
+]);
+function parseFlags(argv) {
+	const [subcommand, ...rest] = argv;
+	const flags = {};
+	for (let i = 0; i < rest.length; i++) {
+		const arg = rest[i];
+		if (!arg || !arg.startsWith("--")) continue;
+		const eq = arg.indexOf("=");
+		if (eq >= 0) {
+			flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+			continue;
+		}
+		const key = arg.slice(2);
+		const next = rest[i + 1];
+		if (VALUE_FLAGS.has(key) && next !== void 0 && !next.startsWith("--")) {
+			flags[key] = next;
+			i += 1;
+		} else flags[key] = true;
+	}
+	return {
+		subcommand,
+		flags
+	};
+}
+function normalizeInstallFlags(flags) {
+	let environment;
+	if (flags.staging === true) environment = STAGING_ENV;
+	if (flags.dev === true) {
+		if (environment) throw new Error("--staging and --dev are mutually exclusive");
+		environment = DEV_ENV;
+	}
+	let allowConversationAccess;
+	if (flags["no-content"] === true || flags["no-conversation"] === true) allowConversationAccess = false;
+	if (flags["allow-conversation"] === true) allowConversationAccess = true;
+	let restart = "auto";
+	if (flags["no-restart"] === true) restart = "never";
+	if (flags.restart === true) {
+		if (flags["no-restart"] === true) throw new Error("--restart and --no-restart are mutually exclusive");
+		restart = "force";
+	}
+	return {
+		apiKey: typeof flags["api-key"] === "string" ? flags["api-key"] : void 0,
+		project: typeof flags.project === "string" ? flags.project : void 0,
+		environment,
+		allowConversationAccess,
+		noTrust: flags["no-trust"] === true,
+		openclawDir: typeof flags["openclaw-dir"] === "string" ? flags["openclaw-dir"] : void 0,
+		dryRun: flags["dry-run"] === true,
+		restart,
+		noPrompt: flags["no-prompt"] === true || flags.yes === true,
+		yes: flags.yes === true
+	};
+}
+async function runInstall(flags = {}) {
+	if (!(!flags.noPrompt && process.stdin.isTTY === true)) return runFlagDrivenInstall(flags);
+	await runInteractiveInstall(flags);
+}
+function resolvePaths(flags) {
+	const resolved = resolveConfigDir({ flag: flags.openclawDir });
+	return {
+		resolved,
+		paths: pathsFor(resolved.dir)
+	};
+}
+function envForSubprocess(paths) {
+	return { OPENCLAW_HOME: paths.configDir };
+}
+async function runInteractiveInstall(flags) {
+	intro(pc.bgCyan(pc.black(" Latitude · OpenClaw telemetry ")));
+	ensureOpenclawIsCompatible();
+	const { resolved, paths } = resolvePaths(flags);
+	log.info(`Using config dir: ${pc.dim(paths.configDir)} ${pc.dim(`(source: ${resolved.source})`)}`);
+	await ensureRuntimeOnNpm();
+	const installedVersion = readInstalledRuntimeVersion(paths.installsPath);
+	if (installedVersion !== void 0) if (installedVersion === RUNTIME_VERSION) log.info(`${PLUGIN_ID} ${pc.dim(installedVersion)} already installed — re-applying (idempotent).`);
+	else log.info(`Upgrading ${PLUGIN_ID} from ${pc.dim(installedVersion)} → ${pc.cyan(RUNTIME_VERSION)}`);
+	const existingConfig = readSettings(paths.settingsPath).plugins?.entries?.["@latitude-data/openclaw-telemetry"]?.config ?? void 0;
+	const envConfig = flags.environment ?? PRODUCTION_ENV;
+	const urls = urlsFor(envConfig);
+	const aboutLines = [
+		"Captures every OpenClaw agent run and ships it to Latitude as",
+		"OpenTelemetry traces — full system prompt, tool I/O, messages,",
+		"token usage, and agent name on every span.",
+		"",
+		`${pc.dim("Docs")}   ${pc.cyan(DOCS_URL)}`
+	];
+	if (envConfig.name !== "production") aboutLines.push("", pc.yellow(`Using ${envConfig.label} environment (${envConfig.ingest})`));
+	note(aboutLines.join("\n"), "About");
+	log.info(`Get an API key at ${pc.cyan(urls.apiKeys)}`);
+	log.info(`Create a project at ${pc.cyan(urls.projects)}`);
+	const apiKey = await promptApiKey(existingConfig?.apiKey, flags.apiKey);
+	const project = await promptProject(existingConfig?.project, flags.project);
+	await applyChanges({
+		apiKey,
+		project,
+		envConfig,
+		allowConversationAccess: flags.allowConversationAccess,
+		noTrust: flags.noTrust === true,
+		paths,
+		dryRun: flags.dryRun === true
+	});
+	if (!flags.dryRun) await maybeRestartGateway(flags.restart ?? "auto", paths);
+	note([flags.dryRun ? "Dry-run only — nothing was written." : "Plugin installed and configured.", `View your traces at  ${pc.cyan(urls.projectView(project))}`].join("\n"), "Next step");
+	outro(flags.dryRun ? pc.dim("(dry-run)") : pc.green("✓ Installed"));
+}
+async function runFlagDrivenInstall(flags) {
+	ensureOpenclawIsCompatible();
+	const { resolved, paths } = resolvePaths(flags);
+	process.stdout.write(`Using config dir: ${paths.configDir} (source: ${resolved.source})\n`);
+	await ensureRuntimeOnNpm();
+	const apiKey = flags.apiKey;
+	const project = flags.project;
+	if (!apiKey || !project) throw new Error("Non-interactive install requires --api-key=... and --project=... (or run in a TTY).");
+	await applyChanges({
+		apiKey,
+		project,
+		envConfig: flags.environment ?? PRODUCTION_ENV,
+		allowConversationAccess: flags.allowConversationAccess,
+		noTrust: flags.noTrust === true,
+		paths,
+		dryRun: flags.dryRun === true
+	});
+	if (flags.dryRun) {
+		process.stdout.write("Dry-run only — nothing was written.\n");
+		return;
+	}
+	await maybeRestartGateway(flags.restart ?? "auto", paths);
+	process.stdout.write(`Installed Latitude plugin in ${paths.settingsPath}\n`);
+}
+async function promptApiKey(_existing, flag) {
+	if (flag) return flag;
+	const result = await password({
+		message: "Latitude API key",
+		mask: "•",
+		validate: (v) => v && v.length > 0 ? void 0 : "Required"
+	});
+	if (isCancel(result)) return onCancel();
+	return result;
+}
+async function promptProject(existing, flag) {
+	if (flag) return flag;
+	const result = await text({
+		message: "Latitude project slug",
+		placeholder: existing ?? "my-openclaw-project",
+		...existing ? { initialValue: existing } : {},
+		validate: (v) => v && v.length > 0 ? void 0 : "Required"
+	});
+	if (isCancel(result)) return onCancel();
+	return result;
+}
+function onCancel() {
+	cancel("Cancelled — nothing was changed");
+	process.exit(1);
+}
+async function applyChanges({ apiKey, project, envConfig, allowConversationAccess, noTrust, paths, dryRun }) {
+	const installSpec = `${RUNTIME_PACKAGE_NAME}@${RUNTIME_VERSION}`;
+	const before = readSettings(paths.settingsPath);
+	const after = structuredClone(before);
+	migrateLegacyEntries(after);
+	setPluginEntry(after, {
+		apiKey,
+		project,
+		baseUrl: envConfig.name === "production" ? void 0 : envConfig.ingest,
+		allowConversationAccess
+	});
+	if (!noTrust) addToPluginsAllow(after);
+	if (dryRun) {
+		log.info(`Would run: ${pc.dim(`openclaw plugins install ${installSpec} --force`)}`);
+		const diff = jsonDiff(before, after, {
+			fromLabel: paths.settingsPath,
+			toLabel: `${paths.settingsPath} (proposed)`
+		});
+		if (diff.length > 0) process.stdout.write(`${diff}\n`);
+		else log.info(`No openclaw.json changes — current config already matches.`);
+		return;
+	}
+	ensureSettingsDir(paths);
+	backupSettings(paths.settingsPath, paths.settingsBackupPath);
+	const installSpinner = spinner();
+	installSpinner.start(`Installing plugin via openclaw plugins install ${installSpec}`);
+	const installResult = runOpenclaw([
+		"plugins",
+		"install",
+		installSpec,
+		"--force"
+	], {
+		timeoutMs: 6e4,
+		env: envForSubprocess(paths)
+	});
+	if (!installResult.ok) {
+		installSpinner.stop("openclaw plugins install failed");
+		if (installResult.reason === "enoent") throw new Error("`openclaw` not found on PATH. Install OpenClaw first (https://openclaw.ai/install) and re-run.");
+		if (installResult.reason === "timeout") throw new Error("openclaw plugins install timed out after 60s. Try running it manually to see what's stuck.");
+		const detail = installResult.stderr.trim() || installResult.stdout.trim() || `exit code ${installResult.code}`;
+		throw new Error(`openclaw plugins install failed: ${detail}`);
+	}
+	installSpinner.stop("Plugin registered with OpenClaw");
+	const postInstallSnapshot = readSettings(paths.settingsPath);
+	const settingsSpinner = spinner();
+	settingsSpinner.start("Updating openclaw.json");
+	const settings = readSettings(paths.settingsPath);
+	migrateLegacyEntries(settings);
+	setPluginEntry(settings, {
+		apiKey,
+		project,
+		baseUrl: envConfig.name === "production" ? void 0 : envConfig.ingest,
+		allowConversationAccess
+	});
+	if (!noTrust) addToPluginsAllow(settings);
+	writeSettings(paths.settingsPath, settings);
+	settingsSpinner.stop(`Updated ${paths.settingsPath}`);
+	if (existsSync(paths.settingsBackupPath)) log.info(`Backup saved at ${pc.dim(paths.settingsBackupPath)}`);
+	if (noTrust) log.warning(`--no-trust set; OpenClaw will warn at every gateway start that ${PLUGIN_ID} is untrusted. Add it to plugins.allow yourself when you're ready.`);
+	const validateSpinner = spinner();
+	validateSpinner.start("Validating openclaw.json");
+	const validateResult = runOpenclaw([
+		"config",
+		"validate",
+		"--json"
+	], {
+		timeoutMs: 1e4,
+		env: envForSubprocess(paths)
+	});
+	if (!validateResult.ok || isInvalidConfigPayload(validateResult.stdout)) {
+		validateSpinner.stop("openclaw config validate failed");
+		const rollback = rollbackSettings(paths, postInstallSnapshot);
+		const detail = validateResult.ok === false ? validateResult.stderr.trim() || validateResult.stdout.trim() || `exit code ${validateResult.code}` : validateResult.stdout.trim() || "config validate reported invalid config";
+		throw new Error(`openclaw config validate reported a problem after our changes:\n  ${detail}\n${rollback}`);
+	}
+	validateSpinner.stop("Config valid");
+}
+/**
+* Two-tier rollback for validation failures:
+*
+*   1. If `.latitude-bak` exists (typical case — operator had openclaw.json
+*      before this flow), restore from it. That's the user's true
+*      pre-install state.
+*   2. If `.latitude-bak` doesn't exist (fresh install — no openclaw.json
+*      pre-flow, so `backupSettings` no-op'd), write `postInstallSnapshot`
+*      back. That's the state immediately after `openclaw plugins install`
+*      and before any of our config layering — schema-valid, just a
+*      disabled plugin entry. Operator can re-run install or run
+*      `openclaw plugins uninstall` to fully revert OpenClaw's bookkeeping.
+*
+* Returns the human-readable recovery line to append to the thrown error.
+*/
+function rollbackSettings(paths, postInstallSnapshot) {
+	if (existsSync(paths.settingsBackupPath)) return restoreBackup(paths.settingsPath, paths.settingsBackupPath) ? `Backup restored from ${paths.settingsBackupPath} — your config is back to the pre-install state.` : `Backup at ${paths.settingsBackupPath} could not be restored automatically; restore it manually.`;
+	try {
+		writeSettings(paths.settingsPath, postInstallSnapshot);
+		return `${paths.settingsPath} rolled back to the post-\`openclaw plugins install\` state (plugin entry exists but disabled). Run \`openclaw plugins uninstall ${PLUGIN_ID} --force\` to fully revert if you don't intend to retry.`;
+	} catch (err) {
+		return `Couldn't roll back ${paths.settingsPath} (${String(err)}). Run \`openclaw plugins uninstall ${PLUGIN_ID} --force\` and inspect the file manually.`;
+	}
+}
+/** Best-effort detection of `{"valid": false, ...}` in the validate output. */
+function isInvalidConfigPayload(stdout) {
+	const trimmed = stdout.trim();
+	if (!trimmed) return false;
+	try {
+		return JSON.parse(trimmed).valid === false;
+	} catch {
+		return false;
+	}
+}
+function ensureSettingsDir(paths) {
+	const dir = dirname(paths.settingsPath);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+/**
+* Verify `openclaw` is on PATH AND its version is >= MIN_OPENCLAW_VERSION.
+* Aborts with a clear upgrade message otherwise. Called before any user
+* prompts so we don't waste their time collecting credentials we can't
+* use.
+*/
+function ensureOpenclawIsCompatible() {
+	const v = getOpenclawVersion();
+	if (!v.ok) {
+		if (v.error === "missing") {
+			cancel("OpenClaw CLI not found on PATH. Install or update via `npm install -g openclaw@latest` and re-run.");
+			process.exit(1);
+		}
+		cancel(`Couldn't parse OpenClaw version output${v.raw ? ` (got: ${pc.dim(v.raw)})` : ""}. Run \`openclaw --version\` and report the output.`);
+		process.exit(1);
+	}
+	if (compareCalver(v.version, "2026.4.25") < 0) {
+		cancel(`OpenClaw ${v.version} is older than the minimum supported version (${MIN_OPENCLAW_VERSION}). Run \`npm install -g openclaw@latest\` and re-run install.`);
+		process.exit(1);
+	}
+	log.info(`OpenClaw ${pc.dim(v.version)} (>= ${MIN_OPENCLAW_VERSION})`);
+}
+/**
+* Lockstep contract check. The CLI installs a pinned `RUNTIME_VERSION`; if
+* that version isn't published yet (half-released release pipeline), abort
+* with a clear upgrade path so the operator's gateway doesn't end up with a
+* runtime that doesn't match this CLI's expectations.
+*
+* Best-effort — uses the npm registry's HTTP API rather than spawning
+* `npm view` so we don't require npm to be on PATH. Network failure
+* (offline) → warn-and-continue; the install spawn would fail visibly
+* anyway if the package wasn't there.
+*/
+async function ensureRuntimeOnNpm() {
+	const url = `https://registry.npmjs.org/${encodeURIComponent(RUNTIME_PACKAGE_NAME)}/${encodeURIComponent(RUNTIME_VERSION)}`;
+	try {
+		const res = await fetch(url, {
+			method: "GET",
+			signal: AbortSignal.timeout(5e3)
+		});
+		if (res.status === 404) {
+			cancel(`CLI ${readCliVersion()} expects ${RUNTIME_PACKAGE_NAME}@${RUNTIME_VERSION} but npm doesn't have that exact version. Upgrade the CLI: npm install -g @latitude-data/openclaw-telemetry-cli@latest`);
+			process.exit(1);
+		}
+		if (!res.ok) log.warning(`npm registry check returned HTTP ${res.status}; continuing.`);
+	} catch (err) {
+		log.warning(`Couldn't reach npm registry to verify ${RUNTIME_PACKAGE_NAME}@${RUNTIME_VERSION}: ${String(err)}`);
+	}
+}
+/**
+* Restart the OpenClaw gateway, prompting on TTY by default. The behaviour
+* is governed by `flags.restart`:
+*
+*   - `"force"` (--restart): always restart, even non-TTY. CI escape hatch.
+*   - `"never"` (--no-restart): never restart, even on TTY.
+*   - `"auto"` (default): prompt on TTY ("Restart now? [Y/n]"); skip
+*     non-TTY (and print the manual command). Hybrid that keeps interactive
+*     UX safe while CI defaults to leaving the operator in control.
+*/
+async function maybeRestartGateway(mode, paths) {
+	if (mode === "never") {
+		log.info(`Skipping gateway restart (--no-restart). Run \`openclaw gateway restart\` when ready.`);
+		return;
+	}
+	let shouldRestart;
+	if (mode === "force") shouldRestart = true;
+	else {
+		if (process.stdin.isTTY !== true) {
+			log.info(`Run \`openclaw gateway restart\` to load the plugin.`);
+			return;
+		}
+		const confirmed = await confirm({
+			message: "Restart the OpenClaw gateway now to load the plugin?",
+			initialValue: true
+		});
+		if (isCancel(confirmed) || confirmed !== true) {
+			log.info(`Run \`openclaw gateway restart\` when ready.`);
+			return;
+		}
+		shouldRestart = true;
+	}
+	if (!shouldRestart) return;
+	log.warning("Restarting gateway. In-flight runs may be interrupted.");
+	const restartSpinner = spinner();
+	restartSpinner.start("openclaw gateway restart");
+	const restartResult = runOpenclaw(["gateway", "restart"], {
+		timeoutMs: 6e4,
+		env: envForSubprocess(paths)
+	});
+	if (!restartResult.ok) {
+		restartSpinner.stop("Gateway restart failed");
+		const detail = restartResult.stderr.trim() || restartResult.stdout.trim() || `exit code ${restartResult.code}`;
+		log.warning(`openclaw gateway restart failed: ${detail}. Restart it yourself when ready.`);
+		return;
+	}
+	restartSpinner.stop("Gateway restarted");
+}
+function normalizeUninstallFlags(flags) {
+	let restart = "auto";
+	if (flags["no-restart"] === true) restart = "never";
+	if (flags.restart === true) {
+		if (flags["no-restart"] === true) throw new Error("--restart and --no-restart are mutually exclusive");
+		restart = "force";
+	}
+	return {
+		noPrompt: flags["no-prompt"] === true || flags.yes === true,
+		openclawDir: typeof flags["openclaw-dir"] === "string" ? flags["openclaw-dir"] : void 0,
+		restart
+	};
+}
+async function runUninstall(flags = {}) {
+	intro(pc.bgYellow(pc.black(" Latitude · OpenClaw telemetry — uninstall ")));
+	const resolved = resolveConfigDir({ flag: flags.openclawDir });
+	const paths = pathsFor(resolved.dir);
+	log.info(`Using config dir: ${pc.dim(paths.configDir)} ${pc.dim(`(source: ${resolved.source})`)}`);
+	if (!hasLatitudePlugin(readSettings(paths.settingsPath))) {
+		note("No Latitude plugin entry found — nothing to remove.", "Status");
+		outro(pc.dim("Nothing changed"));
+		return;
+	}
+	note([
+		`Run \`openclaw plugins uninstall ${PLUGIN_ID} --force\` (removes files, install record, and plugin entry)`,
+		`Sweep any leftover LATITUDE_* keys from settings.env`,
+		`Backup of openclaw.json saved at ${paths.settingsBackupPath}`
+	].join("\n"), "Plan");
+	if (!flags.noPrompt) {
+		if (process.stdin.isTTY !== true) throw new Error("Non-interactive uninstall requires --yes / --no-prompt to confirm. Re-run with --yes to bypass the prompt explicitly.");
+		const ok = await confirm({
+			message: "Proceed?",
+			initialValue: true
+		});
+		if (isCancel(ok) || ok !== true) return onCancel();
+	}
+	backupSettings(paths.settingsPath, paths.settingsBackupPath);
+	const s = spinner();
+	s.start("Reverting via openclaw plugins uninstall");
+	const uninstallResult = runOpenclaw([
+		"plugins",
+		"uninstall",
+		PLUGIN_ID,
+		"--force"
+	], {
+		timeoutMs: 6e4,
+		env: envForSubprocess(paths)
+	});
+	if (!uninstallResult.ok) {
+		s.stop("openclaw plugins uninstall failed");
+		if (uninstallResult.reason === "enoent") log.warning("`openclaw` not found on PATH. Falling back to local cleanup — files at <configDir>/extensions/ may remain.");
+		else {
+			const detail = uninstallResult.stderr.trim() || uninstallResult.stdout.trim() || `exit code ${uninstallResult.code}`;
+			log.warning(`openclaw plugins uninstall reported: ${detail}. Continuing with local cleanup.`);
+		}
+	} else s.stop("Plugin removed by OpenClaw");
+	const cleanupSpinner = spinner();
+	cleanupSpinner.start("Reverting openclaw.json");
+	const post = readSettings(paths.settingsPath);
+	removePluginEntry(post);
+	removeFromPluginsAllow(post);
+	migrateLegacyEntries(post);
+	writeSettings(paths.settingsPath, post);
+	cleanupSpinner.stop("Done");
+	await maybeRestartGateway(flags.restart ?? "auto", paths);
+	outro(pc.green("✓ Uninstalled"));
+}
+//#endregion
+//#region src/cli.ts
+const USAGE = `usage: latitude-openclaw <command> [options]
+
+commands:
+  install               Install the plugin (interactive when stdin is a TTY)
+  uninstall             Remove the plugin entry and files
+  --version, -v         Print the package version
+  --help, -h            Print this message
+
+install options:
+  --api-key=<key>       Pass the API key non-interactively
+  --project=<slug>      Pass the project slug non-interactively
+  --staging             Target https://staging.latitude.so / staging-ingest
+  --dev                 Target http://localhost:3000 / 3002
+  --no-content          Skip raw prompt/response/tool I/O capture
+  --allow-conversation  Force conversation capture on (overrides existing config)
+  --no-trust            Skip adding plugin id to plugins.allow
+  --openclaw-dir=<path> Override OpenClaw config dir (default: $OPENCLAW_HOME, ./openclaw.json,
+                        or ~/.openclaw — see resolution order in README)
+  --dry-run             Show the diff against current openclaw.json and exit (no writes)
+  --restart             Always restart the gateway, even non-TTY
+  --no-restart          Never restart the gateway, even on TTY
+  --yes / --no-prompt   Skip all prompts (required for non-TTY / CI)
+
+uninstall options:
+  --openclaw-dir=<path> Override OpenClaw config dir (same precedence as install)
+  --restart             Always restart the gateway, even non-TTY
+  --no-restart          Never restart the gateway, even on TTY
+  --yes / --no-prompt   Skip the confirmation prompt
+`;
+async function main() {
+	const argv = process.argv.slice(2);
+	if (argv[0] === "--version" || argv[0] === "-v") {
+		process.stdout.write(`${readCliVersion()}\n`);
+		return;
+	}
+	if (argv[0] === "--help" || argv[0] === "-h") {
+		process.stdout.write(USAGE);
+		return;
+	}
+	const { subcommand, flags } = parseFlags(argv);
+	if (subcommand === "install" || subcommand === void 0) {
+		await runInstall(normalizeInstallFlags(flags));
+		return;
+	}
+	if (subcommand === "uninstall") {
+		await runUninstall(normalizeUninstallFlags(flags));
+		return;
+	}
+	process.stderr.write(`unknown subcommand: ${subcommand}\n`);
+	process.stderr.write(USAGE);
+	process.exit(1);
+}
+main().catch((err) => {
+	process.stderr.write(`${String(err)}\n`);
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map