@odla-ai/cli 0.44.0 → 0.45.0

package/dist/cli-2FTL245Y.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  runCli
+} from "./chunk-JHB6352A.js";
+import {
+  exitCodeFor
+} from "./chunk-5MEO3BVF.js";
+export {
+  exitCodeFor,
+  runCli
+};
+//# sourceMappingURL=cli-2FTL245Y.js.map

package/dist/index.cjs

@@ -11430,9 +11430,17 @@ Safety:
   grant, run it once with --request-grant. That flag ignores ODLA_DEV_TOKEN and
   the local cache, prints and opens a fresh exact-project owner-review URL, then
   continues provisioning with the approved replacement credential.
-  Before a non-dry-run provision, the executable checks npm's current CLI
-  release. A confirmed stale client stops with a safe npx rerun command; a
-  workspace-linked client also identifies the worktree that must be updated.
+  Every command says so on STDERR when this CLI is older than the one npm
+  serves, naming the repair for how this executable was launched \u2014 rebuild the
+  worktree, npm i the dependency, or npx the scoped package. The answer is read
+  from a cache under ~/.odla refreshed in the background at most every three
+  hours, so no invocation waits on the registry and stdout is never touched.
+  Set ODLA_CLI_UPDATE_CHECK=0 to switch it off.
+  Before a non-dry-run provision, the executable additionally checks npm LIVE
+  rather than trusting that cache: a security-sensitive grant shape must not
+  ride on a three-hour-old answer. A confirmed stale client stops with a safe
+  npx rerun command; a workspace-linked client also identifies the worktree
+  that must be updated.
   Run Code from a GitHub checkout already connected to an app in Studio; an
   odla.config.mjs may select the app explicitly but is not required. With an
   enrolled code.session device, the Studio repository selection authorizes the
@@ -16108,6 +16116,87 @@ async function securityStatus(parsed, dependencies) {
   }
 }
 
+// src/update-notice.ts
+var import_node_child_process8 = require("child_process");
+var import_node_fs24 = require("fs");
+var import_node_path23 = require("path");
+var import_node_process21 = __toESM(require("process"), 1);
+var REGISTRY_URL = "https://registry.npmjs.org/@odla-ai%2fcli/latest";
+var INTERVAL_MS = 3 * 60 * 60 * 1e3;
+var VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+var refreshScheduled = false;
+function updateCacheFile(env) {
+  return odlaHomePath(["cli-update.json"], env);
+}
+function readUpdateCache(path) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs24.readFileSync)(path, "utf8"));
+    if (typeof parsed.latest !== "string" || !VERSION.test(parsed.latest)) return null;
+    if (typeof parsed.checkedAt !== "number") return null;
+    return { latest: parsed.latest, checkedAt: parsed.checkedAt };
+  } catch {
+    return null;
+  }
+}
+function updateNotice(options = {}) {
+  const env = options.env ?? import_node_process21.default.env;
+  if (env.ODLA_CLI_UPDATE_CHECK === "0") return null;
+  const current = options.currentVersion ?? cliVersion();
+  if (!VERSION.test(current)) return null;
+  const path = updateCacheFile(env);
+  const cache2 = readUpdateCache(path);
+  const now = options.now ?? Date.now();
+  if ((!cache2 || now - cache2.checkedAt > INTERVAL_MS) && !refreshScheduled) {
+    refreshScheduled = true;
+    (options.refresh ?? spawnRefresh)(path, env.ODLA_CLI_REGISTRY_URL ?? REGISTRY_URL);
+  }
+  if (!cache2 || compareVersions(current, cache2.latest) >= 0) return null;
+  return renderNotice(current, cache2.latest, options.entryPath ?? import_node_process21.default.argv[1]);
+}
+function renderNotice(current, latest, entryPath) {
+  const resolved = resolvedEntryPath(entryPath);
+  const behindMajor = Number(latest.split(".")[0]) > Number(current.split(".")[0]);
+  const repair = isWorkspaceCli(resolved) ? `this is the workspace build at ${resolved} \u2014 rebase that worktree and rebuild it` : resolved.includes("/_npx/") ? `run npx --yes @odla-ai/cli@${latest} <command>` : `run npm i @odla-ai/cli@${latest}`;
+  const severity = behindMajor ? "a MAJOR version behind, so commands and flags this version has may no longer exist" : "behind";
+  return `odla-ai: ${current} is ${severity}; npm serves ${latest}. To update, ${repair}.`;
+}
+function spawnRefresh(cachePath, registryUrl) {
+  const script = `
+    const {mkdirSync,writeFileSync}=require("node:fs");
+    const {dirname}=require("node:path");
+    const [path,url]=process.argv.slice(1);
+    const done=setTimeout(()=>process.exit(0),5000); done.unref();
+    fetch(url,{headers:{accept:"application/vnd.npm.install-v1+json"}})
+      .then(r=>r.ok?r.json():null)
+      .then(b=>{
+        const v=b&&b.version;
+        if (typeof v!=="string"||!/^\\d+\\.\\d+\\.\\d+/.test(v)) return;
+        mkdirSync(dirname(path),{recursive:true});
+        writeFileSync(path,JSON.stringify({latest:v,checkedAt:Date.now()}));
+      })
+      .catch(()=>{});
+  `;
+  try {
+    (0, import_node_child_process8.spawn)(import_node_process21.default.execPath, ["-e", script, cachePath, registryUrl], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  } catch {
+  }
+}
+function resolvedEntryPath(entryPath) {
+  if (!entryPath) return "unknown executable";
+  try {
+    return (0, import_node_fs24.realpathSync)(entryPath);
+  } catch {
+    return entryPath;
+  }
+}
+function isWorkspaceCli(entryPath) {
+  const normalized = entryPath.replaceAll("\\", "/");
+  return /\/packages\/cli\/(dist|bin)\//.test(normalized) && !normalized.includes("/node_modules/");
+}
+
 // src/exit-code.ts
 function exitCodeFor(err) {
   const code = err?.code;
@@ -16135,6 +16224,11 @@ async function runCli(argv = process.argv.slice(2), dependencies = {}) {
     throw error;
   } finally {
     renderAdvisories(out, advisories);
+    try {
+      const behind = updateNotice();
+      if (behind) out.error(behind);
+    } catch {
+    }
   }
 }
 async function dispatchCli(argv, dependencies) {