@sylphx/flow 2.15.1 → 2.15.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @sylphx/flow
 
+## 2.15.3 (2025-12-17)
+
+### ⚡️ Performance
+
+- **auto-upgrade:** simplify - no TTL, always background check ([5621a21](https://github.com/SylphxAI/flow/commit/5621a21ab2a3eeb54f3fecadd32c19269bd22312))
+- **auto-upgrade:** cache target current version too ([229a400](https://github.com/SylphxAI/flow/commit/229a4002bde6da3540c014eb39e8a941e072a4db))
+
+## 2.15.2 (2025-12-17)
+
+### ⚡️ Performance
+
+- **auto-upgrade:** non-blocking version check with cache ([0550e44](https://github.com/SylphxAI/flow/commit/0550e44ea9b471ae07b2ea13c196354a7a32a605))
+
 ## 2.15.1 (2025-12-17)
 
 ### Improvements

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "2.15.1",
+	"version": "2.15.3",
 	"description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/services/auto-upgrade.ts

@@ -1,10 +1,13 @@
 /**
  * Auto-Upgrade Service
- * Automatically checks and upgrades Flow and target CLI before each execution
+ * Non-blocking version check with cache
+ * Checks in background, shows result on next run
  */
 
 import { exec } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
@@ -16,6 +19,15 @@ import { TargetInstaller } from './target-installer.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Version info file (stores last background check result)
+const VERSION_FILE = path.join(os.homedir(), '.sylphx-flow', 'versions.json');
+
+interface VersionInfo {
+  flowLatest?: string;
+  targetLatest?: Record<string, string>;
+  targetCurrent?: Record<string, string>;
+}
+
 const execAsync = promisify(exec);
 
 export interface UpgradeStatus {
@@ -43,80 +55,152 @@ export class AutoUpgrade {
   }
 
   /**
-   * Check for available upgrades for Flow and target CLI
-   * @param targetId - Optional target CLI ID to check for upgrades
-   * @returns Upgrade status indicating what needs upgrading
+   * Read version info from last background check
    */
-  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
-    const [flowVersion, targetVersion] = await Promise.all([
-      this.options.skipFlow ? null : this.checkFlowVersion(),
-      this.options.skipTarget || !targetId ? null : this.checkTargetVersion(targetId),
-    ]);
+  private async readVersionInfo(): Promise<VersionInfo | null> {
+    try {
+      if (!existsSync(VERSION_FILE)) {
+        return null;
+      }
+      const data = await fs.readFile(VERSION_FILE, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
 
-    return {
-      flowNeedsUpgrade: !!flowVersion,
-      targetNeedsUpgrade: !!targetVersion,
-      flowVersion,
-      targetVersion,
-    };
+  /**
+   * Write version info
+   */
+  private async writeVersionInfo(info: VersionInfo): Promise<void> {
+    try {
+      const dir = path.dirname(VERSION_FILE);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(VERSION_FILE, JSON.stringify(info, null, 2));
+    } catch {
+      // Silent fail
+    }
   }
 
   /**
-   * Check Flow version
+   * Get current Flow version from package.json (instant, local file)
    */
-  private async checkFlowVersion(): Promise<{ current: string; latest: string } | null> {
+  private async getCurrentFlowVersion(): Promise<string> {
     try {
-      // Get current version from package.json
       const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-      const currentVersion = packageJson.version;
-
-      // Get latest version from npm
-      const { stdout } = await execAsync('npm view @sylphx/flow version');
-      const latestVersion = stdout.trim();
-
-      if (currentVersion !== latestVersion) {
-        return { current: currentVersion, latest: latestVersion };
-      }
-
-      return null;
+      return packageJson.version;
     } catch {
-      return null;
+      return 'unknown';
     }
   }
 
   /**
-   * Check target CLI version
+   * Check for available upgrades (instant, reads from last background check)
+   * Background check runs every time for fresh data next run
    */
-  private async checkTargetVersion(
-    targetId: string
-  ): Promise<{ current: string; latest: string } | null> {
-    const installation = this.targetInstaller.getInstallationInfo(targetId);
-    if (!installation) {
-      return null;
+  async checkForUpgrades(targetId?: string): Promise<UpgradeStatus> {
+    const info = await this.readVersionInfo();
+    const currentVersion = await this.getCurrentFlowVersion();
+
+    // Trigger background check for next run (non-blocking, every time)
+    this.checkInBackground(targetId);
+
+    // No previous check = no upgrade info yet
+    if (!info) {
+      return {
+        flowNeedsUpgrade: false,
+        targetNeedsUpgrade: false,
+        flowVersion: null,
+        targetVersion: null,
+      };
     }
 
-    try {
-      // Get current version
-      const { stdout: currentOutput } = await execAsync(installation.checkCommand);
-      const currentMatch = currentOutput.match(/v?(\d+\.\d+\.\d+)/);
-      if (!currentMatch) {
-        return null;
+    // Check if Flow needs upgrade
+    const flowVersion =
+      info.flowLatest && info.flowLatest !== currentVersion
+        ? { current: currentVersion, latest: info.flowLatest }
+        : null;
+
+    // Check if target needs upgrade
+    let targetVersion: { current: string; latest: string } | null = null;
+    if (targetId && info.targetLatest?.[targetId] && info.targetCurrent?.[targetId]) {
+      const current = info.targetCurrent[targetId];
+      const latest = info.targetLatest[targetId];
+      if (current !== latest) {
+        targetVersion = { current, latest };
       }
-      const currentVersion = currentMatch[1];
+    }
 
-      // Get latest version from npm
-      const { stdout: latestOutput } = await execAsync(`npm view ${installation.package} version`);
-      const latestVersion = latestOutput.trim();
+    return {
+      flowNeedsUpgrade: !!flowVersion,
+      targetNeedsUpgrade: !!targetVersion,
+      flowVersion,
+      targetVersion,
+    };
+  }
 
-      if (currentVersion !== latestVersion) {
-        return { current: currentVersion, latest: latestVersion };
-      }
+  /**
+   * Check versions in background (non-blocking)
+   * Runs every time, updates info for next run
+   */
+  private checkInBackground(targetId?: string): void {
+    // Fire and forget - don't await
+    this.performBackgroundCheck(targetId).catch(() => {
+      // Silent fail
+    });
+  }
 
-      return null;
+  /**
+   * Perform the actual version check (called in background)
+   */
+  private async performBackgroundCheck(targetId?: string): Promise<void> {
+    const oldInfo = await this.readVersionInfo();
+
+    const newInfo: VersionInfo = {
+      targetLatest: oldInfo?.targetLatest || {},
+      targetCurrent: oldInfo?.targetCurrent || {},
+    };
+
+    // Check Flow version from npm (with timeout)
+    try {
+      const { stdout } = await execAsync('npm view @sylphx/flow version', { timeout: 5000 });
+      newInfo.flowLatest = stdout.trim();
     } catch {
-      return null;
+      // Keep old value if check fails
+      newInfo.flowLatest = oldInfo?.flowLatest;
+    }
+
+    // Check target version from npm and local (with timeout)
+    if (targetId) {
+      const installation = this.targetInstaller.getInstallationInfo(targetId);
+      if (installation) {
+        // Check latest version from npm
+        try {
+          const { stdout } = await execAsync(`npm view ${installation.package} version`, {
+            timeout: 5000,
+          });
+          newInfo.targetLatest = newInfo.targetLatest || {};
+          newInfo.targetLatest[targetId] = stdout.trim();
+        } catch {
+          // Keep old value
+        }
+
+        // Check current installed version (local command)
+        try {
+          const { stdout } = await execAsync(installation.checkCommand, { timeout: 5000 });
+          const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          if (match) {
+            newInfo.targetCurrent = newInfo.targetCurrent || {};
+            newInfo.targetCurrent[targetId] = match[1];
+          }
+        } catch {
+          // Keep old value
+        }
+      }
     }
+
+    await this.writeVersionInfo(newInfo);
   }
 
   /**