sim 2.1.14-preview.116.1 → 2.1.14

package/README.md

@@ -317,6 +317,7 @@ The main environment variables are:
 | `SIM_TIMEOUT_SECONDS` | Per-request timeout; `0` waits indefinitely |
 | `SIM_DEBUG` | Print request diagnostics to stderr |
 | `SIM_NO_UPDATE_CHECK` | Turn off update notices |
+| `SIM_TELEMETRY_DISABLED` | Turn off anonymous usage reporting (`DO_NOT_TRACK=1` also works) |
 
 On eligible interactive invocations, `sim` uses a daily cache before asking
 `registry.npmjs.org` what is published under the `latest` tag and prints an
@@ -334,6 +335,22 @@ use the public default; non-empty malformed or non-HTTP(S) values fail closed.
 The full list of cases where it stays quiet is in the
 [configuration guide](https://docs.sim.ai/cli/configuration).
 
+## Usage data
+
+The CLI reports anonymous usage data — which commands run, whether they
+succeed, and how long they take — so the team can see how it is used. Nothing
+you type is sent: no argument or flag values, paths, ids, error messages, or
+credentials. The first interactive run prints a notice and is not reported.
+
+```bash
+sim telemetry status
+sim telemetry disable
+```
+
+`DO_NOT_TRACK=1` or `SIM_TELEMETRY_DISABLED=1` in the environment also turns it
+off. The full description of what is sent is in the
+[usage data guide](https://docs.sim.ai/cli/usage-data).
+
 ## Documentation
 
 - [CLI documentation](https://docs.sim.ai/cli)
@@ -342,6 +359,7 @@ The full list of cases where it stays quiet is in the
 - [Profiles and configuration](https://docs.sim.ai/cli/configuration)
 - [Scripting](https://docs.sim.ai/cli/scripting)
 - [Troubleshooting](https://docs.sim.ai/cli/troubleshooting)
+- [Usage data](https://docs.sim.ai/cli/usage-data)
 
 ## License
 

package/dist/index.js

@@ -6976,6 +6976,9 @@ 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,
@@ -6989,7 +6992,64 @@ import {
   writeFileSync
 } from "node:fs";
 import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+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";
@@ -7006,6 +7066,39 @@ function credentialsPath() {
 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";
@@ -7042,21 +7135,7 @@ function isNewerVersion(candidate, current) {
     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/");
@@ -7125,20 +7204,10 @@ try {
   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 = spawn(process.execPath, [...proxyArguments, "--input-type=module", "--eval", REGISTRY_REQUEST_SCRIPT], {
-      env: registryProcessEnv(),
+    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,
@@ -7194,73 +7263,18 @@ async function fetchDistTags(env, request) {
   }
 }
 function readCache(path) {
-  let descriptor = null;
-  try {
-    if (!lstatSync(path).isFile())
-      return null;
-    descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
-    const descriptorStats = fstatSync(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 = readSync(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 {
+  const parsed = readJsonFile(path, MAX_CACHE_BYTES);
+  if (typeof parsed !== "object" || parsed === null)
     return null;
-  } finally {
-    if (descriptor !== null) {
-      try {
-        closeSync(descriptor);
-      } catch {}
-    }
-  }
+  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) {
-  let descriptor = null;
-  let temporaryCreated = false;
-  const temporaryPath = `${path}.${process.pid}.${Date.now()}.${cacheWriteSequence++}.tmp`;
-  try {
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
-    descriptor = openSync(temporaryPath, "wx", 420);
-    temporaryCreated = true;
-    writeFileSync(descriptor, `${JSON.stringify(entry, 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 {}
-    }
-  }
+  writeJsonFile(path, entry);
 }
 function isFresh(entry, now) {
   const age = now.getTime() - Date.parse(entry.checkedAt);
@@ -7297,7 +7311,7 @@ async function announceUpdateIfAvailable(options = {}) {
       return;
     if (!isTty)
       return;
-    if (CI_VARIABLES.some((variable) => isEnabled(env[variable])))
+    if (isCi(env))
       return;
     if (isUnadvisableInstall(modulePath, env, cwd))
       return;
@@ -8007,6 +8021,191 @@ function resolveProfile(overrides = {}) {
     }
   };
 }
+// ../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;
+}
+
 // src/http/environment.ts
 var reported = new Set;
 function once(key, message) {
@@ -8345,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
         },
@@ -20626,6 +20826,239 @@ function attachSecretCommands(program) {
   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, body, timeoutMs } = JSON.parse(process.env[${JSON.stringify(PAYLOAD_VARIABLE)}])
+  const deadline = setTimeout(() => process.exit(1), timeoutMs)
+  await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body,
+    redirect: 'error',
+  })
+  clearTimeout(deadline)
+  process.exit(0)
+} catch {
+  process.exit(1)
+}
+`;
+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
+  });
+  try {
+    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
+    });
+    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 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 endpointKind(command) {
+  try {
+    const hostname = new URL(profileFrom(command).endpoint).hostname;
+    return hostname === "sim.ai" || hostname.endsWith(".sim.ai") ? "hosted" : "self_hosted";
+  } catch {
+    return;
+  }
+}
+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;
+  }
+  function complete(outcome) {
+    const invocation = recorded;
+    recorded = undefined;
+    if (!invocation || invocation.noticeShown)
+      return;
+    const target = ingestTarget();
+    if (!target)
+      return;
+    const state = loadTelemetryState();
+    if (!isReportable(state))
+      return;
+    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
+    });
+  }
+  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
 var PROGRAM_DESCRIPTION = "Talk to the Sim API from your terminal";
@@ -20702,6 +21135,7 @@ function buildProgram(options = {}) {
   program.addCommand(configureCommand());
   const update = updateCommand();
   program.addCommand(update);
+  program.addCommand(telemetryCommand());
   for (const command of buildGeneratedCommands()) {
     program.addCommand(command);
   }
@@ -20720,47 +21154,56 @@ function buildProgram(options = {}) {
 }
 
 // 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 || error instanceof CliUpdateError) {
-      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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim",
-  "version": "2.1.14-preview.116.1",
+  "version": "2.1.14",
   "description": "Sim CLI - talk to the Sim API from your terminal",
   "type": "module",
   "imports": {
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "prebuild": "bun run clean",
-    "build": "bun build src/index.ts --target=node --format=esm --packages=bundle --reject-unresolved --outfile=dist/index.js",
+    "build": "bun build src/index.ts --target=node --format=esm --packages=bundle --reject-unresolved --env='SIM_CLI_TELEMETRY_*' --outfile=dist/index.js",
     "clean": "bun -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
     "type-check": "tsc --noEmit",
     "lint": "biome check --write --unsafe .",