@aria_asi/cli 0.2.29 → 0.2.31

package/src/self-update.ts

@@ -1,13 +1,12 @@
 // self-update — checks the npm registry for newer @aria_asi/cli versions
-// and surfaces a one-line notice. Doesn't auto-install (clients control
-// their tooling); just informs.
+// and auto-installs them in the background by default.
 //
 // Direction: Hamza 2026-04-26 — "does the package auto update when we
 // enhance it on our enhance? so we can continually improve all night using
 // arias background work we should imrpove to do that once we finish".
 // This is the primitive that closes the overnight-improvement loop:
 // Aria publishes 0.2.5 / 0.3.0 / etc.; clients see the notice on their
-// next `aria <cmd>` invocation; they upgrade with one command.
+// next `aria <cmd>` invocation; Aria upgrades itself in the background.
 //
 // Doctrine bindings:
 //   - feedback_no_demos.md — real overnight evolution, real registry check
@@ -22,21 +21,30 @@
 //   - Reads ~/.aria/last-update-check timestamp; if checked <24h ago, skip
 //   - GET registry.npmjs.org/@aria_asi/cli for latest dist-tag
 //   - semver-compare; if newer, return {updateAvailable: true, latest, current, message}
+//   - Launches npm install -g @aria_asi/cli@latest in the background
+//     unless ARIA_SELF_UPDATE_MODE=notify|off
+//   - Tracks per-version attempts so it doesn't thrash on every invocation
 //   - Write timestamp on every check (success or skip-due-to-rate-limit)
 //   - Failures are silent (network down, registry blip — never block CLI startup)
 //
 // Privacy: the request to npmjs only sends User-Agent (npm registry public).
 // No client identity, no telemetry beyond what the public registry already logs.
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, openSync } from 'node:fs';
+import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ARIA_DIR = join(homedir(), '.aria');
 const LAST_CHECK_PATH = join(ARIA_DIR, 'last-update-check');
+const AUTO_UPDATE_STATE_PATH = join(ARIA_DIR, 'self-update-state.json');
+const AUTO_UPDATE_LOG_PATH = join(ARIA_DIR, 'self-update.log');
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
+const AUTO_UPDATE_RETRY_MS = 6 * 60 * 60 * 1000; // 6h
 const REGISTRY_URL = 'https://registry.npmjs.org/@aria_asi%2Fcli';
+const PACKAGE_NAME = '@aria_asi/cli';
+const AUTO_UPDATE_MODE = (process.env.ARIA_SELF_UPDATE_MODE || 'auto').toLowerCase();
 
 export interface UpdateCheckResult {
   ok: boolean;
@@ -47,6 +55,11 @@ export interface UpdateCheckResult {
   reason?: string;
 }
 
+interface AutoUpdateState {
+  lastAttemptVersion?: string;
+  lastAttemptAt?: number;
+}
+
 /**
  * Find the package's own version by walking up from this file's runtime
  * path until we hit the package.json with name @aria_asi/cli.
@@ -94,6 +107,69 @@ function compareSemver(a: string, b: string): number {
   return pa.pre.localeCompare(pb.pre);
 }
 
+function loadAutoUpdateState(): AutoUpdateState {
+  try {
+    if (!existsSync(AUTO_UPDATE_STATE_PATH)) return {};
+    return JSON.parse(readFileSync(AUTO_UPDATE_STATE_PATH, 'utf-8')) as AutoUpdateState;
+  } catch {
+    return {};
+  }
+}
+
+function saveAutoUpdateState(state: AutoUpdateState): void {
+  try {
+    if (!existsSync(ARIA_DIR)) mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(AUTO_UPDATE_STATE_PATH, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+  } catch {
+    // best effort only
+  }
+}
+
+function canRetryVersion(latest: string): boolean {
+  const state = loadAutoUpdateState();
+  if (state.lastAttemptVersion !== latest) return true;
+  if (!state.lastAttemptAt) return true;
+  return Date.now() - state.lastAttemptAt >= AUTO_UPDATE_RETRY_MS;
+}
+
+function launchAutoInstall(latest: string): { started: boolean; reason?: string } {
+  if (AUTO_UPDATE_MODE === 'off') {
+    return { started: false, reason: 'self-update disabled' };
+  }
+  if (AUTO_UPDATE_MODE === 'notify') {
+    return { started: false, reason: 'notify-only mode' };
+  }
+  if (!canRetryVersion(latest)) {
+    return { started: false, reason: 'recent attempt already made' };
+  }
+
+  try {
+    if (!existsSync(ARIA_DIR)) mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+    const logFd = openSync(AUTO_UPDATE_LOG_PATH, 'a', 0o600);
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const child = spawn(
+      npmCmd,
+      ['install', '-g', `${PACKAGE_NAME}@${latest}`],
+      {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: process.env,
+      },
+    );
+    child.unref();
+    saveAutoUpdateState({
+      lastAttemptVersion: latest,
+      lastAttemptAt: Date.now(),
+    });
+    return { started: true };
+  } catch (error) {
+    return {
+      started: false,
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 /**
  * Check the registry for the latest @aria_asi/cli version. Rate-limited
  * to once per CHECK_INTERVAL_MS (24h) via a timestamp file in ~/.aria.
@@ -150,20 +226,25 @@ export async function checkForUpdate(opts: { force?: boolean } = {}): Promise<Up
     current,
     latest,
     updateAvailable: true,
-    message: `I have an update: v${latest} (you're on v${current}). Run 'npm update -g @aria_asi/cli' when you have a minute.`,
+    message: `I have an update: v${latest} (you're on v${current}).`,
   };
 }
 
 /**
- * Convenience: check + print the notice if available. Non-blocking, silent
+ * Convenience: check + auto-install if available. Falls back to notice-only
+ * when auto-upgrade is disabled or can't be launched. Non-blocking, silent
  * on errors. Called from bin/aria.js on startup.
  */
 export async function maybePrintUpdateNotice(): Promise<void> {
   try {
     const result = await checkForUpdate();
     if (result.ok && result.updateAvailable && result.message) {
-      // Print to stderr so it doesn't pollute stdout-piped CLI output
-      process.stderr.write(`  ${result.message}\n`);
+      const autoInstall = result.latest ? launchAutoInstall(result.latest) : { started: false, reason: 'missing latest version' };
+      if (autoInstall.started) {
+        process.stderr.write(`  ${result.message} Updating in the background now.\n`);
+      } else {
+        process.stderr.write(`  ${result.message} Run 'npm install -g ${PACKAGE_NAME}@latest' if you want it immediately.\n`);
+      }
     }
   } catch {/* never block startup */}
 }