@tuned-tensor/cli 0.22.0 → 0.22.1

package/README.md

@@ -72,7 +72,7 @@ npm install -g --ignore-scripts @tuned-tensor/cli
 tt --version
 ```
 
-Uninstall with `npm uninstall -g @tuned-tensor/cli` (add
+Upgrade later with `tt upgrade`. Uninstall with `npm uninstall -g @tuned-tensor/cli` (add
 `--prefix ~/.local` if the curl installer used that prefix).
 
 Node.js 22.19.0 or newer is required. Training additionally needs
@@ -156,10 +156,19 @@ catalog providers remain available by ID. Unauthenticated entries are marked
 `auth required`. Local endpoints such as Ollama use a placeholder `apiKey` in
 `models.json` and need no TT account.
 
-Before the shell opens, `tt` performs a short, non-blocking npm version check.
-If a newer stable release is available it recommends
-`npm install -g @tuned-tensor/cli@latest`; offline or unavailable registry
-checks are ignored.
+`tt` checks npm for a newer stable release at most every 12 hours and
+remembers the answer in `~/.tuned-tensor/update-check.json`. The notice appears
+when the shell opens and after commands run in a terminal; explicit commands
+never wait on the registry. Upgrade with:
+
+```bash
+tt upgrade            # latest stable, into the same npm prefix tt runs from
+tt upgrade --check    # only report
+tt upgrade beta       # or a specific version
+```
+
+Offline or unavailable registry checks are ignored. `CI`, `TT_NO_UPDATE_CHECK=1`
+or `NO_UPDATE_NOTIFIER=1` disable the check.
 
 After a model is selected, the banner shows it and ordinary sentences go to
 the agent:

package/dist/{chunk-4SUXBHIY.js → chunk-RPWOCVIL.js}

@@ -7768,6 +7768,7 @@ export {
   DEFAULT_FOUNDATION_RUNS_DIR,
   DEFAULT_DECISION_RUNS_DIR,
   expandUserPath,
+  getTunedTensorHome,
   getConfigDir,
   getAgentConfigDir,
   defaultStoreRoot,
@@ -7896,4 +7897,4 @@ export {
   assessHardware,
   createRunConsoleReporter
 };
-//# sourceMappingURL=chunk-4SUXBHIY.js.map
+//# sourceMappingURL=chunk-RPWOCVIL.js.map

package/dist/index.js

@@ -33,6 +33,7 @@ import {
   formatHostStatusLine,
   getAgentConfigDir,
   getConfigDir,
+  getTunedTensorHome,
   hardenExistingLocalStore,
   isFoundationPipeline,
   loadLocalRunInput,
@@ -58,13 +59,13 @@ import {
   warningsFromSnapshot,
   withDecisionPythonEnvironment,
   withFoundationPythonEnvironment
-} from "./chunk-4SUXBHIY.js";
+} from "./chunk-RPWOCVIL.js";
 
 // src/cli.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { constants as osConstants2 } from "os";
 import { Command } from "commander";
-import chalk13 from "chalk";
+import chalk15 from "chalk";
 
 // src/local-agent-client.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -4127,6 +4128,7 @@ var COMMAND_CATALOG = [
   { path: "models rollback", description: "Roll back the active local model.", group: "Serving", modes: LOCAL },
   { path: "serve", description: "Serve a local adapter, active model, or base model.", group: "Serving", modes: LOCAL },
   { path: "info", description: "Show local runtime package information.", group: "Inspect", modes: LOCAL },
+  { path: "upgrade", description: "Upgrade tt to the latest release.", group: "Inspect", modes: LOCAL },
   { path: "status", description: "Show local project context.", group: "Inspect", modes: LOCAL },
   { path: "agent models", description: "List provider models for the laptop-local TT agent.", group: "Inspect", modes: LOCAL },
   { path: "agent configure", description: "Select the laptop-local TT agent model.", group: "Inspect", modes: LOCAL },
@@ -12385,8 +12387,20 @@ function registerUsageCommand(parent) {
   });
 }
 
+// src/commands/upgrade.ts
+import { spawn as spawn5 } from "child_process";
+import { accessSync, constants as constants3, existsSync as existsSync10, readFileSync as readFileSync15, realpathSync } from "fs";
+import { dirname as dirname13, join as join17 } from "path";
+import chalk14 from "chalk";
+
 // src/update-check.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname12, join as join16 } from "path";
+import chalk13 from "chalk";
+var CLI_PACKAGE_NAME = "@tuned-tensor/cli";
 var PACKAGE_LATEST_URL = "https://registry.npmjs.org/@tuned-tensor%2fcli/latest";
+var DEFAULT_CACHE_MAX_AGE_MS = 12 * 60 * 60 * 1e3;
 function parseVersion(version) {
   const match = version.trim().match(
     /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/
@@ -12430,11 +12444,50 @@ function compareVersions(left, right) {
   }
   return comparePrerelease(left.prerelease, right.prerelease);
 }
-async function checkForCliUpdate(currentVersion, options = {}) {
+function getCliUpdateCacheFile(env = process.env) {
+  return join16(getTunedTensorHome(env), "update-check.json");
+}
+function cliUpdateChecksDisabled(env = process.env) {
+  return [env.TT_NO_UPDATE_CHECK, env.NO_UPDATE_NOTIFIER, env.CI].some((value) => value !== void 0 && value !== "" && value !== "0" && value !== "false");
+}
+function readUpdateCache(file) {
+  try {
+    const payload = JSON.parse(readFileSync14(file, "utf8"));
+    if (typeof payload.checkedAt !== "number" || typeof payload.latestVersion !== "string" || !parseVersion(payload.latestVersion)) return null;
+    return { checkedAt: payload.checkedAt, latestVersion: payload.latestVersion };
+  } catch {
+    return null;
+  }
+}
+function writeUpdateCache(file, cache) {
+  try {
+    mkdirSync5(dirname12(file), { recursive: true });
+    writeFileSync7(file, `${JSON.stringify(cache)}
+`);
+  } catch {
+  }
+}
+function recordLatestCliVersion(cacheFile, latestVersion, now = Date.now()) {
+  writeUpdateCache(cacheFile, { checkedAt: now, latestVersion });
+}
+function compareCliVersions(left, right) {
+  const parsedLeft = parseVersion(left);
+  const parsedRight = parseVersion(right);
+  if (!parsedLeft || !parsedRight) return null;
+  return compareVersions(parsedLeft, parsedRight);
+}
+function newerStableRelease(currentVersion, latestVersion) {
+  if (!latestVersion) return null;
   const current = parseVersion(currentVersion);
-  if (!current) return null;
+  const latest = parseVersion(latestVersion);
+  if (!current || !latest || latest.prerelease.length > 0 || compareVersions(latest, current) <= 0) return null;
+  return { currentVersion, latestVersion };
+}
+async function fetchLatestCliVersion(options = {}) {
   const controller = new AbortController();
-  const timeoutMs = options.timeoutMs ?? 750;
+  const abort = () => controller.abort();
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timeoutMs = options.timeoutMs ?? 1500;
   let timeout;
   const request2 = (async () => {
     try {
@@ -12446,11 +12499,7 @@ async function checkForCliUpdate(currentVersion, options = {}) {
       const payload = await response.json();
       if (typeof payload.version !== "string") return null;
       const latest = parseVersion(payload.version);
-      if (!latest || latest.prerelease.length > 0 || compareVersions(latest, current) <= 0) return null;
-      return {
-        currentVersion,
-        latestVersion: payload.version
-      };
+      return latest && latest.prerelease.length === 0 ? payload.version : null;
     } catch {
       return null;
     }
@@ -12465,15 +12514,211 @@ async function checkForCliUpdate(currentVersion, options = {}) {
     return await Promise.race([request2, deadline]);
   } finally {
     if (timeout) clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", abort);
   }
 }
+function cachedCliUpdate(currentVersion, cacheFile) {
+  return newerStableRelease(currentVersion, readUpdateCache(cacheFile)?.latestVersion);
+}
+function cliUpdateCacheIsStale(cacheFile, options = {}) {
+  const cache = readUpdateCache(cacheFile);
+  const now = (options.now ?? Date.now)();
+  return !cache || now - cache.checkedAt >= (options.cacheMaxAgeMs ?? DEFAULT_CACHE_MAX_AGE_MS);
+}
+async function refreshCliUpdateCache(cacheFile, options = {}) {
+  const latest = await fetchLatestCliVersion(options);
+  if (latest) recordLatestCliVersion(cacheFile, latest, (options.now ?? Date.now)());
+  return latest;
+}
+var REFRESH_SCRIPT = `
+const [url, file] = process.argv.slice(1);
+const fs = require("node:fs");
+const path = require("node:path");
+fetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10000) })
+  .then((response) => response.ok ? response.json() : null)
+  .then((payload) => {
+    if (!payload || typeof payload.version !== "string") return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ checkedAt: Date.now(), latestVersion: payload.version }) + "\\n");
+  })
+  .catch(() => {});
+`;
+function spawnCliUpdateRefresh(cacheFile) {
+  const cached = readUpdateCache(cacheFile);
+  if (cached) recordLatestCliVersion(cacheFile, cached.latestVersion);
+  try {
+    const child = spawn4(
+      process.execPath,
+      ["-e", REFRESH_SCRIPT, PACKAGE_LATEST_URL, cacheFile],
+      { detached: true, stdio: "ignore", windowsHide: true }
+    );
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function checkForCliUpdate(currentVersion, options = {}) {
+  if (!parseVersion(currentVersion)) return null;
+  const { cacheFile } = options;
+  if (cacheFile && !cliUpdateCacheIsStale(cacheFile, options)) {
+    return cachedCliUpdate(currentVersion, cacheFile);
+  }
+  const latest = cacheFile ? await refreshCliUpdateCache(cacheFile, options) : await fetchLatestCliVersion(options);
+  return newerStableRelease(
+    currentVersion,
+    latest ?? (cacheFile ? readUpdateCache(cacheFile)?.latestVersion : void 0)
+  );
+}
 function formatCliUpdateNotice(update) {
   return [
-    `Update available: tt ${update.currentVersion} \u2192 ${update.latestVersion}`,
-    "Upgrade with: npm install -g @tuned-tensor/cli@latest"
+    chalk13.yellow(`Update available: tt ${update.currentVersion} \u2192 ${chalk13.bold(update.latestVersion)}`),
+    `Run ${chalk13.bold("tt upgrade")} to install it.`
   ].join("\n");
 }
 
+// src/commands/upgrade.ts
+function resolveGlobalInstall(entrypoint, platform = process.platform) {
+  if (!entrypoint) return null;
+  let script;
+  try {
+    script = realpathSync(entrypoint);
+  } catch {
+    return null;
+  }
+  if (/[\\/]_npx[\\/]/.test(script)) return null;
+  const match = platform === "win32" ? script.match(/^(.*)\\node_modules\\@tuned-tensor\\cli\\dist\\index\.js$/i) : script.match(/^(.*)\/lib\/node_modules\/@tuned-tensor\/cli\/dist\/index\.js$/);
+  if (!match?.[1]) return null;
+  return { prefix: match[1], packageDir: dirname13(dirname13(script)) };
+}
+function prefixIsWritable(prefix, platform) {
+  const modules = platform === "win32" ? join17(prefix, "node_modules") : join17(prefix, "lib", "node_modules");
+  try {
+    accessSync(existsSync10(modules) ? modules : prefix, constants3.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installedVersion(packageDir) {
+  try {
+    const manifest = JSON.parse(readFileSync15(join17(packageDir, "package.json"), "utf8"));
+    return typeof manifest.version === "string" ? manifest.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function quoteForCmd(arg) {
+  return /[\s"&|<>^]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+}
+function defaultNpmRunner(platform) {
+  return async (args2) => await new Promise((resolve13, reject) => {
+    const windows = platform === "win32";
+    const child = spawn5(
+      windows ? "npm.cmd" : "npm",
+      windows ? args2.map(quoteForCmd) : args2,
+      {
+        shell: windows,
+        // Keep stdout clean for --json; npm progress goes to stderr.
+        stdio: ["ignore", isJsonMode() ? 2 : "inherit", "inherit"]
+      }
+    );
+    child.once("error", reject);
+    child.once("close", (code2) => resolve13(code2 ?? 1));
+  });
+}
+function formatCommand(args2) {
+  return ["npm", ...args2].map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ");
+}
+function registerUpgradeCommand(program, deps) {
+  program.command("upgrade").alias("update").description("Upgrade tt to the latest release").argument("[version]", "Version or npm dist-tag to install (default: latest)").option("--check", "Only report whether an update is available").addHelpText(
+    "after",
+    `
+Examples:
+  tt upgrade             Install the latest stable release
+  tt upgrade --check     Report whether a newer release exists
+  tt upgrade beta        Opt in to the beta channel
+  tt upgrade 0.21.0      Install a specific version
+
+Set TT_NO_UPDATE_CHECK=1 to silence update notices.
+`
+  ).action(async (requested, options) => {
+    const platform = deps.platform ?? process.platform;
+    const cacheFile = getCliUpdateCacheFile(deps.env);
+    const current = deps.version;
+    const target = requested?.trim() || "latest";
+    let latest;
+    if (target === "latest") {
+      latest = await fetchLatestCliVersion({ fetchImpl: deps.fetchImpl, timeoutMs: 1e4 }) ?? void 0;
+      if (!latest) {
+        throw new Error(
+          "Could not reach the npm registry to look up the latest tt release. Check your connection and try again."
+        );
+      }
+      recordLatestCliVersion(cacheFile, latest);
+      const comparison = compareCliVersions(latest, current);
+      if (comparison !== null && comparison <= 0) {
+        if (isJsonMode()) {
+          printJson({ current_version: current, latest_version: latest, update_available: false });
+        } else {
+          printSuccess(`tt ${current} is the latest version.`);
+        }
+        return;
+      }
+    }
+    if (options.check) {
+      if (isJsonMode()) {
+        printJson({ current_version: current, latest_version: latest ?? null, update_available: Boolean(latest) });
+      } else if (latest) {
+        console.log(`Update available: tt ${current} \u2192 ${chalk14.bold(latest)}`);
+        console.log(`Run ${chalk14.bold("tt upgrade")} to install it.`);
+      } else {
+        console.log(`tt ${current} is installed. Run ${chalk14.bold(`tt upgrade ${target}`)} to install ${target}.`);
+      }
+      return;
+    }
+    const install = resolveGlobalInstall(deps.entrypoint, platform);
+    const packageSpec = `${CLI_PACKAGE_NAME}@${target}`;
+    if (!install) {
+      throw new Error(
+        `This tt (${deps.entrypoint ?? "unknown path"}) was not installed with npm -g, so it can't upgrade itself.
+Upgrade it the way you installed it, for example:
+  npm install -g --ignore-scripts ${packageSpec}`
+      );
+    }
+    const npmArgs = ["install", "-g", "--ignore-scripts", "--prefix", install.prefix, packageSpec];
+    if (!prefixIsWritable(install.prefix, platform)) {
+      throw new Error(
+        `tt is installed in ${install.prefix}, which this user can't write to. Run:
+  sudo ${formatCommand(npmArgs)}`
+      );
+    }
+    if (!isJsonMode()) {
+      console.log(`Upgrading tt ${current} \u2192 ${chalk14.bold(latest ?? target)}`);
+      console.log(chalk14.dim(`$ ${formatCommand(npmArgs)}`));
+    }
+    let code2;
+    try {
+      code2 = await (deps.runNpm ?? defaultNpmRunner(platform))(npmArgs);
+    } catch (error) {
+      throw new Error(
+        `Could not run npm (${error instanceof Error ? error.message : String(error)}). Run it yourself:
+  ${formatCommand(npmArgs)}`
+      );
+    }
+    if (code2 !== 0) {
+      throw new Error(`npm exited with code ${code2}. Run it yourself to see details:
+  ${formatCommand(npmArgs)}`);
+    }
+    const installed = installedVersion(install.packageDir) ?? latest ?? target;
+    if (isJsonMode()) {
+      printJson({ previous_version: current, version: installed, prefix: install.prefix });
+    } else {
+      printSuccess(`Upgraded tt ${current} \u2192 ${installed}. Restart any open tt sessions to use it.`);
+    }
+  });
+}
+
 // src/cli.ts
 function createAccountToolApi(opts) {
   return {
@@ -12584,7 +12829,7 @@ async function runSelfCommand(args2, options = {}) {
     throw new Error("Cannot locate the tt CLI entrypoint.");
   }
   return await new Promise((resolve13, reject) => {
-    const child = spawn4(process.execPath, [entrypoint, ...args2], {
+    const child = spawn6(process.execPath, [entrypoint, ...args2], {
       cwd: options.cwd,
       env: options.env ?? process.env,
       stdio: "inherit",
@@ -12686,7 +12931,7 @@ function createProgram(version, runtime = {}) {
     if (root.json) setJsonMode(true);
     if (root.color === false) {
       process.env.FORCE_COLOR = "0";
-      chalk13.level = 0;
+      chalk15.level = 0;
     }
   });
   registerLocalCommands(program, {
@@ -12705,6 +12950,11 @@ function createProgram(version, runtime = {}) {
   registerUsageCommand(program);
   registerPublishCommand(program);
   registerCloudCommands(program);
+  registerUpgradeCommand(program, {
+    version,
+    entrypoint: runtime.argv?.[1] ?? process.argv[1],
+    env
+  });
   registerAgentCommands(program, {
     get env() {
       return childEnvironment2(program.opts(), env);
@@ -12724,12 +12974,12 @@ function createProgram(version, runtime = {}) {
 `);
       return;
     }
-    output.write(`${chalk13.bold.hex("#8B5CF6")("Tuned Tensor status")}
+    output.write(`${chalk15.bold.hex("#8B5CF6")("Tuned Tensor status")}
 `);
     output.write(`${formatShellStatus(context).join("\n")}
 
 `);
-    output.write(`${chalk13.bold("Context")}
+    output.write(`${chalk15.bold("Context")}
 `);
     output.write(`${formatShellContext(context).join("\n")}
 `);
@@ -12785,7 +13035,11 @@ async function runCli(version, runtime = {}) {
     const error = runtime.stderr ?? process.stderr;
     let update = null;
     try {
-      update = await (runtime.checkForUpdate ?? checkForCliUpdate)(version);
+      if (runtime.checkForUpdate) {
+        update = await runtime.checkForUpdate(version);
+      } else if (!cliUpdateChecksDisabled(env)) {
+        update = await checkForCliUpdate(version, { cacheFile: getCliUpdateCacheFile(env) });
+      }
     } catch {
     }
     if (update) {
@@ -12826,11 +13080,29 @@ async function runCli(version, runtime = {}) {
     return;
   }
   if (argv.includes("--json")) setJsonMode(true);
-  await createProgram(version, { ...runtime, argv }).parseAsync(argv);
+  const notifier = startCommandUpdateNotifier(version, args2, runtime, env);
+  try {
+    await createProgram(version, { ...runtime, argv }).parseAsync(argv);
+  } finally {
+    notifier?.();
+  }
+}
+function startCommandUpdateNotifier(version, args2, runtime, env) {
+  const error = runtime.stderr ?? process.stderr;
+  if (runtime.checkForUpdate || error.isTTY !== true || cliUpdateChecksDisabled(env) || args2.some((arg) => ["--json", "--version", "-V", "--help", "-h"].includes(arg)) || ["upgrade", "update", "help"].includes(args2[0] ?? "")) return null;
+  const cacheFile = getCliUpdateCacheFile(env);
+  if (cliUpdateCacheIsStale(cacheFile)) spawnCliUpdateRefresh(cacheFile);
+  return () => {
+    if (isJsonMode()) return;
+    const update = cachedCliUpdate(version, cacheFile);
+    if (update) error.write(`
+${formatCliUpdateNotice(update)}
+`);
+  };
 }
 
 // src/index.ts
-runCli("0.22.0").catch((err) => {
+runCli("0.22.1").catch((err) => {
   reportError(err);
   process.exit(1);
 });