sim 2.1.13 → 2.1.14-preview.117.1

package/dist/index.js

@@ -6946,35 +6946,588 @@ var {
   safeDump
 } = yaml;
 
+// src/update/install.ts
+import { spawn as spawn2 } from "node:child_process";
+import { readFileSync as readFileSync2, realpathSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../utils/src/errors.ts
+function getErrorMessage(value, fallback) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  return fallback ?? String(value);
+}
+
+// ../utils/src/object.ts
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+
+// src/update/install.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+
+// src/update/check.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// src/config/json-file.ts
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname } from "node:path";
+var writeSequence = 0;
+function readJsonFile(path, maxBytes) {
+  let descriptor = null;
+  try {
+    if (!lstatSync(path).isFile())
+      return null;
+    descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+    const stats = fstatSync(descriptor);
+    if (!stats.isFile() || stats.size > maxBytes)
+      return null;
+    const buffer = Buffer.allocUnsafe(maxBytes + 1);
+    let bytesRead = 0;
+    while (bytesRead < buffer.byteLength) {
+      const count = readSync(descriptor, buffer, bytesRead, buffer.byteLength - bytesRead, bytesRead);
+      if (count === 0)
+        break;
+      bytesRead += count;
+    }
+    if (bytesRead > maxBytes)
+      return null;
+    return JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+  } catch {
+    return null;
+  } finally {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {}
+    }
+  }
+}
+function writeJsonFile(path, value, mode = 420) {
+  let descriptor = null;
+  let temporaryCreated = false;
+  const temporaryPath = `${path}.${process.pid}.${Date.now()}.${writeSequence++}.tmp`;
+  try {
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    descriptor = openSync(temporaryPath, "wx", mode);
+    temporaryCreated = true;
+    writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}
+`);
+    closeSync(descriptor);
+    descriptor = null;
+    renameSync(temporaryPath, path);
+    temporaryCreated = false;
+  } catch {} finally {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {}
+    }
+    if (temporaryCreated) {
+      try {
+        unlinkSync(temporaryPath);
+      } catch {}
+    }
+  }
+}
+
 // src/config/paths.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
 function configDir() {
   return process.env.SIM_CONFIG_DIR || join(homedir(), ".sim");
 }
-function configPath() {
-  return process.env.SIM_CONFIG_FILE || join(configDir(), "config");
+function configPath() {
+  return process.env.SIM_CONFIG_FILE || join(configDir(), "config");
+}
+function credentialsPath() {
+  return process.env.SIM_CREDENTIALS_FILE || join(configDir(), "credentials");
+}
+function updateCachePath() {
+  return join(configDir(), "update-check.json");
+}
+function telemetryStatePath() {
+  return join(configDir(), "telemetry.json");
+}
+
+// src/environment.ts
+var CI_VARIABLES = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "JENKINS_URL",
+  "TEAMCITY_VERSION",
+  "BUILDKITE"
+];
+function isEnabled(value) {
+  if (value === undefined)
+    return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+function isCi(env = process.env) {
+  return CI_VARIABLES.some((variable) => isEnabled(env[variable]));
+}
+function proxyExecArgv() {
+  return process.execArgv.filter((argument) => argument === "--use-env-proxy" || argument === "--no-use-env-proxy");
+}
+function childProcessEnv(strip, extra = {}) {
+  const env = { ...process.env };
+  const stripped = new Set(strip.map((name) => name.toLowerCase()));
+  for (const key of Object.keys(env)) {
+    if (stripped.has(key.toLowerCase()))
+      delete env[key];
+  }
+  return { ...env, ...extra };
+}
+
+// src/version.ts
+import { readFileSync } from "node:fs";
+function readPackageVersion() {
+  const metadata = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
+    throw new Error("CLI package metadata is missing a valid version");
+  }
+  return metadata.version;
+}
+var CLI_VERSION = readPackageVersion();
+var USER_AGENT = `sim-cli/${CLI_VERSION} node/${process.versions.node} (${process.platform}; ${process.arch})`;
+
+// src/update/check.ts
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+var REGISTRY_TIMEOUT_MS = 1000;
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var PACKAGE_NAME = "sim";
+var DIST_TAGS_PATH = `-/package/${PACKAGE_NAME}/dist-tags`;
+var MAX_RESPONSE_BYTES = 64 * 1024;
+var MAX_CACHE_BYTES = 4 * 1024;
+var STABLE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseStableVersion(version) {
+  const match = STABLE_VERSION_PATTERN.exec(version);
+  if (!match)
+    return null;
+  const parsed = [Number(match[1]), Number(match[2]), Number(match[3])];
+  return parsed.every(Number.isSafeInteger) ? parsed : null;
+}
+function isNewerVersion(candidate, current) {
+  if (candidate[0] !== current[0])
+    return candidate[0] > current[0];
+  if (candidate[1] !== current[1])
+    return candidate[1] > current[1];
+  return candidate[2] > current[2];
+}
+var CACHE_VERSION = 1;
+function isProjectLocalInstall(modulePath, cwd) {
+  const normalizedModulePath = normalizeModulePath(modulePath);
+  const nodeModulesIndex = normalizedModulePath.indexOf("/node_modules/");
+  if (nodeModulesIndex < 0)
+    return false;
+  const installRoot = normalizedModulePath.slice(0, nodeModulesIndex);
+  const workingDirectory = normalizeModulePath(cwd).replace(/\/+$/, "");
+  return workingDirectory === installRoot || workingDirectory.startsWith(`${installRoot}/`);
+}
+function isUnadvisableInstall(modulePath, env, cwd) {
+  const normalized = normalizeModulePath(modulePath);
+  return env.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/packages/sim-cli/") || isProjectLocalInstall(modulePath, cwd);
+}
+function normalizeModulePath(modulePath) {
+  return modulePath.replace(/\\/g, "/").toLowerCase();
+}
+function registryUrl(env) {
+  const fallback = new URL(DIST_TAGS_PATH, DEFAULT_REGISTRY);
+  const configured = env.npm_config_registry?.trim();
+  if (!configured)
+    return fallback;
+  try {
+    const base = new URL(configured);
+    if (base.protocol !== "http:" && base.protocol !== "https:")
+      return null;
+    if (base.username || base.password)
+      return null;
+    base.pathname = `${base.pathname.replace(/\/$/, "")}/${DIST_TAGS_PATH}`;
+    return base;
+  } catch {
+    return null;
+  }
+}
+var REGISTRY_REQUEST_SCRIPT = `
+let input = ''
+process.stdin.setEncoding('utf8')
+for await (const chunk of process.stdin) input += chunk
+
+try {
+  const { url, headers, maxResponseBytes, timeoutMs } = JSON.parse(input)
+  const deadline = setTimeout(() => process.exit(1), timeoutMs)
+  const response = await fetch(url, { headers, redirect: 'error' })
+  const declared = Number(response.headers.get('content-length'))
+
+  if (!response.ok || !response.body || (Number.isFinite(declared) && declared > maxResponseBytes)) {
+    process.exit(1)
+  }
+
+  const reader = response.body.getReader()
+  const chunks = []
+  let seen = 0
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    seen += value.byteLength
+    if (seen > maxResponseBytes) {
+      process.exit(1)
+    }
+    chunks.push(Buffer.from(value))
+  }
+
+  clearTimeout(deadline)
+  process.stdout.write(Buffer.concat(chunks), () => process.exit(0))
+} catch {
+  process.exit(1)
+}
+`;
+function requestRegistry(url, { headers, maxResponseBytes, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [...proxyExecArgv(), "--input-type=module", "--eval", REGISTRY_REQUEST_SCRIPT], {
+      env: childProcessEnv(["npm_config_registry", "sim_api_key"]),
+      killSignal: "SIGKILL",
+      stdio: ["pipe", "pipe", "ignore"],
+      timeout: timeoutMs,
+      windowsHide: true
+    });
+    const chunks = [];
+    let failed = false;
+    let seen = 0;
+    child.stdout.on("data", (chunk) => {
+      seen += chunk.byteLength;
+      if (seen > maxResponseBytes) {
+        failed = true;
+        child.kill("SIGKILL");
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stdout.on("error", () => {
+      failed = true;
+      child.kill("SIGKILL");
+    });
+    child.stdin.on("error", () => {});
+    child.once("error", reject);
+    child.once("close", (code) => {
+      resolve(code === 0 && !failed ? Buffer.concat(chunks).toString("utf8") : null);
+    });
+    child.stdin.end(JSON.stringify({ headers, maxResponseBytes, timeoutMs, url: url.href }));
+  });
+}
+async function fetchDistTags(env, request) {
+  try {
+    const url = registryUrl(env);
+    if (!url)
+      return null;
+    const text = await request(url, {
+      headers: { accept: "application/json", "user-agent": `${PACKAGE_NAME}-cli/${CLI_VERSION}` },
+      maxResponseBytes: MAX_RESPONSE_BYTES,
+      timeoutMs: REGISTRY_TIMEOUT_MS
+    });
+    if (text === null || Buffer.byteLength(text) > MAX_RESPONSE_BYTES)
+      return null;
+    const body = JSON.parse(text);
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+      return null;
+    const tags = {};
+    for (const [tag, version] of Object.entries(body)) {
+      if (typeof version === "string")
+        tags[tag] = version;
+    }
+    return tags;
+  } catch {
+    return null;
+  }
+}
+function readCache(path) {
+  const parsed = readJsonFile(path, MAX_CACHE_BYTES);
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const entry = parsed;
+  if (entry.version !== CACHE_VERSION)
+    return null;
+  if (typeof entry.checkedAt !== "string" || Number.isNaN(Date.parse(entry.checkedAt)))
+    return null;
+  return { version: CACHE_VERSION, checkedAt: entry.checkedAt };
+}
+function writeCache(path, entry) {
+  writeJsonFile(path, entry);
+}
+function isFresh(entry, now) {
+  const age = now.getTime() - Date.parse(entry.checkedAt);
+  return age >= 0 && age < CHECK_INTERVAL_MS;
+}
+function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env = process.env) {
+  const target = `${PACKAGE_NAME}@latest`;
+  const normalized = normalizeModulePath(modulePath);
+  if (normalized.includes(".bun/install/global"))
+    return `bun add -g ${target}`;
+  if (normalized.includes("/pnpm/") || normalized.includes("/.pnpm/")) {
+    return `pnpm add -g ${target}`;
+  }
+  if (normalized.includes("/.yarn/") || normalized.includes("/yarn/")) {
+    return `yarn global add ${target}`;
+  }
+  const agent = env.npm_config_user_agent ?? "";
+  if (agent.startsWith("pnpm/"))
+    return `pnpm add -g ${target}`;
+  if (agent.startsWith("yarn/"))
+    return `yarn global add ${target}`;
+  if (agent.startsWith("bun/"))
+    return `bun add -g ${target}`;
+  return `npm install -g ${target}`;
+}
+async function announceUpdateIfAvailable(options = {}) {
+  try {
+    const env = options.env ?? process.env;
+    const isTty = options.isTty ?? process.stderr.isTTY === true;
+    const modulePath = options.modulePath ?? fileURLToPath(import.meta.url);
+    const cwd = options.cwd ?? process.cwd();
+    const now = options.now ?? new Date;
+    if (isEnabled(env.SIM_NO_UPDATE_CHECK))
+      return;
+    if (!isTty)
+      return;
+    if (isCi(env))
+      return;
+    if (isUnadvisableInstall(modulePath, env, cwd))
+      return;
+    const currentVersion = options.currentVersion ?? CLI_VERSION;
+    const current = parseStableVersion(currentVersion);
+    if (!current)
+      return;
+    const cachePath = updateCachePath();
+    const cached = readCache(cachePath);
+    if (cached && isFresh(cached, now))
+      return;
+    const tags = await fetchDistTags(env, options.registryRequest ?? requestRegistry);
+    const latest = tags?.latest ?? null;
+    const available = latest ? parseStableVersion(latest) : null;
+    writeCache(cachePath, {
+      version: CACHE_VERSION,
+      checkedAt: now.toISOString()
+    });
+    if (!latest || !available)
+      return;
+    if (!isNewerVersion(available, current))
+      return;
+    const write = options.write ?? ((message) => void process.stderr.write(message));
+    write(`Update available: sim ${currentVersion} → ${latest}. Run: sim update
+`);
+  } catch {}
 }
-function credentialsPath() {
-  return process.env.SIM_CREDENTIALS_FILE || join(configDir(), "credentials");
+
+// src/update/install.ts
+class CliUpdateError extends Error {
+}
+var PACKAGE_MANAGERS = ["npm", "pnpm", "bun", "yarn"];
+var runPackageManager = (manager, args, { env, capture }) => new Promise((resolve, reject) => {
+  const child = spawn2(manager, args, {
+    cwd: homedir2(),
+    env,
+    shell: process.platform === "win32",
+    stdio: ["ignore", capture ? "pipe" : process.stderr, process.stderr],
+    timeout: capture ? 1e4 : 5 * 60000,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  let output = "";
+  child.stdout?.setEncoding("utf8").on("data", (chunk) => {
+    output += chunk;
+    if (Buffer.byteLength(output) > 64 * 1024) {
+      child.kill("SIGKILL");
+      reject(new CliUpdateError(`${manager} returned too much output while checking Sim.`));
+    }
+  });
+  child.once("error", (error) => {
+    reject(new CliUpdateError(`Could not run ${manager}: ${getErrorMessage(error)}`));
+  });
+  child.once("close", (code, signal) => {
+    if (code !== 0) {
+      reject(new CliUpdateError(`${manager} ${args.join(" ")} failed (${signal ?? `exit ${code}`}). Resolve the package-manager error and run sim update again.`));
+      return;
+    }
+    resolve(output.trim());
+  });
+});
+function parseReleaseVersion(version) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(preview|dev)\.(0|[1-9]\d*)\.(0|[1-9]\d*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version);
+  if (version.length > 256 || !match) {
+    throw new CliUpdateError(`Cannot determine the release channel for Sim ${version}.`);
+  }
+  const precedence = [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])];
+  if (match[4])
+    precedence.push(BigInt(match[5]), BigInt(match[6]));
+  return {
+    channel: match[4] === "preview" ? "staging" : match[4] === "dev" ? "dev" : "latest",
+    precedence
+  };
 }
-function updateCachePath() {
-  return join(configDir(), "update-check.json");
+function compareReleases(candidate, current) {
+  for (const [index, component] of candidate.precedence.entries()) {
+    if (component !== current.precedence[index])
+      return component > current.precedence[index] ? 1 : -1;
+  }
+  return 0;
+}
+function resolveInstallationPath(path) {
+  try {
+    return realpathSync(path);
+  } catch (cause) {
+    throw new CliUpdateError(`Cannot access the Sim installation: ${getErrorMessage(cause)}`, {
+      cause
+    });
+  }
+}
+function readInstalledVersion(entrypoint) {
+  const manifestPath = join2(dirname2(dirname2(resolveInstallationPath(entrypoint))), "package.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  } catch (cause) {
+    throw new CliUpdateError(`Cannot read the installed Sim manifest: ${getErrorMessage(cause)}`, {
+      cause
+    });
+  }
+  if (typeof manifest !== "object" || manifest === null || !("name" in manifest) || manifest.name !== "sim" || !("version" in manifest) || typeof manifest.version !== "string") {
+    throw new CliUpdateError("The installed Sim manifest must name the sim package and its version.");
+  }
+  return manifest.version;
+}
+function parseRegistryVersion(output, manager) {
+  let version;
+  try {
+    if (manager === "yarn") {
+      const events = output.split(/\r?\n/).filter((line) => line.trim()).map((line) => JSON.parse(line));
+      const inspections = events.filter((event) => typeof event === "object" && event !== null && ("type" in event) && event.type === "inspect" && ("data" in event));
+      if (inspections.length === 1)
+        version = inspections[0].data;
+    } else {
+      version = JSON.parse(output);
+    }
+  } catch (cause) {
+    throw new CliUpdateError(`${manager} returned invalid registry JSON.`, { cause });
+  }
+  if (typeof version !== "string") {
+    throw new CliUpdateError(`${manager} did not resolve a single Sim release version.`);
+  }
+  return version;
+}
+async function installUpdate(options = {}) {
+  const modulePath = resolveInstallationPath(options.modulePath ?? fileURLToPath2(import.meta.url));
+  const env = omit(options.env ?? process.env, ["SIM_API_KEY"]);
+  const normalized = modulePath.replaceAll("\\", "/").toLowerCase();
+  if (env.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/bunx-") || !normalized.endsWith("/node_modules/sim/dist/index.js")) {
+    throw new CliUpdateError("sim update requires a global installation. Update project dependencies with their package manager, or use sim@latest with your package runner.");
+  }
+  const manager = options.packageManager ?? upgradeCommand(modulePath, env).split(" ")[0];
+  if (!PACKAGE_MANAGERS.includes(manager)) {
+    throw new CliUpdateError("Cannot determine which package manager installed Sim.");
+  }
+  const packageManager = manager;
+  const run = options.run ?? runPackageManager;
+  const currentVersion = options.currentVersion ?? CLI_VERSION;
+  const current = parseReleaseVersion(currentVersion);
+  const target = current.channel;
+  const write = options.write ?? ((message) => void process.stderr.write(message));
+  env.SIM_NO_UPDATE_CHECK = "1";
+  const locateArgs = packageManager === "bun" ? ["pm", "bin", "-g"] : packageManager === "yarn" ? ["global", "dir", "--silent"] : ["root", "-g"];
+  const directory = await run(packageManager, locateArgs, { env, capture: true });
+  if (!isAbsolute(directory) || /[\r\n]/.test(directory)) {
+    throw new CliUpdateError(`${packageManager} did not return a valid global installation path.`);
+  }
+  const installedEntry = packageManager === "bun" ? join2(directory, "sim") : join2(directory, ...packageManager === "yarn" ? ["node_modules"] : [], "sim/dist/index.js");
+  if (resolveInstallationPath(installedEntry) !== modulePath) {
+    throw new CliUpdateError(`${packageManager} would update a different Sim installation. Use the package manager and global configuration that installed this copy, or select --package-manager.`);
+  }
+  const release = await import_proper_lockfile.lock(dirname2(dirname2(modulePath)), { retries: 0, realpath: false }).catch((cause) => {
+    throw new CliUpdateError(`Cannot lock Sim for update: ${getErrorMessage(cause)}`, { cause });
+  });
+  let updateFailed = false;
+  try {
+    if (readInstalledVersion(installedEntry) !== currentVersion) {
+      throw new CliUpdateError("The Sim installation changed while starting the update. Run sim update again.");
+    }
+    const version = parseRegistryVersion(await run(packageManager, [
+      packageManager === "bun" || packageManager === "yarn" ? "info" : "view",
+      `sim@${target}`,
+      "version",
+      "--json"
+    ], { env, capture: true }), packageManager);
+    const candidate = parseReleaseVersion(version);
+    if (candidate.channel !== target) {
+      throw new CliUpdateError("The registry resolved Sim to a different release channel.");
+    }
+    const comparison = compareReleases(candidate, current);
+    if (comparison < 0) {
+      throw new CliUpdateError(`Refusing to downgrade Sim ${currentVersion} to ${version}. Check your package-manager registry settings.`);
+    }
+    if (comparison === 0) {
+      write(`Sim ${currentVersion} is already up to date.
+`);
+      return;
+    }
+    write(`Updating Sim ${currentVersion} with ${packageManager} (sim@${version})…
+`);
+    const args = packageManager === "npm" ? ["install", "-g", `sim@${version}`] : packageManager === "yarn" ? ["global", "add", `sim@${version}`] : ["add", "-g", `sim@${version}`];
+    await run(packageManager, args, { env, capture: false });
+    if (readInstalledVersion(installedEntry) !== version) {
+      throw new CliUpdateError("The package manager did not install the expected Sim version.");
+    }
+    write(`Updated Sim ${currentVersion} → ${version}. The next invocation will use the new version.
+`);
+  } catch (error) {
+    updateFailed = true;
+    throw error;
+  } finally {
+    await release().catch((cause) => {
+      const message = `Cannot release the Sim update lock: ${getErrorMessage(cause)}`;
+      if (updateFailed) {
+        write(`${message}
+`);
+      } else {
+        throw new CliUpdateError(message, { cause });
+      }
+    });
+  }
 }
 // src/config/profile.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import {
   chmodSync,
   existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  renameSync as renameSync2,
   rmSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname } from "node:path";
+import { dirname as dirname3 } from "node:path";
 
 // src/config/ini.ts
 class ProfileConfigError extends Error {
@@ -7130,16 +7683,16 @@ function configSectionName(profile) {
 function readIni(path) {
   if (!existsSync(path))
     return { preamble: [], sections: [] };
-  return parseIni(readFileSync(path, "utf8"));
+  return parseIni(readFileSync3(path, "utf8"));
 }
 function writeIni(path, doc, secret) {
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
   const temporary = `${path}.${process.pid}.${temporaryFileSequence++}.tmp`;
   try {
-    writeFileSync(temporary, serializeIni(doc), { mode: secret ? 384 : 420 });
+    writeFileSync2(temporary, serializeIni(doc), { mode: secret ? 384 : 420 });
     if (secret)
       chmodSync(temporary, 384);
-    renameSync(temporary, path);
+    renameSync2(temporary, path);
   } catch (error) {
     rmSync(temporary, { force: true });
     throw error;
@@ -7301,10 +7854,10 @@ var heldLock = new AsyncLocalStorage;
 async function withProfileLoginLease(profile, work) {
   const digest = createHash("sha256").update(profile, "utf8").digest("hex");
   const path = `${credentialsPath()}.login-${digest}`;
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
   let release;
   try {
-    release = await import_proper_lockfile.lock(path, {
+    release = await import_proper_lockfile2.lock(path, {
       realpath: false,
       stale: CREDENTIALS_LOCK_STALE_MS,
       update: CREDENTIALS_LOCK_STALE_MS / 3,
@@ -7326,10 +7879,10 @@ async function withCredentialsLock(work) {
   if (heldLock.getStore())
     return work();
   const path = credentialsPath();
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
   let release;
   try {
-    release = await import_proper_lockfile.lock(path, {
+    release = await import_proper_lockfile2.lock(path, {
       realpath: false,
       stale: CREDENTIALS_LOCK_STALE_MS,
       update: CREDENTIALS_LOCK_STALE_MS / 3,
@@ -7468,17 +8021,190 @@ function resolveProfile(overrides = {}) {
     }
   };
 }
-// src/version.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-function readPackageVersion() {
-  const metadata = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
-  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
-    throw new Error("CLI package metadata is missing a valid version");
-  }
-  return metadata.version;
+// ../utils/src/client-info.ts
+var CLIENT_INFO_HEADER = "x-sim-client-info";
+var SIM_SURFACES = ["web", "desktop", "cli", "sdk-js", "sdk-python"];
+var TOKEN_PATTERN = /^[A-Za-z0-9._+-]+$/;
+var OS_KEY = "os";
+var ARCH_KEY = "arch";
+var AGENT_KEY = "agent";
+var SURFACE_SET = new Set(SIM_SURFACES);
+function isToken(value) {
+  return TOKEN_PATTERN.test(value);
+}
+function product(name, version) {
+  if (!isToken(name))
+    throw new Error(`Client info token name is not a valid token: ${name}`);
+  if (version === undefined)
+    return name;
+  if (!isToken(version))
+    throw new Error(`Client info token version is not a valid token: ${version}`);
+  return `${name}/${version}`;
+}
+function formatClientInfo(info) {
+  const tokens = [product(info.surface, info.version)];
+  if (info.runtime)
+    tokens.push(product(info.runtime.name, info.runtime.version));
+  if (info.os)
+    tokens.push(product(OS_KEY, info.os));
+  if (info.arch)
+    tokens.push(product(ARCH_KEY, info.arch));
+  if (info.agent)
+    tokens.push(product(AGENT_KEY, info.agent));
+  return tokens.join("; ");
+}
+
+// src/telemetry/coding-agent.ts
+var AGENT_NAME_PATTERN = /^[a-z0-9_-]+$/i;
+var MAX_AGENT_NAME_LENGTH = 64;
+var anyOf = (...variables) => (env) => variables.some((variable) => Boolean(env[variable]));
+var AGENT_MARKERS = [
+  { name: "amp", matches: (env) => env.AGENT === "amp" || Boolean(env.AMP_CURRENT_THREAD_ID) },
+  {
+    name: "codex",
+    matches: anyOf("CODEX_THREAD_ID", "CODEX_SANDBOX", "CODEX_CI", "CODEX_SANDBOX_NETWORK_DISABLED")
+  },
+  { name: "gemini-cli", matches: anyOf("GEMINI_CLI") },
+  { name: "opencode", matches: anyOf("OPENCODE") },
+  { name: "antigravity", matches: anyOf("ANTIGRAVITY_AGENT") },
+  { name: "augment", matches: anyOf("AUGMENT_AGENT") },
+  { name: "cline", matches: anyOf("CLINE_ACTIVE") },
+  { name: "cowork", matches: anyOf("CLAUDE_CODE_IS_COWORK") },
+  { name: "claude-code", matches: anyOf("CLAUDECODE", "CLAUDE_CODE") },
+  {
+    name: "cursor",
+    matches: (env) => anyOf("CURSOR_AGENT", "CURSOR_TRACE_ID")(env) || env.CURSOR_EXTENSION_HOST_ROLE === "agent-exec"
+  },
+  { name: "warp", matches: anyOf("OZ_RUN_ID") },
+  { name: "pi", matches: anyOf("PI_CODING_AGENT") },
+  { name: "crush", matches: anyOf("CRUSH") }
+];
+function declaredAgentName(value) {
+  const trimmed = value?.trim().toLowerCase();
+  if (!trimmed || trimmed.length > MAX_AGENT_NAME_LENGTH)
+    return;
+  return AGENT_NAME_PATTERN.test(trimmed) ? trimmed : undefined;
+}
+function detectCodingAgent(env = process.env) {
+  const declared = declaredAgentName(env.AI_AGENT);
+  if (declared)
+    return declared;
+  const generic = declaredAgentName(env.AGENT);
+  if (generic && generic !== "1")
+    return generic;
+  return AGENT_MARKERS.find((marker) => marker.matches(env))?.name;
+}
+
+// src/telemetry/policy.ts
+var DO_NOT_TRACK_VARIABLE = "DO_NOT_TRACK";
+var TELEMETRY_DISABLED_VARIABLE = "SIM_TELEMETRY_DISABLED";
+function telemetryStatus({ env, state, configured }) {
+  if (isEnabled(env[DO_NOT_TRACK_VARIABLE]))
+    return { enabled: false, reason: "do_not_track" };
+  if (isEnabled(env[TELEMETRY_DISABLED_VARIABLE]))
+    return { enabled: false, reason: "environment" };
+  if (state.enabled === false)
+    return { enabled: false, reason: "setting" };
+  if (!configured)
+    return { enabled: false, reason: "unconfigured" };
+  return { enabled: true };
+}
+
+// ../utils/src/id.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/telemetry/state.ts
+var SESSION_IDLE_MS = 30 * 60 * 1000;
+var MAX_STATE_BYTES = 4 * 1024;
+var STATE_VERSION = 1;
+var STATE_FILE_MODE = 384;
+function isIsoTimestamp(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function parseSession(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const session = value;
+  if (typeof session.id !== "string" || !session.id)
+    return;
+  if (!isIsoTimestamp(session.lastActiveAt))
+    return;
+  if (!Number.isSafeInteger(session.sequence) || session.sequence < 0)
+    return;
+  return {
+    id: session.id,
+    lastActiveAt: session.lastActiveAt,
+    sequence: session.sequence
+  };
+}
+function initialTelemetryState() {
+  return { version: STATE_VERSION, deviceId: generateId() };
+}
+function readTelemetryState(path = telemetryStatePath()) {
+  const parsed = readJsonFile(path, MAX_STATE_BYTES);
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const state = parsed;
+  if (state.version !== STATE_VERSION)
+    return null;
+  if (typeof state.deviceId !== "string" || !state.deviceId)
+    return null;
+  const result = { version: STATE_VERSION, deviceId: state.deviceId };
+  if (typeof state.enabled === "boolean")
+    result.enabled = state.enabled;
+  if (isIsoTimestamp(state.noticeShownAt))
+    result.noticeShownAt = state.noticeShownAt;
+  const session = parseSession(state.session);
+  if (session)
+    result.session = session;
+  return result;
+}
+function loadTelemetryState(path = telemetryStatePath()) {
+  return readTelemetryState(path) ?? initialTelemetryState();
+}
+function writeTelemetryState(state, path = telemetryStatePath()) {
+  writeJsonFile(path, state, STATE_FILE_MODE);
+}
+function nextSession(state, now) {
+  const current = state.session;
+  const idleFor = current ? now.getTime() - Date.parse(current.lastActiveAt) : Number.NaN;
+  if (current && idleFor >= 0 && idleFor < SESSION_IDLE_MS) {
+    return { id: current.id, lastActiveAt: now.toISOString(), sequence: current.sequence + 1 };
+  }
+  return { id: generateId(), lastActiveAt: now.toISOString(), sequence: 1 };
+}
+
+// src/telemetry/client-info.ts
+var cached;
+function clientInfoHeader(env = process.env) {
+  if (env !== process.env)
+    return buildClientInfoHeader(env);
+  cached ??= buildClientInfoHeader(env);
+  return cached;
+}
+function buildClientInfoHeader(env) {
+  return formatClientInfo({
+    surface: "cli",
+    version: CLI_VERSION,
+    runtime: { name: "node", version: process.versions.node },
+    os: process.platform,
+    arch: process.arch,
+    ...reportingAllowed(env) ? { agent: detectCodingAgent(env) } : {}
+  });
+}
+function reportingAllowed(env) {
+  return telemetryStatus({ env, state: loadTelemetryState(), configured: true }).enabled;
 }
-var CLI_VERSION = readPackageVersion();
-var USER_AGENT = `sim-cli/${CLI_VERSION} node/${process.versions.node} (${process.platform}; ${process.arch})`;
 
 // src/http/environment.ts
 var reported = new Set;
@@ -7818,6 +8544,7 @@ class SimClient {
           ...credential?.kind === "oauth" ? { authorization: `Bearer ${credential.oauth.accessToken}` } : {},
           accept: "application/json",
           "user-agent": USER_AGENT,
+          [CLIENT_INFO_HEADER]: clientInfoHeader(),
           ...hasBody ? { "content-type": "application/json" } : {},
           ...options.headers
         },
@@ -8466,20 +9193,18 @@ var {
   Help
 } = import__.default;
 
+// src/commands/update.ts
+function updateCommand() {
+  return new Command("update").description("Update this global CLI installation to the newest release on its channel").addOption(new Option("--package-manager <manager>", "Package manager that installed this copy").choices(["npm", "pnpm", "bun", "yarn"])).action(async (options) => {
+    await installUpdate({ packageManager: options.packageManager });
+  });
+}
+
 // src/commands/auth.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 
-// ../utils/src/errors.ts
-function getErrorMessage(value, fallback) {
-  if (value instanceof Error)
-    return value.message;
-  if (typeof value === "string" && value.length > 0)
-    return value;
-  return fallback ?? String(value);
-}
-
 // src/auth/device-flow.ts
 import { createHash as createHash3, randomBytes as randomBytes2, randomInt } from "node:crypto";
 
@@ -14627,7 +15352,7 @@ var MAX_INTERACTIVE_WORKSPACES = 1000;
 function openBrowser(url) {
   const [command, args] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : [process.platform === "darwin" ? "open" : "xdg-open", [url]];
   try {
-    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    const child = spawn3(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
@@ -17094,7 +17819,7 @@ function attachWorkspaceOperationWait(operations) {
 }
 
 // src/runtime/request.ts
-import { closeSync, existsSync as existsSync2, fstatSync, openSync, readSync } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync2, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2 } from "node:fs";
 var PROFILE_INJECTED_FIELD = "workspaceId";
 function isProfileWorkspacePath(commandSpec, param) {
   return commandSpec.profileWorkspacePath === true && param === PROFILE_INJECTED_FIELD;
@@ -17158,7 +17883,7 @@ function readArgumentDescriptor(descriptor) {
   for (;; ) {
     let read;
     try {
-      read = readSync(descriptor, buffer, 0, buffer.length, null);
+      read = readSync2(descriptor, buffer, 0, buffer.length, null);
     } catch (error) {
       const code = error.code;
       if (code === "EAGAIN") {
@@ -17200,13 +17925,13 @@ function readArgumentSource(raw, flagName) {
     }
   }
   try {
-    const descriptor = openSync(path, "r");
+    const descriptor = openSync2(path, "r");
     try {
-      if (fstatSync(descriptor).size > MAX_JSON_ARGUMENT_BYTES)
+      if (fstatSync2(descriptor).size > MAX_JSON_ARGUMENT_BYTES)
         throw new SimApiError("JSON input exceeds 10 MiB", 0);
       return { text: readArgumentDescriptor(descriptor), from: ` (read from ${path})` };
     } finally {
-      closeSync(descriptor);
+      closeSync2(descriptor);
     }
   } catch (error) {
     throw new SimApiError(`--${flagName} cannot read ${path}: ${error.message}${literalAtHint(error, path)}`, 0);
@@ -18511,7 +19236,7 @@ Examples:
 import { once as once2 } from "node:events";
 import { createWriteStream, rmSync as rmSync2 } from "node:fs";
 import { link, lstat, mkdtemp, readlink, rename, rm } from "node:fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join3, resolve as resolve2 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 function writeFailure(path, error) {
@@ -18543,7 +19268,7 @@ async function forcedPublicationTarget(target) {
     }
     if (!metadata.isSymbolicLink())
       return candidate;
-    candidate = resolve2(dirname2(candidate), await readlink(candidate));
+    candidate = resolve2(dirname4(candidate), await readlink(candidate));
   }
 }
 function normalizedWriteFailure(target, error) {
@@ -18596,8 +19321,8 @@ async function saveStagedFile(body, target, force) {
   try {
     try {
       const publicationTarget = force ? await forcedPublicationTarget(target) : target;
-      temporaryDirectory = await mkdtemp(join2(dirname2(publicationTarget), ".sim-download-"));
-      const temporaryPath = join2(temporaryDirectory, "payload");
+      temporaryDirectory = await mkdtemp(join3(dirname4(publicationTarget), ".sim-download-"));
+      const temporaryPath = join3(temporaryDirectory, "payload");
       await streamToFile(body, createWriteStream(temporaryPath, { flags: "wx" }), target);
       if (force) {
         await rename(temporaryPath, publicationTarget);
@@ -18695,7 +19420,7 @@ function attachFileGet(files) {
 }
 
 // src/transfer/local-file.ts
-import { constants } from "node:fs";
+import { constants as constants2 } from "node:fs";
 import { access, stat } from "node:fs/promises";
 import { basename } from "node:path";
 var CONTENT_TYPES = {
@@ -18736,7 +19461,7 @@ async function localFile(path, override) {
     const stats = await stat(path);
     if (!stats.isFile())
       throw new SimApiError(`${path} is not a regular file`, 0);
-    await access(path, constants.R_OK);
+    await access(path, constants2.R_OK);
     size = stats.size;
   } catch (error) {
     if (error instanceof SimApiError)
@@ -18907,7 +19632,7 @@ function attachKnowledgeDocumentUpload(documents) {
 }
 
 // src/commands/protocol/knowledge-export.ts
-import { basename as basename2, join as join3 } from "node:path";
+import { basename as basename2, join as join4 } from "node:path";
 function attachmentFileName(contentDisposition) {
   if (!contentDisposition)
     return null;
@@ -18949,7 +19674,7 @@ function attachKnowledgeExport(knowledge) {
       await streamToStdout(response.body);
       return;
     }
-    const target = options.outputFile ?? join3(process.cwd(), attachmentFileName(response.headers.get("content-disposition")) ?? `${knowledgeBaseId}.simkb.zip`);
+    const target = options.outputFile ?? join4(process.cwd(), attachmentFileName(response.headers.get("content-disposition")) ?? `${knowledgeBaseId}.simkb.zip`);
     await saveToFile(response.body, target, Boolean(options.force));
     printProtocolResult(profile.output, {
       id: knowledgeBaseId,
@@ -20087,341 +20812,252 @@ async function setSecret(name, options, command, redactionSpellings) {
     body: {
       workspaceId: client.requireWorkspace(),
       scope: options.scope,
-      ...value === undefined ? {} : { value },
-      description,
-      ...unredacted === undefined ? {} : { unredacted }
-    }
-  });
-  renderResult("setSecret", profile.output, response.data, SECRET_RESULT);
-}
-function attachSecretCommands(program) {
-  const secrets = program.commands.find((command) => command.name() === "secrets");
-  if (!secrets)
-    throw new Error("The generated secrets command group is missing");
-  const redactionSpellings = new Set;
-  secrets.command("set").argument("<name>", "Secret name, as referenced in workflows").description(describeOperation(V2_OPERATIONS.setSecret, "Create or replace a named secret")).addOption(new Option("--scope <scope>", "Secret ownership scope (required)").choices([...SECRET_SCOPES]).makeOptionMandatory()).option("--value <value|@file>", "Secret value. Passing it inline exposes it to shell history and process listings; @path reads it from a file and @- from stdin, verbatim — a trailing newline is part of the value, so write the file with printf rather than echo. Prefix a literal leading @ with a second one").option("--description <description>", "What the secret is for, shown to teammates; workspace scope only. Omit to leave an existing description unchanged").option("--unredacted", `${V2_OPERATIONS.setSecret.body.unredacted.describe} Pass --no-unredacted to restore redaction`).option("--no-unredacted", "Send --unredacted as false").on("option:unredacted", () => redactionSpellings.add("--unredacted")).on("option:no-unredacted", () => redactionSpellings.add("--no-unredacted")).action((name, options, command) => setSecret(name, options, command, redactionSpellings));
-}
-
-// src/update/check.ts
-import { spawn as spawn2 } from "node:child_process";
-import {
-  closeSync as closeSync2,
-  constants as constants2,
-  fstatSync as fstatSync2,
-  lstatSync,
-  mkdirSync as mkdirSync2,
-  openSync as openSync2,
-  readSync as readSync2,
-  renameSync as renameSync2,
-  unlinkSync,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import { dirname as dirname3 } from "node:path";
-import { fileURLToPath } from "node:url";
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-var REGISTRY_TIMEOUT_MS = 1000;
-var DEFAULT_REGISTRY = "https://registry.npmjs.org";
-var PACKAGE_NAME = "sim";
-var DIST_TAGS_PATH = `-/package/${PACKAGE_NAME}/dist-tags`;
-var MAX_RESPONSE_BYTES = 64 * 1024;
-var MAX_CACHE_BYTES = 4 * 1024;
-var STABLE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function parseStableVersion(version) {
-  const match = STABLE_VERSION_PATTERN.exec(version);
-  if (!match)
-    return null;
-  const parsed = [Number(match[1]), Number(match[2]), Number(match[3])];
-  return parsed.every(Number.isSafeInteger) ? parsed : null;
-}
-function isNewerVersion(candidate, current) {
-  if (candidate[0] !== current[0])
-    return candidate[0] > current[0];
-  if (candidate[1] !== current[1])
-    return candidate[1] > current[1];
-  return candidate[2] > current[2];
-}
-var CI_VARIABLES = [
-  "CI",
-  "GITHUB_ACTIONS",
-  "JENKINS_URL",
-  "TEAMCITY_VERSION",
-  "BUILDKITE"
-];
-var CACHE_VERSION = 1;
-var cacheWriteSequence = 0;
-function isEnabled(value) {
-  if (value === undefined)
-    return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized !== "" && normalized !== "0" && normalized !== "false";
-}
-function isProjectLocalInstall(modulePath, cwd) {
-  const normalizedModulePath = normalizeModulePath(modulePath);
-  const nodeModulesIndex = normalizedModulePath.indexOf("/node_modules/");
-  if (nodeModulesIndex < 0)
-    return false;
-  const installRoot = normalizedModulePath.slice(0, nodeModulesIndex);
-  const workingDirectory = normalizeModulePath(cwd).replace(/\/+$/, "");
-  return workingDirectory === installRoot || workingDirectory.startsWith(`${installRoot}/`);
-}
-function isUnadvisableInstall(modulePath, env, cwd) {
-  const normalized = normalizeModulePath(modulePath);
-  return env.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/packages/sim-cli/") || isProjectLocalInstall(modulePath, cwd);
-}
-function normalizeModulePath(modulePath) {
-  return modulePath.replace(/\\/g, "/").toLowerCase();
-}
-function registryUrl(env) {
-  const fallback = new URL(DIST_TAGS_PATH, DEFAULT_REGISTRY);
-  const configured = env.npm_config_registry?.trim();
-  if (!configured)
-    return fallback;
-  try {
-    const base = new URL(configured);
-    if (base.protocol !== "http:" && base.protocol !== "https:")
-      return null;
-    if (base.username || base.password)
-      return null;
-    base.pathname = `${base.pathname.replace(/\/$/, "")}/${DIST_TAGS_PATH}`;
-    return base;
-  } catch {
-    return null;
-  }
+      ...value === undefined ? {} : { value },
+      description,
+      ...unredacted === undefined ? {} : { unredacted }
+    }
+  });
+  renderResult("setSecret", profile.output, response.data, SECRET_RESULT);
 }
-var REGISTRY_REQUEST_SCRIPT = `
-let input = ''
-process.stdin.setEncoding('utf8')
-for await (const chunk of process.stdin) input += chunk
-
+function attachSecretCommands(program) {
+  const secrets = program.commands.find((command) => command.name() === "secrets");
+  if (!secrets)
+    throw new Error("The generated secrets command group is missing");
+  const redactionSpellings = new Set;
+  secrets.command("set").argument("<name>", "Secret name, as referenced in workflows").description(describeOperation(V2_OPERATIONS.setSecret, "Create or replace a named secret")).addOption(new Option("--scope <scope>", "Secret ownership scope (required)").choices([...SECRET_SCOPES]).makeOptionMandatory()).option("--value <value|@file>", "Secret value. Passing it inline exposes it to shell history and process listings; @path reads it from a file and @- from stdin, verbatim — a trailing newline is part of the value, so write the file with printf rather than echo. Prefix a literal leading @ with a second one").option("--description <description>", "What the secret is for, shown to teammates; workspace scope only. Omit to leave an existing description unchanged").option("--unredacted", `${V2_OPERATIONS.setSecret.body.unredacted.describe} Pass --no-unredacted to restore redaction`).option("--no-unredacted", "Send --unredacted as false").on("option:unredacted", () => redactionSpellings.add("--unredacted")).on("option:no-unredacted", () => redactionSpellings.add("--no-unredacted")).action((name, options, command) => setSecret(name, options, command, redactionSpellings));
+}
+// src/telemetry/transport.ts
+import { spawn as spawn4 } from "node:child_process";
+var BUILT_IN_KEY = process.env.SIM_CLI_TELEMETRY_KEY;
+var BUILT_IN_HOST = process.env.SIM_CLI_TELEMETRY_HOST;
+var DEFAULT_INGEST_HOST = "https://us.i.posthog.com";
+var CAPTURE_PATH = "/i/v0/e/";
+var SEND_TIMEOUT_MS = 5000;
+var PAYLOAD_VARIABLE = "SIM_TELEMETRY_CAPTURE";
+function builtInIngestTarget() {
+  if (!BUILT_IN_KEY)
+    return;
+  return { key: BUILT_IN_KEY, host: BUILT_IN_HOST || DEFAULT_INGEST_HOST };
+}
+var SEND_SCRIPT = `
 try {
-  const { url, headers, maxResponseBytes, timeoutMs } = JSON.parse(input)
+  const { url, body, timeoutMs } = JSON.parse(process.env[${JSON.stringify(PAYLOAD_VARIABLE)}])
   const deadline = setTimeout(() => process.exit(1), timeoutMs)
-  const response = await fetch(url, { headers, redirect: 'error' })
-  const declared = Number(response.headers.get('content-length'))
-
-  if (!response.ok || !response.body || (Number.isFinite(declared) && declared > maxResponseBytes)) {
-    process.exit(1)
-  }
-
-  const reader = response.body.getReader()
-  const chunks = []
-  let seen = 0
-
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) break
-    seen += value.byteLength
-    if (seen > maxResponseBytes) {
-      process.exit(1)
-    }
-    chunks.push(Buffer.from(value))
-  }
-
+  await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body,
+    redirect: 'error',
+  })
   clearTimeout(deadline)
-  process.stdout.write(Buffer.concat(chunks), () => process.exit(0))
+  process.exit(0)
 } catch {
   process.exit(1)
 }
 `;
-function registryProcessEnv() {
-  const env = { ...process.env };
-  for (const key of Object.keys(env)) {
-    const normalized = key.toLowerCase();
-    if (normalized === "npm_config_registry" || normalized === "sim_api_key")
-      delete env[key];
-  }
-  return env;
-}
-function requestRegistry(url, { headers, maxResponseBytes, timeoutMs }) {
-  return new Promise((resolve, reject) => {
-    const proxyArguments = process.execArgv.filter((argument) => argument === "--use-env-proxy" || argument === "--no-use-env-proxy");
-    const child = spawn2(process.execPath, [...proxyArguments, "--input-type=module", "--eval", REGISTRY_REQUEST_SCRIPT], {
-      env: registryProcessEnv(),
-      killSignal: "SIGKILL",
-      stdio: ["pipe", "pipe", "ignore"],
-      timeout: timeoutMs,
-      windowsHide: true
-    });
-    const chunks = [];
-    let failed = false;
-    let seen = 0;
-    child.stdout.on("data", (chunk) => {
-      seen += chunk.byteLength;
-      if (seen > maxResponseBytes) {
-        failed = true;
-        child.kill("SIGKILL");
-        return;
-      }
-      chunks.push(chunk);
-    });
-    child.stdout.on("error", () => {
-      failed = true;
-      child.kill("SIGKILL");
-    });
-    child.stdin.on("error", () => {});
-    child.once("error", reject);
-    child.once("close", (code) => {
-      resolve(code === 0 && !failed ? Buffer.concat(chunks).toString("utf8") : null);
-    });
-    child.stdin.end(JSON.stringify({ headers, maxResponseBytes, timeoutMs, url: url.href }));
+function sendCapture(target, request, spawnSender = spawn4) {
+  const payload = JSON.stringify({
+    url: new URL(CAPTURE_PATH, target.host).href,
+    body: JSON.stringify(request),
+    timeoutMs: SEND_TIMEOUT_MS
   });
-}
-async function fetchDistTags(env, request) {
   try {
-    const url = registryUrl(env);
-    if (!url)
-      return null;
-    const text = await request(url, {
-      headers: { accept: "application/json", "user-agent": `${PACKAGE_NAME}-cli/${CLI_VERSION}` },
-      maxResponseBytes: MAX_RESPONSE_BYTES,
-      timeoutMs: REGISTRY_TIMEOUT_MS
+    const child = spawnSender(process.execPath, [...proxyExecArgv(), "--input-type=module", "--eval", SEND_SCRIPT], {
+      detached: true,
+      env: childProcessEnv(["sim_api_key"], { [PAYLOAD_VARIABLE]: payload }),
+      stdio: "ignore",
+      windowsHide: true
     });
-    if (text === null || Buffer.byteLength(text) > MAX_RESPONSE_BYTES)
-      return null;
-    const body = JSON.parse(text);
-    if (typeof body !== "object" || body === null || Array.isArray(body))
-      return null;
-    const tags = {};
-    for (const [tag, version] of Object.entries(body)) {
-      if (typeof version === "string")
-        tags[tag] = version;
-    }
-    return tags;
-  } catch {
-    return null;
+    child.once("error", () => {});
+    child.unref();
+  } catch {}
+}
+
+// src/telemetry/invocation.ts
+var COMMAND_EVENT = "cli_command_executed";
+var LIBRARY_NAME = "sim-cli";
+var EXCLUDED_ROOT_COMMAND = "telemetry";
+var USAGE_DATA_DOCS_URL = "https://docs.sim.ai/cli/usage-data";
+var FIRST_RUN_NOTICE = [
+  "Sim collects anonymous usage data to improve the CLI: which commands run, whether",
+  "they succeed, and how long they take. Nothing you type is sent.",
+  `Learn more: ${USAGE_DATA_DOCS_URL}`,
+  "Turn it off: sim telemetry disable",
+  ""
+].join(`
+`);
+function commandPath2(command) {
+  const names = [];
+  for (let current = command;current?.parent; current = current.parent) {
+    names.unshift(current.name());
   }
+  return names;
 }
-function readCache(path) {
-  let descriptor = null;
-  try {
-    if (!lstatSync(path).isFile())
-      return null;
-    descriptor = openSync2(path, constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.O_NOFOLLOW);
-    const descriptorStats = fstatSync2(descriptor);
-    if (!descriptorStats.isFile() || descriptorStats.size > MAX_CACHE_BYTES) {
-      return null;
-    }
-    const buffer = Buffer.allocUnsafe(MAX_CACHE_BYTES + 1);
-    let bytesRead = 0;
-    while (bytesRead < buffer.byteLength) {
-      const count = readSync2(descriptor, buffer, bytesRead, buffer.byteLength - bytesRead, bytesRead);
-      if (count === 0)
-        break;
-      bytesRead += count;
-    }
-    if (bytesRead > MAX_CACHE_BYTES)
-      return null;
-    const parsed = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
-    if (typeof parsed !== "object" || parsed === null)
-      return null;
-    const entry = parsed;
-    if (entry.version !== CACHE_VERSION)
-      return null;
-    if (typeof entry.checkedAt !== "string" || Number.isNaN(Date.parse(entry.checkedAt)))
-      return null;
-    return {
-      version: CACHE_VERSION,
-      checkedAt: entry.checkedAt
-    };
-  } catch {
-    return null;
-  } finally {
-    if (descriptor !== null) {
-      try {
-        closeSync2(descriptor);
-      } catch {}
+function typedFlags(command) {
+  const flags = new Set;
+  for (let current = command;current; current = current.parent) {
+    for (const option of current.options) {
+      if (current.getOptionValueSource(option.attributeName()) !== "cli")
+        continue;
+      const name = option.long ?? option.short;
+      if (name)
+        flags.add(name);
     }
   }
+  return [...flags];
 }
-function writeCache(path, entry) {
-  let descriptor = null;
-  let temporaryCreated = false;
-  const temporaryPath = `${path}.${process.pid}.${Date.now()}.${cacheWriteSequence++}.tmp`;
+function endpointKind(command) {
   try {
-    mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
-    descriptor = openSync2(temporaryPath, "wx", 420);
-    temporaryCreated = true;
-    writeFileSync2(descriptor, `${JSON.stringify(entry, null, 2)}
-`);
-    closeSync2(descriptor);
-    descriptor = null;
-    renameSync2(temporaryPath, path);
-    temporaryCreated = false;
-  } catch {} finally {
-    if (descriptor !== null) {
-      try {
-        closeSync2(descriptor);
-      } catch {}
-    }
-    if (temporaryCreated) {
-      try {
-        unlinkSync(temporaryPath);
-      } catch {}
-    }
+    const hostname = new URL(profileFrom(command).endpoint).hostname;
+    return hostname === "sim.ai" || hostname.endsWith(".sim.ai") ? "hosted" : "self_hosted";
+  } catch {
+    return;
   }
 }
-function isFresh(entry, now) {
-  const age = now.getTime() - Date.parse(entry.checkedAt);
-  return age >= 0 && age < CHECK_INTERVAL_MS;
-}
-function upgradeCommand(modulePath = fileURLToPath(import.meta.url), env = process.env) {
-  const target = `${PACKAGE_NAME}@latest`;
-  const normalized = normalizeModulePath(modulePath);
-  if (normalized.includes(".bun/install/global"))
-    return `bun add -g ${target}`;
-  if (normalized.includes("/pnpm/") || normalized.includes("/.pnpm/")) {
-    return `pnpm add -g ${target}`;
-  }
-  if (normalized.includes("/.yarn/") || normalized.includes("/yarn/")) {
-    return `yarn global add ${target}`;
+function failureProperties(error) {
+  if (error === undefined)
+    return {};
+  if (!(error instanceof Error))
+    return { error_name: "unknown" };
+  const properties = { error_name: error.name };
+  if (error instanceof SimApiError) {
+    if (error.code)
+      properties.error_code = error.code;
+    if (error.status > 0)
+      properties.http_status = error.status;
+  }
+  return properties;
+}
+var listenForProcessExit = (listener) => {
+  process.once("exit", listener);
+};
+function createCommandTelemetry(options = {}) {
+  const env = options.env ?? process.env;
+  const ingestTarget = options.ingestTarget ?? builtInIngestTarget;
+  const send = options.send ?? sendCapture;
+  const now = options.now ?? (() => new Date);
+  const elapsed = options.elapsed ?? (() => performance.now());
+  const stdoutIsTty = options.stdoutIsTty ?? process.stdout.isTTY === true;
+  const stderrIsTty = options.stderrIsTty ?? process.stderr.isTTY === true;
+  const write = options.write ?? ((message) => void process.stderr.write(message));
+  const onExit = options.onExit ?? listenForProcessExit;
+  let recorded;
+  function isReportable(state) {
+    return telemetryStatus({ env, state, configured: ingestTarget() !== undefined }).enabled;
+  }
+  function showNoticeIfDue(state) {
+    if (state.noticeShownAt || !stderrIsTty || isCi(env))
+      return false;
+    write(FIRST_RUN_NOTICE);
+    writeTelemetryState({ ...state, noticeShownAt: now().toISOString() });
+    return true;
   }
-  const agent = env.npm_config_user_agent ?? "";
-  if (agent.startsWith("pnpm/"))
-    return `pnpm add -g ${target}`;
-  if (agent.startsWith("yarn/"))
-    return `yarn global add ${target}`;
-  if (agent.startsWith("bun/"))
-    return `bun add -g ${target}`;
-  return `npm install -g ${target}`;
-}
-async function announceUpdateIfAvailable(options = {}) {
-  try {
-    const env = options.env ?? process.env;
-    const isTty = options.isTty ?? process.stderr.isTTY === true;
-    const modulePath = options.modulePath ?? fileURLToPath(import.meta.url);
-    const cwd = options.cwd ?? process.cwd();
-    const now = options.now ?? new Date;
-    if (isEnabled(env.SIM_NO_UPDATE_CHECK))
-      return;
-    if (!isTty)
-      return;
-    if (CI_VARIABLES.some((variable) => isEnabled(env[variable])))
-      return;
-    if (isUnadvisableInstall(modulePath, env, cwd))
+  function complete(outcome) {
+    const invocation = recorded;
+    recorded = undefined;
+    if (!invocation || invocation.noticeShown)
       return;
-    const currentVersion = options.currentVersion ?? CLI_VERSION;
-    const current = parseStableVersion(currentVersion);
-    if (!current)
+    const target = ingestTarget();
+    if (!target)
       return;
-    const cachePath = updateCachePath();
-    const cached = readCache(cachePath);
-    if (cached && isFresh(cached, now))
+    const state = loadTelemetryState();
+    if (!isReportable(state))
       return;
-    const tags = await fetchDistTags(env, options.registryRequest ?? requestRegistry);
-    const latest = tags?.latest ?? null;
-    const available = latest ? parseStableVersion(latest) : null;
-    writeCache(cachePath, {
-      version: CACHE_VERSION,
-      checkedAt: now.toISOString()
+    const timestamp = now();
+    const session = nextSession(state, timestamp);
+    writeTelemetryState({ ...state, session });
+    const properties = {
+      $lib: LIBRARY_NAME,
+      $lib_version: CLI_VERSION,
+      $process_person_profile: false,
+      $session_id: session.id,
+      session_sequence: session.sequence,
+      surface: "cli",
+      command: invocation.command,
+      flags: invocation.flags,
+      arg_count: invocation.argCount,
+      exit_code: outcome.exitCode,
+      duration_ms: Math.round(elapsed()),
+      ...failureProperties(outcome.error),
+      cli_version: CLI_VERSION,
+      node_version: process.versions.node,
+      os: process.platform,
+      arch: process.arch,
+      is_tty: stdoutIsTty,
+      is_ci: isCi(env)
+    };
+    const kind = endpointKind(invocation.action);
+    if (kind)
+      properties.endpoint_kind = kind;
+    const agent = detectCodingAgent(env);
+    if (agent)
+      properties.coding_agent = agent;
+    send(target, {
+      api_key: target.key,
+      event: COMMAND_EVENT,
+      distinct_id: state.deviceId,
+      timestamp: timestamp.toISOString(),
+      properties
     });
-    if (!latest || !available)
-      return;
-    if (!isNewerVersion(available, current))
-      return;
-    const write = options.write ?? ((message) => void process.stderr.write(message));
-    write(`Update available: sim ${currentVersion} → ${latest}. Run: ${upgradeCommand(modulePath, env)}
-`);
-  } catch {}
+  }
+  return {
+    observe(program) {
+      program.hook("preAction", (_root, action) => {
+        const path = commandPath2(action);
+        if (path[0] === EXCLUDED_ROOT_COMMAND || !isReportable({}))
+          return;
+        const state = loadTelemetryState();
+        if (!isReportable(state))
+          return;
+        recorded = {
+          action,
+          command: path.join(" "),
+          flags: typedFlags(action),
+          argCount: action.args.length,
+          state,
+          noticeShown: showNoticeIfDue(state)
+        };
+      });
+      onExit((exitCode) => complete({ exitCode }));
+    },
+    complete
+  };
+}
+// src/commands/telemetry.ts
+function describe(status) {
+  if (status.enabled)
+    return "Usage reporting is on.";
+  switch (status.reason) {
+    case "do_not_track":
+      return `Usage reporting is off: ${DO_NOT_TRACK_VARIABLE} is set.`;
+    case "environment":
+      return `Usage reporting is off: ${TELEMETRY_DISABLED_VARIABLE} is set.`;
+    case "setting":
+      return "Usage reporting is off. Turn it on with: sim telemetry enable";
+    case "unconfigured":
+      return "Usage reporting is off: this build has no reporting destination.";
+  }
+}
+function currentStatus() {
+  return telemetryStatus({
+    env: process.env,
+    state: loadTelemetryState(),
+    configured: builtInIngestTarget() !== undefined
+  });
+}
+function setEnabled(enabled) {
+  writeTelemetryState({ ...loadTelemetryState(), enabled });
+  console.log(describe(currentStatus()));
+}
+function telemetryCommand() {
+  const telemetry = new Command("telemetry").description("Control anonymous usage reporting");
+  telemetry.command("status").description("Show whether usage reporting is on, and why not if it is off").action(() => {
+    console.log(describe(currentStatus()));
+    console.log(`Learn more: ${USAGE_DATA_DOCS_URL}`);
+  });
+  telemetry.command("enable").description("Turn usage reporting on for this machine").action(() => setEnabled(true));
+  telemetry.command("disable").description("Turn usage reporting off for this machine").action(() => setEnabled(false));
+  return telemetry;
 }
 
 // src/program.ts
@@ -20497,6 +21133,9 @@ function buildProgram(options = {}) {
   program.addCommand(whoamiCommand());
   program.addCommand(profilesCommand());
   program.addCommand(configureCommand());
+  const update = updateCommand();
+  program.addCommand(update);
+  program.addCommand(telemetryCommand());
   for (const command of buildGeneratedCommands()) {
     program.addCommand(command);
   }
@@ -20504,54 +21143,67 @@ function buildProgram(options = {}) {
   attachProtocolCommands(program);
   attachSecretCommands(program);
   program.addHelpText("after", HELP_EPILOGUE);
-  program.hook("preAction", () => announceUpdateIfAvailable());
+  program.hook("preAction", async (_program, command) => {
+    if (command === update)
+      return;
+    await announceUpdateIfAvailable();
+  });
   refuseHelpAfterUnknownCommand(program);
   assertNoReservedProgramFlags(program);
   return program;
 }
 
 // src/index.ts
+function explainFailure(error, program) {
+  if (error instanceof ProfileConfigError || error instanceof CliUpdateError) {
+    console.error(source_default.red(`Error: ${sanitize(error.message)}`));
+    return 1;
+  }
+  if (isRequestTimeout(error)) {
+    console.error(source_default.red(`Error: the request timed out. ${RAISE_TIMEOUT_HINT}`));
+    return 1;
+  }
+  if (error instanceof SimApiError) {
+    let output = program.opts().output;
+    try {
+      output = clientFrom(program).profile.output;
+    } catch {}
+    if (output === "json" || output === "yaml") {
+      const payload = {
+        error: {
+          code: error.code ?? "CLI_ERROR",
+          message: error.message,
+          ...error.details === undefined ? {} : { details: error.details }
+        }
+      };
+      process.stderr.write(output === "json" ? `${JSON.stringify(payload)}
+` : dump(payload));
+      return error.exitCode;
+    }
+    console.error(source_default.red(`Error: ${sanitize(error.message)}`));
+    if (error.code)
+      console.error(source_default.dim(`  code: ${sanitize(error.code)}`));
+    if (error.details !== undefined) {
+      for (const line of formatApiErrorDetails(error.details)) {
+        console.error(source_default.dim(sanitize(line)));
+      }
+    }
+    return error.exitCode;
+  }
+  return null;
+}
 async function main() {
+  const telemetry = createCommandTelemetry();
   const program = buildProgram();
+  telemetry.observe(program);
   try {
     await program.parseAsync(process.argv);
   } catch (error) {
-    if (error instanceof ProfileConfigError) {
-      console.error(source_default.red(`Error: ${sanitize(error.message)}`));
-      process.exit(1);
-    }
-    if (isRequestTimeout(error)) {
-      console.error(source_default.red(`Error: the request timed out. ${RAISE_TIMEOUT_HINT}`));
-      process.exit(1);
-    }
-    if (error instanceof SimApiError) {
-      let output = program.opts().output;
-      try {
-        output = clientFrom(program).profile.output;
-      } catch {}
-      if (output === "json" || output === "yaml") {
-        const payload = {
-          error: {
-            code: error.code ?? "CLI_ERROR",
-            message: error.message,
-            ...error.details === undefined ? {} : { details: error.details }
-          }
-        };
-        process.stderr.write(output === "json" ? `${JSON.stringify(payload)}
-` : dump(payload));
-        process.exit(error.exitCode);
-      }
-      console.error(source_default.red(`Error: ${sanitize(error.message)}`));
-      if (error.code)
-        console.error(source_default.dim(`  code: ${sanitize(error.code)}`));
-      if (error.details !== undefined) {
-        for (const line of formatApiErrorDetails(error.details)) {
-          console.error(source_default.dim(sanitize(line)));
-        }
-      }
-      process.exit(error.exitCode);
-    }
-    throw error;
+    const exitCode = explainFailure(error, program);
+    telemetry.complete({ exitCode: exitCode ?? 1, error });
+    if (exitCode === null)
+      throw error;
+    process.exit(exitCode);
   }
 }
 main();