sim 2.1.6-preview.83.1 → 2.1.6-preview.89.1

package/README.md

@@ -256,9 +256,26 @@ The main environment variables are:
 | `SIM_API_KEY` | API key, usually for CI |
 | `SIM_WORKSPACE` | Workspace to target |
 | `SIM_OUTPUT` | `table`, `json`, `yaml`, or `text` |
-| `SIM_CONFIG_DIR` | Directory containing CLI config and credentials |
+| `SIM_CONFIG_DIR` | Base directory for CLI config, credentials, and the update cache |
 | `SIM_TIMEOUT_SECONDS` | Per-request timeout; `0` waits indefinitely |
 | `SIM_DEBUG` | Print request diagnostics to stderr |
+| `SIM_NO_UPDATE_CHECK` | Turn off the update notice |
+
+On eligible interactive invocations, `sim` uses a daily cache before asking
+`registry.npmjs.org` what is published under the `latest` tag and prints one
+line on stderr when a newer version exists. Prerelease installs are skipped
+entirely. The cache lives in `~/.sim` by default and follows `SIM_CONFIG_DIR`;
+without a writable cache, each eligible invocation checks again. Concurrent
+invocations can also perform duplicate checks. The registry request has a
+one-second deadline; the short-lived request process is terminated on expiry.
+Apart from the configured registry URL, it sends only its own version and never
+your Sim API key. If `npm_config_registry` points at a private mirror, its query
+string is preserved, including any query-string credentials. Registry URLs
+containing username/password userinfo are rejected. Set
+`SIM_NO_UPDATE_CHECK=1` to turn it off. Empty or whitespace-only registry values
+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).
 
 ## Documentation
 

package/dist/index.js

@@ -2310,6 +2310,9 @@ function configPath() {
 function credentialsPath() {
   return process.env.SIM_CREDENTIALS_FILE || join(configDir(), "credentials");
 }
+function updateCachePath() {
+  return join(configDir(), "update-check.json");
+}
 // src/config/profile.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
@@ -8263,6 +8266,22 @@ var V2_OPERATIONS = {
       }
     }
   },
+  editFileContent: {
+    method: "PATCH",
+    path: "/api/v2/files/[fileId]/content",
+    pathParams: ["fileId"],
+    pathParamDocs: { fileId: "File identifier." },
+    responseMode: "json",
+    summary: "Edit File Content",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the file." },
+      edit: {
+        kind: "unknown",
+        required: true,
+        describe: "One exact or anchor-based edit: search_replace, replace_between, insert_after, or delete_between."
+      }
+    }
+  },
   executeTool: {
     method: "POST",
     path: "/api/v2/tools/[toolId]/execute",
@@ -9263,6 +9282,28 @@ var V2_OPERATIONS = {
         values: ["active", "archived"],
         default: "active",
         describe: "Which lifecycle set to list: `active` (default) returns live folders only; `archived` returns folders a recursive delete soft-deleted, which is how a caller finds a path to hand to the folder restore. Authorization is identical for both."
+      },
+      recursive: {
+        kind: "enum",
+        values: [
+          "true",
+          "1",
+          "yes",
+          "on",
+          "y",
+          "enabled",
+          "false",
+          "0",
+          "no",
+          "off",
+          "n",
+          "disabled"
+        ],
+        describe: "Whether parentPath includes every descendant instead of direct children only."
+      },
+      depth: {
+        kind: "integer",
+        describe: "Deepest level below parentPath to include when recursive is true."
       }
     }
   },
@@ -10440,6 +10481,14 @@ var V2_OPERATIONS = {
       maxBytes: {
         kind: "integer",
         describe: "Optional ceiling on the source bytes fed to the parser, lowering but never raising the server limit."
+      },
+      offset: {
+        kind: "integer",
+        describe: "First line to return, 1-based. Absent starts at the first line."
+      },
+      limit: {
+        kind: "integer",
+        describe: "How many lines to return from `offset`. Absent reads to the end."
       }
     }
   },
@@ -10770,6 +10819,50 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." }
     }
   },
+  searchFileContent: {
+    method: "GET",
+    path: "/api/v2/files/search",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Search File Content",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace to search." },
+      query: {
+        kind: "string",
+        required: true,
+        describe: "Regular expression, or exact text when `mode` is `exact`."
+      },
+      mode: {
+        kind: "enum",
+        values: ["exact", "regex"],
+        default: "regex",
+        describe: "How `query` is read."
+      },
+      maxResults: { kind: "integer", default: 50, describe: "Maximum matching lines to return." },
+      folderPaths: {
+        kind: "string",
+        describe: "Folders the search is confined to, comma-separated. Absent searches the whole workspace. The scope also narrows `indexStatus`, so `complete` describes the folders searched rather than the workspace."
+      },
+      includeSubfolders: {
+        kind: "enum",
+        values: [
+          "true",
+          "1",
+          "yes",
+          "on",
+          "y",
+          "enabled",
+          "false",
+          "0",
+          "no",
+          "off",
+          "n",
+          "disabled"
+        ],
+        describe: "Whether the scope descends into nested folders. Absent means yes. The listed spellings are the whole accepted vocabulary and are case-sensitive; any other value is rejected."
+      }
+    }
+  },
   searchKnowledge: {
     method: "POST",
     path: "/api/v2/knowledge/search",
@@ -12019,6 +12112,7 @@ var TABLE_SORT_HELP = 'Ordered sort keys: [{"field":"createdAt","direction":"des
 var KNOWLEDGE_TAG_DEFINITIONS_HELP = 'Tag definitions: [{"tagSlot":"tag1","displayName":"category","fieldType":"text"}]';
 var CUSTOM_TOOL_SCHEMA_HELP = 'OpenAI function schema: {"type":"function","function":{"name":"...","parameters":{"type":"object","properties":{}}}}';
 var DISPATCH_ROW_LIMIT_HELP = "Stop after this many eligible rows have run (1-1,000,000). Omit for an unbounded run";
+var FILE_EDIT_HELP = 'One edit object: {"mode":"search_replace","search":"old","content":"new","replaceAll":false}, {"mode":"replace_between","beforeAnchor":"start line","afterAnchor":"end line","content":"new"}, {"mode":"insert_after","anchor":"line","content":"new"}, or {"mode":"delete_between","startAnchor":"first line deleted","endAnchor":"ending line kept"}. Anchored modes also accept occurrence starting at 1';
 var WORKFLOW_OPERATIONS_HELP = 'Edits to apply, in a single batch, keyed by operation_type: [{"operation_type":"add","block_id":"my-fn","params":{"type":"function","name":"My Fn","inputs":{"code":"return {ok:true}"}}},{"operation_type":"edit","block_id":"<uuid>","params":{"name":"Renamed","connections":{"success":"my-fn"}}},{"operation_type":"delete","block_id":"<uuid>"}]. Also extract_from_subflow, whose params carry {"subflowId":"<loop-id>"}, and insert_into_subflow, which creates a block and so takes an add’s params plus that subflowId';
 var WORKFLOW_SET_BLOCK_ENABLED_HELP = 'Blocks to enable or disable, applied after --operations: [{"block_id":"<uuid>","enabled":false}]. Disabling a loop or parallel cascades to its unlocked descendants; enabling a block whose container is disabled is declined';
 var WORKFLOW_VARIABLE_OPERATIONS_HELP = 'Variable changes to apply in order, keyed by operation: [{"operation":"add","name":"my_var","type":"string","value":"hello"},{"operation":"edit","name":"my_var","value":"updated"},{"operation":"delete","name":"my_var"}]';
@@ -12399,6 +12493,25 @@ var CLI_CONTRACT = {
     flags: { folderPaths: FOLDER_PATHS_FLAG },
     confirm: "This deletes every listed table and all of their rows."
   },
+  searchFileContent: {
+    flags: {
+      folderPaths: {
+        ...FOLDER_PATHS_FLAG,
+        describe: "Folders to search, by path as shown in the app; omit to search the whole workspace"
+      },
+      includeSubfolders: {
+        boolean: true,
+        negatable: true,
+        describe: "Whether each folder scope includes nested folders; on by default"
+      }
+    },
+    itemsPath: "results",
+    columns: [
+      { header: "file", path: "fileId" },
+      { header: "line", path: "lineNumber" },
+      { header: "text" }
+    ]
+  },
   searchKnowledge: {
     flags: {
       knowledgeBaseIds: { name: "kb", list: true, describe: "Knowledge base ID (repeatable)" },
@@ -12818,6 +12931,13 @@ var CLI_CONTRACT = {
       folderPaths: FOLDER_PATHS_FLAG
     }
   },
+  editFileContent: {
+    command: "files edit",
+    describe: "Apply one exact or anchor-based edit to a text file",
+    flags: {
+      edit: { describe: FILE_EDIT_HELP }
+    }
+  },
   updateFileContent: {
     command: "files set-content",
     describe: "Replace a file’s contents",
@@ -13531,7 +13651,7 @@ function withoutWireVocabulary(documented) {
   return documented.replace(WIRE_VOCABULARY_SENTENCE, " ").trim();
 }
 var NON_PAGINATED_LIMIT_HINT = " (caps a --filter match only; omit it to act on every match, and note 0 is not accepted)";
-function addFieldOption(command, operation, field, descriptor, slot, paginates) {
+function addFieldOption(command, operation, field, descriptor, slot, paginates, capsAFilter) {
   if (field === PROFILE_INJECTED_FIELD || field === "cursor")
     return;
   const flag = flagSpecFor(operation, field);
@@ -13543,7 +13663,7 @@ function addFieldOption(command, operation, field, descriptor, slot, paginates)
     command.option("--limit <n>", "Maximum items to return (0 for everything)", String(DEFAULT_LIMIT));
     return;
   }
-  const documented = `${describeField(flag, descriptor, name, field)}${field === "limit" && (descriptor.kind === "number" || descriptor.kind === "integer") ? NON_PAGINATED_LIMIT_HINT : ""}`;
+  const documented = `${describeField(flag, descriptor, name, field)}${capsAFilter && field === "limit" && (descriptor.kind === "number" || descriptor.kind === "integer") ? NON_PAGINATED_LIMIT_HINT : ""}`;
   if (descriptor.kind === "boolean" || flag.boolean) {
     const booleanDoc = withoutWireVocabulary(documented);
     if (descriptor.required) {
@@ -13591,13 +13711,14 @@ function addOperationOptions(command, operation, commandSpec, operationSpec) {
     command.addOption(new Option(`${short}--${name} <${flag.placeholder ?? "value"}>`, `${flag.describe ?? operationSpec.pathParamDocs?.[param] ?? `Set ${name.replaceAll("-", " ")}`} (required)`).makeOptionMandatory());
   }
   const paginates = cursorSlot(operationSpec) !== null;
+  const capsAFilter = ["query", "body", "headers"].some((slot) => operationSpec[slot] !== undefined && ("filter" in operationSpec[slot]));
   for (const slot of ["query", "body", "headers"]) {
     for (const [field, descriptor] of Object.entries(operationSpec[slot] ?? {})) {
       if (commandSpec.requestFields && !commandSpec.requestFields.includes(field))
         continue;
       if (commandSpec.positionals?.includes(field))
         continue;
-      addFieldOption(command, operation, field, descriptor, slot, paginates);
+      addFieldOption(command, operation, field, descriptor, slot, paginates, capsAFilter);
     }
   }
   if (commandSpec.allWorkspaces) {
@@ -16336,6 +16457,328 @@ function attachSecretCommands(program2) {
   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,
+  constants as constants2,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readSync as readSync2,
+  renameSync,
+  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, env2, cwd) {
+  const normalized = normalizeModulePath(modulePath);
+  return env2.npm_command === "exec" || normalized.includes("/_npx/") || normalized.includes("/packages/sim-cli/") || isProjectLocalInstall(modulePath, cwd);
+}
+function normalizeModulePath(modulePath) {
+  return modulePath.replace(/\\/g, "/").toLowerCase();
+}
+function registryUrl(env2) {
+  const fallback = new URL(DIST_TAGS_PATH, DEFAULT_REGISTRY);
+  const configured = env2.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 registryProcessEnv() {
+  const env2 = { ...process.env };
+  for (const key of Object.keys(env2)) {
+    const normalized = key.toLowerCase();
+    if (normalized === "npm_config_registry" || normalized === "sim_api_key")
+      delete env2[key];
+  }
+  return env2;
+}
+function requestRegistry(url, { headers, maxResponseBytes, timeoutMs }) {
+  return new Promise((resolve3, 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) => {
+      resolve3(code === 0 && !failed ? Buffer.concat(chunks).toString("utf8") : null);
+    });
+    child.stdin.end(JSON.stringify({ headers, maxResponseBytes, timeoutMs, url: url.href }));
+  });
+}
+async function fetchDistTags(env2, request) {
+  try {
+    const url = registryUrl(env2);
+    if (!url)
+      return null;
+    const text2 = await request(url, {
+      headers: { accept: "application/json", "user-agent": `${PACKAGE_NAME}-cli/${CLI_VERSION}` },
+      maxResponseBytes: MAX_RESPONSE_BYTES,
+      timeoutMs: REGISTRY_TIMEOUT_MS
+    });
+    if (text2 === null || Buffer.byteLength(text2) > MAX_RESPONSE_BYTES)
+      return null;
+    const body = JSON.parse(text2);
+    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) {
+  let descriptor = null;
+  try {
+    if (!lstatSync(path).isFile())
+      return null;
+    descriptor = openSync(path, constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.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 = 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 {
+        closeSync(descriptor);
+      } catch {}
+    }
+  }
+}
+function writeCache(path, entry) {
+  let descriptor = null;
+  let temporaryCreated = false;
+  const temporaryPath = `${path}.${process.pid}.${Date.now()}.${cacheWriteSequence++}.tmp`;
+  try {
+    mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
+    descriptor = openSync(temporaryPath, "wx", 420);
+    temporaryCreated = true;
+    writeFileSync2(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 {}
+    }
+  }
+}
+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), env2 = 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 = env2.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 env2 = 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(env2.SIM_NO_UPDATE_CHECK))
+      return;
+    if (!isTty)
+      return;
+    if (CI_VARIABLES.some((variable) => isEnabled(env2[variable])))
+      return;
+    if (isUnadvisableInstall(modulePath, env2, 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(env2, 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: ${upgradeCommand(modulePath, env2)}
+`);
+  } catch {}
+}
+
 // src/program.ts
 var PROGRAM_DESCRIPTION = "Talk to the Sim API from your terminal";
 var HELP_EPILOGUE = `
@@ -16415,6 +16858,7 @@ function buildProgram(options = {}) {
   attachProtocolCommands(program2);
   attachSecretCommands(program2);
   program2.addHelpText("after", HELP_EPILOGUE);
+  program2.hook("preAction", () => announceUpdateIfAvailable());
   refuseHelpAfterUnknownCommand(program2);
   assertNoReservedProgramFlags(program2);
   return program2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim",
-  "version": "2.1.6-preview.83.1",
+  "version": "2.1.6-preview.89.1",
   "description": "Sim CLI - talk to the Sim API from your terminal",
   "type": "module",
   "bin": {