usagemax 0.3.8 → 0.3.9

package/README.md

@@ -40,10 +40,12 @@ bunx usagemax sync --dry-run --explain
 bunx usagemax sync
 ```
 
-The CLI checks npm's `latest` dist-tag at most twice per day and never replaces
-itself silently. Run `usagemax update sync` to hand a command to the current
-release without typing `@latest`, or set `USAGEMAX_AUTO_UPDATE=1` for an
-explicit automatic handoff. Use `--no-update-check` or set
+The CLI checks npm's `latest` dist-tag at most twice per day. Run
+`usagemax update` to update a global installation through the package manager
+that launched it (Bun or npm). Add `--check` for a read-only check, or
+`--json` for automation. A command suffix such as `usagemax update sync` hands
+that command to the newest release without typing `@latest`. Set
+`USAGEMAX_AUTO_UPDATE=1` for an explicit automatic handoff. Use `--no-update-check` or set
 `USAGEMAX_DISABLE_UPDATE_CHECK=1` in offline environments. Interactive
 terminals show a small stderr progress line; JSON,
 quiet, CI, and scheduled runs remain machine-readable and quiet.
@@ -81,6 +83,9 @@ usagemax token status            Diagnose a key piped on stdin
 usagemax service install        Opt into periodic OS checkpoints
 usagemax service status|run|uninstall
 usagemax unlink [--revoke]       Remove local credentials
+usagemax update                  Update the global CLI through Bun or npm
+usagemax update --check          Check without installing
+usagemax update sync             Run sync through the newest CLI release
 ```
 
 Useful options:
@@ -93,7 +98,8 @@ bunx usagemax status --remote --json      # remote check; secret is never printe
 bunx usagemax doctor --deep --json        # parse and audit retained history
 bunx usagemax link UMX-… --no-sync        # link without uploading yet
 bunx usagemax --version --json             # print CLI and ccusage versions
-bunx usagemax update --json                # machine-readable release check
+bunx usagemax update --json                # update and return machine-readable status
+bunx usagemax update --check --json        # check without installing
 bunx usagemax unlink --json                # safe automation result; no secret output
 ```
 
@@ -135,7 +141,7 @@ printf '%s' "$USAGEMAX_COLLECTOR_TOKEN" \
       --json
 ```
 
-The `token status` command is included in CLI `0.3.8`. If a fresh environment
+The `token status` command is included in CLI `0.3.9`. If a fresh environment
 still has an older npm tag, run `usagemax update token status` or
 `node packages/cli/src/cli.js token status` from this repository until the new
 package is published.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usagemax",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Link local coding-agent usage to your UsageMax profile",
   "keywords": [
     "usagemax",

package/src/cli.js

@@ -18,7 +18,7 @@ import { intervalMinutes, manageService, runScheduledSync } from "./service.js";
 import { collectorStatusView, requestCollectorStatus, requestSnapshot } from "./transport.js";
 import { resumeUpload, restartExpiredUpload, withConfigLock } from "./resume.js";
 import { CCUSAGE_VERSION, ccusageEnvironment, ccusageHome, discoverProviderArchives, SOURCE_INVENTORY_VERSION, sourceInventory, SUPPORTED_SOURCES } from "./sources.js";
-import { checkForUpdate, runLatest } from "./updates.js";
+import { checkForUpdate, packageManagerFor, runLatest, updateGlobal } from "./updates.js";
 
 // Make the short-lived collector recognizable in Activity Monitor and `ps`.
 // Windows may still display the underlying node.exe image name in Task Manager.
@@ -26,7 +26,7 @@ process.title = "UsageMax";
 
 const require = createRequire(import.meta.url);
 const executeFile = promisify(execFile);
-const VERSION = "0.3.8";
+const VERSION = "0.3.9";
 const PUBLIC_API_ORIGIN = "https://usagemax.com/api";
 const DEFAULT_LINK_ENDPOINT = `${PUBLIC_API_ORIGIN}/v1/devices/link`;
 const DEFAULT_STATUS_ENDPOINT = `${PUBLIC_API_ORIGIN}/v1/devices/status`;
@@ -132,8 +132,9 @@ function help() {
   process.stdout.write("  usagemax service status|run|uninstall\n");
   process.stdout.write("  usagemax doctor [--deep] [--json] [--quiet|--no-progress]\n");
   process.stdout.write("                                  Check source coverage; --deep parses full history\n");
-  process.stdout.write("  usagemax update [command args]  Check npm and optionally run the latest CLI\n");
-  process.stdout.write("           [--json]                  Emit machine-readable update status\n");
+  process.stdout.write("  usagemax update                  Update the global CLI through Bun or npm\n");
+  process.stdout.write("           [--check] [--json]       Check only or emit machine-readable status\n");
+  process.stdout.write("  usagemax update <command args>   Run a command through the latest CLI\n");
   process.stdout.write("  usagemax report [...args]        Run a local ccusage report\n");
   process.stdout.write("  usagemax unlink [--revoke]       Remove locally; --revoke also disables uploads\n");
   process.stdout.write("           [--json]                  Emit machine-readable unlink status\n");
@@ -622,6 +623,9 @@ async function report(args) {
 
 async function update(args = []) {
   const json = args.includes("--json");
+  const checkOnly = args.includes("--check") || args.includes("--no-install");
+  const commandArgs = args.filter((arg) => !["--check", "--no-install", "--json"].includes(arg));
+  const handoffArgs = commandArgs.length ? [...commandArgs, ...(json ? ["--json"] : [])] : [];
   const check = await checkForUpdate(configDirectory(), VERSION, { force: true });
   if (!check.latest) {
     const result = { version: VERSION, latest: null, newer: false, status: "unavailable" };
@@ -633,15 +637,31 @@ async function update(args = []) {
     process.stdout.write(json ? `${JSON.stringify(result)}\n` : `UsageMax CLI ${VERSION} is current.\n`);
     return;
   }
-  const result = { version: VERSION, latest: check.latest, newer: true, status: "available", command: "usagemax update sync" };
-  process.stdout.write(json ? `${JSON.stringify(result)}\n` : `UsageMax CLI ${check.latest} is available (current ${VERSION}).\n`);
-  const commandArgs = args.filter((arg) => arg !== "--check");
-  if (!commandArgs.length || args.includes("--check")) {
-    if (!json) process.stdout.write("Run `usagemax update sync` to hand off the next command to the latest npm release.\n");
+  if (handoffArgs.length) {
+    const result = { version: VERSION, latest: check.latest, newer: true, status: "available", command: `usagemax update ${commandArgs.join(" ")}` };
+    process.stdout.write(json ? `${JSON.stringify(result)}\n` : `UsageMax CLI ${check.latest} is available (current ${VERSION}).\n`);
+    if (!json) process.stdout.write(`Launching UsageMax ${check.latest}…\n`);
+    return runLatest(handoffArgs);
+  }
+  const manager = packageManagerFor({ cliPath: process.argv[1], runtime: process.versions, env: process.env });
+  const installCommand = manager === "bun" ? "bun add --global usagemax@latest" : "npm install --global usagemax@latest";
+  const available = { version: VERSION, latest: check.latest, newer: true, status: "available", manager, installCommand };
+  if (checkOnly) {
+    process.stdout.write(json ? `${JSON.stringify(available)}\n` : `UsageMax CLI ${check.latest} is available (current ${VERSION}). Run \`${installCommand}\`.\n`);
     return;
   }
-  if (!json) process.stdout.write(`Launching UsageMax ${check.latest}…\n`);
-  return runLatest(commandArgs);
+  if (!json) process.stdout.write(`Updating UsageMax ${VERSION} → ${check.latest} via ${manager}…\n`);
+  try {
+    await updateGlobal({ latest: check.latest, manager, quiet: json });
+  } catch (error) {
+    const result = { ...available, status: "failed", error: error instanceof Error ? error.message : String(error) };
+    if (json) process.stdout.write(`${JSON.stringify(result)}\n`);
+    else process.stderr.write(`UsageMax update failed: ${result.error}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = { ...available, status: "updated", installedVersion: check.latest };
+  process.stdout.write(json ? `${JSON.stringify(result)}\n` : `UsageMax CLI is now ${check.latest}.\n`);
 }
 
 async function maybeUpdate(command, args) {

package/src/updates.js

@@ -83,6 +83,43 @@ function runner() {
   return { command: "bunx", prefix: ["--bun"] };
 }
 
+/**
+ * Pick the package manager that owns the current invocation. Bun's global and
+ * ephemeral package paths are explicit; npm remains the safe default for a
+ * normal Node installation. The override is useful for managed environments
+ * where the executable is wrapped by a fleet-specific package manager.
+ */
+export function packageManagerFor({ cliPath = process.argv[1], runtime = process.versions, env = process.env } = {}) {
+  const override = String(env.USAGEMAX_PACKAGE_MANAGER || "").trim().toLowerCase();
+  if (override === "bun" || override === "npm") return override;
+  const normalizedPath = String(cliPath || "").replaceAll("\\", "/");
+  if (normalizedPath.includes("/.bun/install/") || runtime?.bun) return "bun";
+  if (env.npm_execpath || String(env.npm_config_user_agent || "").startsWith("npm/")) return "npm";
+  return "npm";
+}
+
+/** Install the current public release into the user's global package scope. */
+export async function updateGlobal({ latest = "latest", manager = packageManagerFor(), spawnImpl = spawn, env = process.env, quiet = false, platform = process.platform } = {}) {
+  if (manager !== "bun" && manager !== "npm") throw new Error(`Unsupported package manager: ${manager}`);
+  if (!/^\d+\.\d+\.\d+$/.test(String(latest)) && latest !== "latest") throw new Error("Invalid UsageMax release version.");
+  const command = manager === "bun" ? (platform === "win32" ? "bun.exe" : "bun") : (platform === "win32" ? "npm.cmd" : "npm");
+  const args = manager === "bun"
+    ? ["add", "--global", `usagemax@${latest}`]
+    : ["install", "--global", `usagemax@${latest}`];
+  const child = spawnImpl(command, args, {
+    stdio: quiet ? ["ignore", "pipe", "pipe"] : "inherit",
+    env: { ...env, NPM_CONFIG_UPDATE_NOTIFIER: "false" },
+  });
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (status) => {
+      const code = status ?? 1;
+      if (code === 0) resolve({ manager, command, args });
+      else reject(Object.assign(new Error(`${command} ${args.join(" ")} exited with code ${code}.`), { code: "USAGEMAX_UPDATE_FAILED", exitCode: code }));
+    });
+  });
+}
+
 /** Re-run a command through the current npm dist-tag without requiring @latest. */
 export async function runLatest(args, { spawnImpl = spawn } = {}) {
   const selected = runner();