@compass-ai/nova 1.0.73 → 1.0.74

package/dist/services/update-service.js

@@ -0,0 +1,749 @@
+/**
+ * Auto-update service for the Compass CLI.
+ *
+ * This module provides functionality to check for updates, notify users,
+ * and manage the update lifecycle. It uses update-notifier for npm registry
+ * checks and provides a comprehensive update management system.
+ *
+ * Key features:
+ * - Automatic update checking on startup (configurable)
+ * - Manual update checking via /update command
+ * - Update notification banners with customizable styles
+ * - Update history tracking
+ * - Configurable check intervals and notification preferences
+ */
+import updateNotifier from 'update-notifier';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import semver from 'semver';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execa } from 'execa';
+import { getGlobalCompassDir } from '../utils/path.js';
+import { ensureDir, pathExists, safeReadJson, safeWriteJson } from '../utils/file-system.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Package metadata - uses build-time constants if available, otherwise fallback values
+ */
+const PACKAGE_NAME = typeof __PKG_NAME__ !== 'undefined' ? __PKG_NAME__ : '@compass-ai/nova';
+const CURRENT_VERSION = typeof __PKG_VERSION__ !== 'undefined' ? __PKG_VERSION__ : '0.0.0';
+const CACHE_VERSION = '1.0.0';
+/**
+ * Resolve the path to this package's package.json
+ */
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_JSON_PATH = path.resolve(__dirname, '../../package.json');
+/**
+ * Cache file name for storing update data
+ */
+const UPDATE_CACHE_FILE = 'update-cache.json';
+/**
+ * Default update configuration
+ */
+const defaultConfig = {
+    checkOnStartup: true,
+    checkInterval: 4, // hours
+    showNotifications: true,
+    notificationStyle: 'banner',
+    includePrerelease: false,
+};
+/**
+ * UpdateService class manages all update-related functionality.
+ */
+export class UpdateService {
+    config;
+    cache;
+    cacheFilePath;
+    packageJson;
+    constructor(config, packageJson) {
+        this.config = config;
+        this.packageJson = packageJson;
+        this.cacheFilePath = path.join(getGlobalCompassDir(), UPDATE_CACHE_FILE);
+        this.cache = {
+            history: [],
+            cacheVersion: CACHE_VERSION,
+        };
+    }
+    /**
+     * Creates and initializes an UpdateService instance.
+     */
+    static async create(config) {
+        const mergedConfig = { ...defaultConfig, ...config };
+        // Read package.json from the installed CLI location for accurate version info
+        let packageJson = { name: PACKAGE_NAME, version: CURRENT_VERSION };
+        try {
+            logger.debug('Update service: resolving package.json', { path: PACKAGE_JSON_PATH });
+            if (await pathExists(PACKAGE_JSON_PATH)) {
+                const pkgContent = await readFile(PACKAGE_JSON_PATH, 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                packageJson = { name: pkg.name || PACKAGE_NAME, version: pkg.version || CURRENT_VERSION };
+                logger.debug('Update service: loaded package.json', {
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    source: 'package.json',
+                });
+            }
+            else {
+                logger.debug('Update service: package.json not found, using fallback', {
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    source: 'fallback',
+                });
+            }
+        }
+        catch (error) {
+            // Use defaults if package.json can't be read
+            logger.debug('Update service: failed to read package.json, using fallback', {
+                error: error instanceof Error ? error.message : 'unknown error',
+                name: packageJson.name,
+                version: packageJson.version,
+            });
+        }
+        const service = new UpdateService(mergedConfig, packageJson);
+        await service.loadCache();
+        return service;
+    }
+    /**
+     * Loads the update cache from disk.
+     */
+    async loadCache() {
+        try {
+            await ensureDir(getGlobalCompassDir());
+            if (await pathExists(this.cacheFilePath)) {
+                const data = await safeReadJson(this.cacheFilePath);
+                if (data && data.cacheVersion === CACHE_VERSION) {
+                    this.cache = data;
+                }
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to load update cache', error);
+        }
+    }
+    /**
+     * Saves the update cache to disk.
+     */
+    async saveCache() {
+        try {
+            await ensureDir(getGlobalCompassDir());
+            await safeWriteJson(this.cacheFilePath, this.cache);
+        }
+        catch (error) {
+            logger.debug('Failed to save update cache', error);
+        }
+    }
+    /**
+     * Checks for available updates.
+     */
+    async checkForUpdates(force = false) {
+        const result = {
+            updateAvailable: false,
+            currentVersion: this.packageJson.version,
+            checkedAt: new Date().toISOString(),
+        };
+        try {
+            // Check if we should skip based on interval (unless forced)
+            if (!force && this.cache.lastCheck) {
+                // Invalidate cache if the installed version has changed (e.g., user manually updated)
+                if (this.cache.lastCheck.currentVersion !== this.packageJson.version) {
+                    logger.debug('Cache invalidated - installed version changed', {
+                        cachedVersion: this.cache.lastCheck.currentVersion,
+                        installedVersion: this.packageJson.version,
+                    });
+                }
+                else {
+                    const lastCheckTime = new Date(this.cache.lastCheck.checkedAt).getTime();
+                    const intervalMs = this.config.checkInterval * 60 * 60 * 1000;
+                    if (Date.now() - lastCheckTime < intervalMs) {
+                        logger.debug('Skipping update check - within interval');
+                        return this.cache.lastCheck;
+                    }
+                }
+            }
+            logger.debug('Checking for updates...');
+            // Use update-notifier to check npm registry
+            const notifier = updateNotifier({
+                pkg: this.packageJson,
+                updateCheckInterval: 0, // We manage our own interval
+            });
+            // Fetch update info (this can take a moment)
+            const updateInfo = await notifier.fetchInfo();
+            // Only mark as update available if latest version is actually NEWER than current
+            if (updateInfo && updateInfo.latest && semver.gt(updateInfo.latest, this.packageJson.version)) {
+                result.updateAvailable = true;
+                result.latestVersion = updateInfo.latest;
+                result.updateType = this.mapUpdateType(updateInfo.type || 'patch');
+                result.releaseNotesUrl = `https://dev.azure.com/oakpeak-devops/Kore/_git/Kore-CLI?version=GTv${updateInfo.latest}`;
+                // Filter out prerelease if not wanted
+                if (!this.config.includePrerelease && semver.prerelease(updateInfo.latest)) {
+                    result.updateAvailable = false;
+                    result.latestVersion = undefined;
+                    result.updateType = undefined;
+                }
+            }
+            else if (updateInfo && updateInfo.latest && semver.lt(updateInfo.latest, this.packageJson.version)) {
+                logger.debug('Current version is newer than npm registry', {
+                    currentVersion: this.packageJson.version,
+                    registryVersion: updateInfo.latest,
+                });
+            }
+            // Update cache
+            this.cache.lastCheck = result;
+            await this.saveCache();
+            return result;
+        }
+        catch (error) {
+            result.error = error instanceof Error ? error.message : 'Failed to check for updates';
+            logger.debug('Update check failed', error);
+            return result;
+        }
+    }
+    /**
+     * Maps update-notifier type to our UpdateType.
+     */
+    mapUpdateType(type) {
+        switch (type) {
+            case 'major':
+                return 'major';
+            case 'minor':
+                return 'minor';
+            case 'patch':
+                return 'patch';
+            case 'prerelease':
+                return 'prerelease';
+            default:
+                return 'patch';
+        }
+    }
+    /**
+     * Displays an update notification to the user.
+     */
+    displayUpdateNotification(result) {
+        if (!result.updateAvailable || !result.latestVersion || !this.config.showNotifications) {
+            return;
+        }
+        if (this.config.notificationStyle === 'silent') {
+            return;
+        }
+        const notification = this.formatNotification(result);
+        console.log(notification);
+        // Update notification state
+        this.updateNotificationState(result.latestVersion);
+    }
+    /**
+     * Formats the update notification based on style preference.
+     */
+    formatNotification(result) {
+        const { currentVersion, latestVersion, updateType } = result;
+        switch (this.config.notificationStyle) {
+            case 'minimal':
+                return this.formatMinimalNotification(currentVersion, latestVersion, updateType);
+            case 'detailed':
+                return this.formatDetailedNotification(currentVersion, latestVersion, updateType, result.releaseNotesUrl);
+            case 'banner':
+            default:
+                return this.formatBannerNotification(currentVersion, latestVersion, updateType);
+        }
+    }
+    /**
+     * Formats a minimal one-line notification.
+     */
+    formatMinimalNotification(current, latest, type) {
+        const typeColor = this.getUpdateTypeColor(type);
+        return chalk.gray(`Update available: ${current} -> `) + typeColor(latest) + chalk.gray(` (npm i -g ${this.packageJson.name})`);
+    }
+    /**
+     * Formats a banner-style notification using boxen.
+     */
+    formatBannerNotification(current, latest, type) {
+        const typeColor = this.getUpdateTypeColor(type);
+        const typeLabel = type ? ` (${type})` : '';
+        const message = [
+            `Update available! ${chalk.dim(current)} ${chalk.reset('→')} ${typeColor(latest)}${chalk.dim(typeLabel)}`,
+            '',
+            `Run ${chalk.cyan(`npm i -g ${this.packageJson.name}`)} to update`,
+        ].join('\n');
+        return boxen(message, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: this.getUpdateTypeBorderColor(type),
+            title: 'Compass CLI Update',
+            titleAlignment: 'center',
+        });
+    }
+    /**
+     * Formats a detailed notification with release notes link.
+     */
+    formatDetailedNotification(current, latest, type, releaseNotesUrl) {
+        const typeColor = this.getUpdateTypeColor(type);
+        const typeLabel = type ? type.charAt(0).toUpperCase() + type.slice(1) : 'New';
+        const lines = [
+            '',
+            chalk.bold.cyan(`  ${typeLabel} Update Available!`),
+            '',
+            `  ${chalk.gray('Current version:')} ${current}`,
+            `  ${chalk.gray('Latest version:')}  ${typeColor(latest)}`,
+            '',
+        ];
+        if (releaseNotesUrl) {
+            lines.push(`  ${chalk.gray('Release notes:')} ${chalk.underline.blue(releaseNotesUrl)}`);
+            lines.push('');
+        }
+        lines.push(`  ${chalk.gray('To update, run:')} ${chalk.cyan(`npm i -g ${this.packageJson.name}`)}`);
+        lines.push('');
+        const message = lines.join('\n');
+        return boxen(message, {
+            padding: 0,
+            margin: 1,
+            borderStyle: 'double',
+            borderColor: this.getUpdateTypeBorderColor(type),
+        });
+    }
+    /**
+     * Gets the chalk color function for an update type.
+     */
+    getUpdateTypeColor(type) {
+        switch (type) {
+            case 'major':
+                return chalk.red;
+            case 'minor':
+                return chalk.yellow;
+            case 'patch':
+                return chalk.green;
+            case 'prerelease':
+                return chalk.magenta;
+            default:
+                return chalk.cyan;
+        }
+    }
+    /**
+     * Gets the border color for boxen based on update type.
+     */
+    getUpdateTypeBorderColor(type) {
+        switch (type) {
+            case 'major':
+                return 'red';
+            case 'minor':
+                return 'yellow';
+            case 'patch':
+                return 'green';
+            case 'prerelease':
+                return 'magenta';
+            default:
+                return 'cyan';
+        }
+    }
+    /**
+     * Updates the notification state in cache.
+     */
+    async updateNotificationState(version) {
+        const existing = this.cache.notificationState;
+        if (existing && existing.version === version) {
+            existing.showCount++;
+        }
+        else {
+            this.cache.notificationState = {
+                version,
+                notifiedAt: new Date().toISOString(),
+                dismissed: false,
+                showCount: 1,
+            };
+        }
+        await this.saveCache();
+    }
+    /**
+     * Dismisses the current update notification.
+     */
+    async dismissNotification() {
+        if (this.cache.notificationState) {
+            this.cache.notificationState.dismissed = true;
+            this.cache.notificationState.dismissedAt = new Date().toISOString();
+            await this.saveCache();
+        }
+    }
+    /**
+     * Performs the update using the specified package manager.
+     */
+    async performUpdate(method = 'npm') {
+        const result = await this.checkForUpdates(true);
+        if (!result.updateAvailable || !result.latestVersion) {
+            logger.output(chalk.green('You are already on the latest version!'));
+            return true;
+        }
+        const fromVersion = this.packageJson.version;
+        const toVersion = result.latestVersion;
+        logger.output('');
+        logger.output(chalk.cyan(`Updating Compass CLI from ${fromVersion} to ${toVersion}...`));
+        logger.output('');
+        try {
+            const command = this.getUpdateCommand(method);
+            logger.output(chalk.gray(`Running: ${command}`));
+            logger.output('');
+            const { stdout } = await execa(command, { shell: true });
+            if (stdout) {
+                logger.output(stdout);
+            }
+            // Record successful update
+            await this.recordUpdateHistory(fromVersion, toVersion, true, method);
+            logger.output('');
+            logger.output(chalk.green(`Successfully updated to version ${toVersion}!`));
+            logger.output(chalk.gray('Please restart Compass CLI to use the new version.'));
+            logger.output('');
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            // Record failed update
+            await this.recordUpdateHistory(fromVersion, toVersion, false, method, errorMessage);
+            logger.output('');
+            logger.output(chalk.red(`Update failed: ${errorMessage}`));
+            logger.output('');
+            logger.output(chalk.gray('You can try updating manually:'));
+            logger.output(chalk.cyan(`  ${this.getUpdateCommand(method)}`));
+            logger.output('');
+            return false;
+        }
+    }
+    /**
+     * Gets the update command for the specified package manager.
+     */
+    getUpdateCommand(method) {
+        const pkgName = this.packageJson.name;
+        switch (method) {
+            case 'yarn':
+                return `yarn global add ${pkgName}`;
+            case 'pnpm':
+                return `pnpm add -g ${pkgName}`;
+            case 'npm':
+            default:
+                return `npm install -g ${pkgName}`;
+        }
+    }
+    /**
+     * Records an update attempt in the history.
+     */
+    async recordUpdateHistory(fromVersion, toVersion, success, method, error) {
+        const entry = {
+            fromVersion,
+            toVersion,
+            updatedAt: new Date().toISOString(),
+            success,
+            method,
+            error,
+        };
+        this.cache.history.push(entry);
+        // Keep only last 10 entries
+        if (this.cache.history.length > 10) {
+            this.cache.history = this.cache.history.slice(-10);
+        }
+        // Clear notification state after update attempt
+        if (success) {
+            this.cache.notificationState = undefined;
+        }
+        await this.saveCache();
+    }
+    /**
+     * Gets the update history.
+     */
+    getUpdateHistory() {
+        return [...this.cache.history];
+    }
+    /**
+     * Gets the last update check result.
+     */
+    getLastCheckResult() {
+        return this.cache.lastCheck;
+    }
+    /**
+     * Gets the current configuration.
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Updates the configuration.
+     */
+    async updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+    /**
+     * Gets information about the current version and update status.
+     */
+    getVersionInfo() {
+        return {
+            currentVersion: this.packageJson.version,
+            packageName: this.packageJson.name,
+            lastCheck: this.cache.lastCheck,
+            updateAvailable: this.cache.lastCheck?.updateAvailable ?? false,
+            latestVersion: this.cache.lastCheck?.latestVersion,
+        };
+    }
+    /**
+     * Detects the package manager used to install the CLI.
+     */
+    async detectPackageManager() {
+        try {
+            // Check if installed via yarn
+            const { stdout: yarnGlobal } = await execa('yarn', ['global', 'list', '--depth=0'], {
+                shell: true,
+                reject: false,
+            });
+            if (yarnGlobal && yarnGlobal.includes(this.packageJson.name)) {
+                return 'yarn';
+            }
+        }
+        catch {
+            // yarn not available or failed
+        }
+        try {
+            // Check if installed via pnpm
+            const { stdout: pnpmGlobal } = await execa('pnpm', ['list', '-g', '--depth=0'], {
+                shell: true,
+                reject: false,
+            });
+            if (pnpmGlobal && pnpmGlobal.includes(this.packageJson.name)) {
+                return 'pnpm';
+            }
+        }
+        catch {
+            // pnpm not available or failed
+        }
+        // Default to npm
+        return 'npm';
+    }
+}
+// Singleton instance
+let updateServiceInstance = null;
+/**
+ * Gets the singleton UpdateService instance.
+ */
+export async function getUpdateService(config) {
+    if (!updateServiceInstance) {
+        updateServiceInstance = await UpdateService.create(config);
+    }
+    return updateServiceInstance;
+}
+/**
+ * Checks for updates and displays notification if available.
+ * This is the main entry point for startup update checks.
+ */
+export async function checkAndNotifyUpdates(config) {
+    const service = await getUpdateService(config);
+    const result = await service.checkForUpdates();
+    if (result.updateAvailable) {
+        service.displayUpdateNotification(result);
+    }
+    return result;
+}
+/**
+ * Performs a manual update check with full output.
+ */
+export async function manualUpdateCheck() {
+    const service = await getUpdateService();
+    logger.output('');
+    logger.output(chalk.cyan('Checking for updates...'));
+    const result = await service.checkForUpdates(true);
+    if (result.error) {
+        logger.output(chalk.red(`Failed to check for updates: ${result.error}`));
+    }
+    else if (result.updateAvailable) {
+        service.displayUpdateNotification(result);
+    }
+    else {
+        logger.output('');
+        logger.output(chalk.green(`You are on the latest version (${result.currentVersion})`));
+        logger.output('');
+    }
+    return result;
+}
+/**
+ * Formats an update type color indicator for the terminal.
+ */
+function getUpdateTypeIndicator(type) {
+    switch (type) {
+        case 'major':
+            return chalk.red('●');
+        case 'minor':
+            return chalk.yellow('●');
+        case 'patch':
+            return chalk.green('●');
+        case 'prerelease':
+            return chalk.magenta('●');
+        default:
+            return chalk.cyan('●');
+    }
+}
+/**
+ * Checks for updates and returns a discrete status for startup display.
+ * This provides a smart, single-line status message instead of verbose notifications.
+ *
+ * @example
+ * ```typescript
+ * const status = await checkUpdateStatus();
+ * if (status.type === 'available') {
+ *   console.log(status.message); // "● Update available: 1.0.8 → 1.1.0 (npm i -g @compass-ai/nova)"
+ * }
+ * ```
+ */
+export async function checkUpdateStatus(config) {
+    const service = await getUpdateService(config);
+    const versionInfo = service.getVersionInfo();
+    const pkgName = versionInfo.packageName;
+    const currentVersion = versionInfo.currentVersion;
+    logger.debug('Update check: querying npm registry', {
+        packageName: pkgName,
+        currentVersion,
+    });
+    try {
+        const result = await service.checkForUpdates();
+        logger.debug('Update check: npm registry response', {
+            updateAvailable: result.updateAvailable,
+            latestVersion: result.latestVersion,
+            updateType: result.updateType,
+            error: result.error,
+        });
+        if (result.error) {
+            const manualCmd = `npm i -g ${pkgName}`;
+            return {
+                type: 'error',
+                message: chalk.red('✗') + chalk.dim(` Update check failed. Manual upgrade: `) + chalk.cyan(manualCmd),
+                currentVersion,
+                packageName: pkgName,
+                manualCommand: manualCmd,
+            };
+        }
+        if (result.updateAvailable && result.latestVersion) {
+            const indicator = getUpdateTypeIndicator(result.updateType);
+            const manualCmd = `npm i -g ${pkgName}@${result.latestVersion}`;
+            return {
+                type: 'available',
+                message: indicator +
+                    chalk.dim(' Update available: ') +
+                    chalk.dim(currentVersion) +
+                    chalk.dim(' → ') +
+                    chalk.bold(result.latestVersion) +
+                    chalk.dim(` (${manualCmd})`),
+                currentVersion,
+                latestVersion: result.latestVersion,
+                packageName: pkgName,
+                manualCommand: manualCmd,
+            };
+        }
+        return {
+            type: 'up-to-date',
+            message: '', // No message needed when up-to-date
+            currentVersion,
+            packageName: pkgName,
+        };
+    }
+    catch (error) {
+        const manualCmd = `npm i -g ${pkgName}`;
+        return {
+            type: 'error',
+            message: chalk.red('✗') + chalk.dim(` Update check failed. Manual upgrade: `) + chalk.cyan(manualCmd),
+            currentVersion,
+            packageName: pkgName,
+            manualCommand: manualCmd,
+        };
+    }
+}
+/**
+ * Displays the discrete update status line if relevant.
+ * Only outputs a message if there's something to report (available update or error).
+ * Debug logging is always emitted to help diagnose update issues.
+ */
+export async function displayDiscreteUpdateStatus(config) {
+    logger.debug('Update check: starting discrete update status check');
+    const status = await checkUpdateStatus(config);
+    // Log detailed debug info about the update status
+    logger.debug('Update check: completed', {
+        type: status.type,
+        currentVersion: status.currentVersion,
+        latestVersion: status.latestVersion,
+        packageName: status.packageName,
+    });
+    // Only display if there's an update available or an error occurred
+    if (status.type === 'available') {
+        logger.debug(`Update check: new version available (${status.latestVersion})`);
+        console.log(status.message);
+    }
+    else if (status.type === 'error') {
+        logger.debug('Update check: error occurred, showing manual upgrade command');
+        console.log(status.message);
+    }
+    else if (status.type === 'up-to-date') {
+        logger.debug('Update check: already on latest version, no notification shown');
+    }
+    return status;
+}
+/**
+ * Performs auto-update on startup if an update is available.
+ * This function checks for updates and automatically installs if available.
+ * Returns true if an update was performed (CLI should exit for restart).
+ *
+ * @example
+ * ```typescript
+ * const result = await performAutoUpdateOnStartup();
+ * if (result.updated) {
+ *   // CLI will exit, user should restart
+ *   process.exit(0);
+ * }
+ * ```
+ */
+export async function performAutoUpdateOnStartup(config, force = false) {
+    logger.debug('Auto-update: starting startup update check', { force });
+    const service = await getUpdateService(config);
+    const versionInfo = service.getVersionInfo();
+    try {
+        // Check for updates (force bypasses cache interval)
+        const result = await service.checkForUpdates(force);
+        logger.debug('Auto-update: check completed', {
+            updateAvailable: result.updateAvailable,
+            currentVersion: result.currentVersion,
+            latestVersion: result.latestVersion,
+        });
+        if (!result.updateAvailable || !result.latestVersion) {
+            logger.debug('Auto-update: no update available');
+            return { updated: false };
+        }
+        // Update is available - perform auto-update
+        const fromVersion = versionInfo.currentVersion;
+        const toVersion = result.latestVersion;
+        // Detect package manager and perform update
+        const packageManager = await service.detectPackageManager();
+        logger.debug('Auto-update: detected package manager', { packageManager });
+        const success = await service.performUpdate(packageManager);
+        if (success) {
+            return {
+                updated: true,
+                fromVersion,
+                toVersion,
+            };
+        }
+        else {
+            // Update failed - return error but don't exit, let user continue with current version
+            logger.debug('Auto-update: update failed');
+            return {
+                updated: false,
+                error: 'Update failed, continuing with current version',
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        logger.debug('Auto-update: error during update', { error: errorMessage });
+        // Don't block startup on update errors
+        console.log(chalk.yellow(`⚠ Auto-update check failed: ${errorMessage}`));
+        console.log(chalk.dim(`  You can manually update with: npm i -g ${versionInfo.packageName}`));
+        console.log('');
+        return {
+            updated: false,
+            error: errorMessage,
+        };
+    }
+}
+export default UpdateService;
+//# sourceMappingURL=update-service.js.map