@liangjie559567/ultrapower 5.5.20 → 5.5.21

package/dist/features/auto-update.js

@@ -0,0 +1,781 @@
+/**
+ * Auto-Update System
+ *
+ * Provides version checking and auto-update functionality for ultrapower.
+ *
+ * Features:
+ * - Check for new versions from GitHub releases
+ * - Download and install updates automatically
+ * - Store version metadata for installed components
+ * - Configurable update notifications
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { execSync } from 'child_process';
+import { install as installSisyphus, HOOKS_DIR, isProjectScopedPlugin, isRunningAsPlugin } from '../installer/index.js';
+import { getConfigDir } from '../utils/config-dir.js';
+import { syncPluginRegistry } from '../lib/plugin-registry.js';
+import { getRuntimePackageVersion } from '../lib/version.js';
+/** GitHub repository information */
+export const REPO_OWNER = 'liangjie559567';
+export const REPO_NAME = 'ultrapower';
+export const GITHUB_API_URL = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}`;
+export const GITHUB_RAW_URL = `https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}`;
+/**
+ * Best-effort sync of the Claude Code marketplace clone.
+ * The marketplace clone at ~/.claude/plugins/marketplaces/omc/ is used by
+ * Claude Code to populate the plugin cache. If it's stale, `/plugin install`
+ * and cache rebuilds reinstall old versions. (See #506)
+ */
+function syncMarketplaceClone(verbose = false) {
+    const marketplacePath = join(getConfigDir(), 'plugins', 'marketplaces', 'omc');
+    if (!existsSync(marketplacePath)) {
+        return { ok: true, message: 'Marketplace clone not found; skipping' };
+    }
+    const stdio = verbose ? 'inherit' : 'pipe';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- execSync stdio type narrowing
+    const execOpts = { encoding: 'utf-8', stdio: stdio, timeout: 60000 };
+    try {
+        execSync(`git -C "${marketplacePath}" fetch --all --prune`, execOpts);
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to fetch marketplace clone: ${err instanceof Error ? err.message : err}` };
+    }
+    // Ensure we're on main (ignore errors for older clones on different branches)
+    try {
+        execSync(`git -C "${marketplacePath}" checkout main`, { ...execOpts, timeout: 15000 });
+    }
+    catch { /* ignore checkout errors on older clones */ }
+    try {
+        execSync(`git -C "${marketplacePath}" pull --ff-only origin main`, execOpts);
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to update marketplace clone: ${err instanceof Error ? err.message : err}` };
+    }
+    // After successful sync, update registry version from marketplace package.json
+    try {
+        const marketplacePackageJson = join(marketplacePath, 'package.json');
+        if (existsSync(marketplacePackageJson)) {
+            const pkg = JSON.parse(readFileSync(marketplacePackageJson, 'utf-8'));
+            if (pkg.version) {
+                syncPluginRegistry({ newVersion: pkg.version });
+            }
+        }
+    }
+    catch {
+        // Non-fatal: registry sync failure should not block marketplace sync
+    }
+    return { ok: true, message: 'Marketplace clone updated' };
+}
+/** Installation paths (respects CLAUDE_CONFIG_DIR env var) */
+export const CLAUDE_CONFIG_DIR = getConfigDir();
+export const VERSION_FILE = join(CLAUDE_CONFIG_DIR, '.omc-version.json');
+export const CONFIG_FILE = join(CLAUDE_CONFIG_DIR, '.omc-config.json');
+/**
+ * Read the OMC configuration
+ */
+export function getOMCConfig() {
+    if (!existsSync(CONFIG_FILE)) {
+        // No config file = disabled by default for security
+        return { silentAutoUpdate: false };
+    }
+    try {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(content);
+        return {
+            silentAutoUpdate: config.silentAutoUpdate ?? false,
+            configuredAt: config.configuredAt,
+            configVersion: config.configVersion,
+            taskTool: config.taskTool,
+            taskToolConfig: config.taskToolConfig,
+            setupCompleted: config.setupCompleted,
+            setupVersion: config.setupVersion,
+            stopHookCallbacks: config.stopHookCallbacks,
+            notifications: config.notifications,
+            notificationProfiles: config.notificationProfiles,
+            hudEnabled: config.hudEnabled,
+            autoUpgradePrompt: config.autoUpgradePrompt,
+        };
+    }
+    catch {
+        // If config file is invalid, default to disabled for security
+        return { silentAutoUpdate: false };
+    }
+}
+/**
+ * Check if silent auto-updates are enabled
+ */
+export function isSilentAutoUpdateEnabled() {
+    return getOMCConfig().silentAutoUpdate;
+}
+/**
+ * Check if auto-upgrade prompt is enabled at session start
+ * Returns true by default - users must explicitly opt out
+ */
+export function isAutoUpgradePromptEnabled() {
+    return getOMCConfig().autoUpgradePrompt !== false;
+}
+/**
+ * Check if team feature is enabled
+ * Returns false by default - requires explicit opt-in
+ * Checks ~/.claude/settings.json first, then env var fallback
+ */
+export function isTeamEnabled() {
+    try {
+        const settingsPath = join(CLAUDE_CONFIG_DIR, 'settings.json');
+        if (existsSync(settingsPath)) {
+            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            const val = settings.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+            if (val === '1' || val === 'true') {
+                return true;
+            }
+        }
+    }
+    catch {
+        // Fall through to env check
+    }
+    const envVal = process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+    return envVal === '1' || envVal === 'true';
+}
+/**
+ * Read the current version metadata
+ */
+export function getInstalledVersion() {
+    if (!existsSync(VERSION_FILE)) {
+        // Try to detect version from package.json if installed via npm
+        try {
+            // Check if we can find the package in node_modules
+            const result = execSync('npm list -g @liangjie559567/ultrapower --json', {
+                encoding: 'utf-8',
+                timeout: 5000,
+                stdio: 'pipe'
+            });
+            const data = JSON.parse(result);
+            if (data.dependencies?.['@liangjie559567/ultrapower']?.version) {
+                return {
+                    version: data.dependencies['@liangjie559567/ultrapower'].version,
+                    installedAt: new Date().toISOString(),
+                    installMethod: 'npm'
+                };
+            }
+        }
+        catch {
+            // Not installed via npm or command failed
+        }
+        return null;
+    }
+    try {
+        const content = readFileSync(VERSION_FILE, 'utf-8');
+        const metadata = JSON.parse(content);
+        // Cross-check with actual runtime package version to detect stale VERSION_FILE.
+        // This happens when npm updates the package but VERSION_FILE wasn't refreshed
+        // (e.g. manual npm install, or update interrupted before saveVersionMetadata).
+        try {
+            const runtimeVersion = getRuntimePackageVersion();
+            if (runtimeVersion && runtimeVersion !== 'unknown' && runtimeVersion !== metadata.version) {
+                const updated = {
+                    ...metadata,
+                    version: runtimeVersion,
+                    installedAt: metadata.installedAt,
+                    installMethod: metadata.installMethod,
+                };
+                saveVersionMetadata(updated);
+                return updated;
+            }
+        }
+        catch {
+            // getRuntimePackageVersion failed (e.g. running from source) — use VERSION_FILE as-is
+        }
+        return metadata;
+    }
+    catch (error) {
+        console.error('Error reading version file:', error);
+        return null;
+    }
+}
+/**
+ * Save version metadata after installation/update
+ */
+export function saveVersionMetadata(metadata) {
+    const dir = dirname(VERSION_FILE);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(VERSION_FILE, JSON.stringify(metadata, null, 2));
+}
+/**
+ * Update the last check timestamp
+ */
+export function updateLastCheckTime() {
+    const current = getInstalledVersion();
+    if (current) {
+        current.lastCheckAt = new Date().toISOString();
+        saveVersionMetadata(current);
+    }
+}
+/**
+ * Fetch the latest release from GitHub
+ */
+export async function fetchLatestRelease() {
+    const response = await fetch(`${GITHUB_API_URL}/releases/latest`, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'ultrapower-updater'
+        }
+    });
+    if (response.status === 404) {
+        // No releases found - try to get version from package.json in repo
+        const pkgResponse = await fetch(`${GITHUB_RAW_URL}/main/package.json`, {
+            headers: {
+                'User-Agent': 'ultrapower-updater'
+            }
+        });
+        if (pkgResponse.ok) {
+            const pkg = await pkgResponse.json();
+            return {
+                tag_name: `v${pkg.version}`,
+                name: `Version ${pkg.version}`,
+                published_at: new Date().toISOString(),
+                html_url: `https://github.com/${REPO_OWNER}/${REPO_NAME}`,
+                body: 'No release notes available (fetched from package.json)',
+                prerelease: false,
+                draft: false
+            };
+        }
+        throw new Error('No releases found and could not fetch package.json');
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch release info: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+/**
+ * Compare semantic versions
+ * Returns: -1 if a < b, 0 if a == b, 1 if a > b
+ */
+export function compareVersions(a, b) {
+    // Remove 'v' prefix if present
+    const cleanA = a.replace(/^v/, '');
+    const cleanB = b.replace(/^v/, '');
+    const partsA = cleanA.split('.').map(n => parseInt(n, 10) || 0);
+    const partsB = cleanB.split('.').map(n => parseInt(n, 10) || 0);
+    const maxLength = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLength; i++) {
+        const numA = partsA[i] || 0;
+        const numB = partsB[i] || 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Check for available updates
+ */
+export async function checkForUpdates() {
+    const installed = getInstalledVersion();
+    const release = await fetchLatestRelease();
+    const currentVersion = installed?.version ?? null;
+    const latestVersion = release.tag_name.replace(/^v/, '');
+    const updateAvailable = currentVersion === null || compareVersions(currentVersion, latestVersion) < 0;
+    // Update last check time
+    updateLastCheckTime();
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable,
+        releaseInfo: release,
+        releaseNotes: release.body || 'No release notes available.'
+    };
+}
+/**
+ * Reconcile runtime state after update
+ *
+ * This is safe to run repeatedly and refreshes local runtime artifacts that may
+ * lag behind an updated package or plugin cache.
+ */
+export function reconcileUpdateRuntime(options) {
+    const errors = [];
+    const projectScopedPlugin = isProjectScopedPlugin();
+    if (!projectScopedPlugin) {
+        try {
+            if (!existsSync(HOOKS_DIR)) {
+                mkdirSync(HOOKS_DIR, { recursive: true });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to prepare hooks directory: ${message}`);
+        }
+    }
+    try {
+        const installResult = installSisyphus({
+            force: true,
+            verbose: options?.verbose ?? false,
+            skipClaudeCheck: true,
+            forceHooks: true,
+            refreshHooksInPlugin: !projectScopedPlugin,
+        });
+        if (!installResult.success) {
+            errors.push(...installResult.errors);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`Failed to refresh installer artifacts: ${message}`);
+    }
+    if (errors.length > 0) {
+        return {
+            success: false,
+            message: 'Runtime reconciliation failed',
+            errors,
+        };
+    }
+    // Sync plugin registry version after successful reconciliation
+    try {
+        const newVersion = getRuntimePackageVersion();
+        if (newVersion && newVersion !== 'unknown') {
+            syncPluginRegistry({ newVersion, skipIfProjectScoped: projectScopedPlugin });
+        }
+    }
+    catch {
+        // Non-fatal: registry sync failure should not block reconciliation
+    }
+    return {
+        success: true,
+        message: 'Runtime state reconciled successfully',
+    };
+}
+/**
+ * Download and execute the install script to perform an update
+ */
+export async function performUpdate(options) {
+    const installed = getInstalledVersion();
+    const previousVersion = installed?.version ?? null;
+    try {
+        // Check if running as plugin - guide user to correct update path
+        if (isRunningAsPlugin() && !options?.standalone) {
+            // Project-scoped plugin: prompt user to navigate to project directory
+            if (isProjectScopedPlugin()) {
+                return {
+                    success: true,
+                    previousVersion,
+                    newVersion: 'unknown',
+                    message: 'Project-scoped plugin detected.\nTo update, navigate to your project directory and run:\n  /plugin install ultrapower',
+                };
+            }
+            // Fetch latest version for display (best-effort)
+            let latestVersion = 'unknown';
+            try {
+                const release = await fetchLatestRelease();
+                latestVersion = release.tag_name.replace(/^v/, '');
+            }
+            catch { /* ignore */ }
+            // [1/2] Sync marketplace clone
+            process.stdout.write('[1/2] Syncing marketplace... ');
+            const syncResult = syncMarketplaceClone(options?.verbose ?? false);
+            if (!syncResult.ok) {
+                process.stdout.write('⚠\n');
+            }
+            else {
+                process.stdout.write('✓\n');
+                // Update registry version after successful sync
+                try {
+                    if (latestVersion && latestVersion !== 'unknown') {
+                        const { syncPluginRegistry } = await import('../lib/plugin-registry.js');
+                        syncPluginRegistry({ newVersion: latestVersion, skipIfProjectScoped: false });
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            // [2/2] Guide user to complete update
+            const versionHint = latestVersion !== 'unknown'
+                ? ` (current: v${previousVersion ?? 'unknown'} → available: v${latestVersion})`
+                : '';
+            const guidanceMessage = [
+                `[2/2] → Action required: run /plugin install ultrapower to complete update${versionHint}`,
+                '',
+                '  Or pass --standalone to force npm global update.',
+            ].join('\n');
+            return {
+                success: true,
+                previousVersion,
+                newVersion: latestVersion,
+                message: guidanceMessage,
+            };
+        }
+        // Fetch the latest release to get the version
+        const release = await fetchLatestRelease();
+        const newVersion = release.tag_name.replace(/^v/, '');
+        // Use npm for updates on all platforms (install.sh was removed)
+        try {
+            execSync('npm install -g @liangjie559567/ultrapower@latest', {
+                encoding: 'utf-8',
+                stdio: (options?.verbose ? 'inherit' : 'pipe'),
+                timeout: 120000, // 2 minute timeout for npm
+                shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            });
+            // Sync Claude Code marketplace clone so plugin cache picks up new version (#506)
+            const marketplaceSync = syncMarketplaceClone(options?.verbose ?? false);
+            if (!marketplaceSync.ok && options?.verbose) {
+                console.warn(`[omc update] ${marketplaceSync.message}`);
+            }
+            // CRITICAL FIX: After npm updates the global package, the current process
+            // still has OLD code loaded in memory. We must re-exec to run reconciliation
+            // with the NEW code. Otherwise, installSisyphus() runs OLD logic against NEW files.
+            if (!process.env.OMC_UPDATE_RECONCILE) {
+                // Set flag to prevent infinite loop
+                process.env.OMC_UPDATE_RECONCILE = '1';
+                // Find the omc binary path
+                const whichCmd = process.platform === 'win32' ? 'where omc' : 'which omc';
+                const omcPath = execSync(whichCmd, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+                }).trim().split('\n')[0];
+                // Re-exec with reconcile subcommand
+                try {
+                    execSync(`"${omcPath}" update-reconcile`, {
+                        encoding: 'utf-8',
+                        stdio: options?.verbose ? 'inherit' : 'pipe',
+                        timeout: 60000,
+                        env: { ...process.env, OMC_UPDATE_RECONCILE: '1' }
+                    });
+                }
+                catch (reconcileError) {
+                    return {
+                        success: false,
+                        previousVersion,
+                        newVersion,
+                        message: `Updated to ${newVersion}, but runtime reconciliation failed`,
+                        errors: [reconcileError instanceof Error ? reconcileError.message : String(reconcileError)],
+                    };
+                }
+                // Update version metadata after reconciliation succeeds
+                saveVersionMetadata({
+                    version: newVersion,
+                    installedAt: new Date().toISOString(),
+                    installMethod: 'npm',
+                    lastCheckAt: new Date().toISOString()
+                });
+                return {
+                    success: true,
+                    previousVersion,
+                    newVersion,
+                    message: `Successfully updated from ${previousVersion ?? 'unknown'} to ${newVersion}`
+                };
+            }
+            else {
+                // We're in the re-exec'd process - run reconciliation directly
+                const reconcileResult = reconcileUpdateRuntime({ verbose: options?.verbose });
+                if (!reconcileResult.success) {
+                    return {
+                        success: false,
+                        previousVersion,
+                        newVersion,
+                        message: `Updated to ${newVersion}, but runtime reconciliation failed`,
+                        errors: reconcileResult.errors?.map(e => `Reconciliation failed: ${e}`),
+                    };
+                }
+                return {
+                    success: true,
+                    previousVersion,
+                    newVersion,
+                    message: 'Reconciliation completed successfully'
+                };
+            }
+        }
+        catch (npmError) {
+            throw new Error('Auto-update via npm failed. Please run manually:\n' +
+                '  npm install -g @liangjie559567/ultrapower@latest\n' +
+                'Or use: /plugin install ultrapower\n' +
+                `Error: ${npmError instanceof Error ? npmError.message : npmError}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            previousVersion,
+            newVersion: 'unknown',
+            message: `Update failed: ${errorMessage}`,
+            errors: [errorMessage]
+        };
+    }
+}
+/**
+ * Get a formatted update notification message
+ */
+export function formatUpdateNotification(checkResult) {
+    if (!checkResult.updateAvailable) {
+        return `ultrapower is up to date (v${checkResult.currentVersion ?? 'unknown'})`;
+    }
+    const lines = [
+        '╔═══════════════════════════════════════════════════════════╗',
+        '║           ultrapower Update Available!              ║',
+        '╚═══════════════════════════════════════════════════════════╝',
+        '',
+        `  Current version: ${checkResult.currentVersion ?? 'unknown'}`,
+        `  Latest version:  ${checkResult.latestVersion}`,
+        '',
+        isRunningAsPlugin()
+            ? '  To update, run: /plugin install ultrapower'
+            : '  To update, run: /update',
+        ''
+    ];
+    // Add truncated release notes if available
+    if (checkResult.releaseNotes && checkResult.releaseNotes !== 'No release notes available.') {
+        lines.push('  Release notes:');
+        const notes = checkResult.releaseNotes.split('\n').slice(0, 5);
+        notes.forEach(line => lines.push(`    ${line}`));
+        if (checkResult.releaseNotes.split('\n').length > 5) {
+            lines.push('    ...');
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Check if enough time has passed since the last update check
+ */
+export function shouldCheckForUpdates(intervalHours = 24) {
+    const installed = getInstalledVersion();
+    if (!installed?.lastCheckAt) {
+        return true;
+    }
+    const lastCheck = new Date(installed.lastCheckAt).getTime();
+    const now = Date.now();
+    const hoursSinceLastCheck = (now - lastCheck) / (1000 * 60 * 60);
+    return hoursSinceLastCheck >= intervalHours;
+}
+/**
+ * Perform a background update check (non-blocking)
+ */
+export function backgroundUpdateCheck(callback) {
+    if (!shouldCheckForUpdates()) {
+        return;
+    }
+    // Run the check asynchronously without blocking
+    checkForUpdates()
+        .then(result => {
+        if (callback) {
+            callback(result);
+        }
+        else if (result.updateAvailable) {
+            // Default behavior: print notification to console
+            console.log('\n' + formatUpdateNotification(result));
+        }
+    })
+        .catch(error => {
+        // Silently ignore errors in background checks
+        if (process.env.OMC_DEBUG) {
+            console.error('Background update check failed:', error);
+        }
+    });
+}
+/**
+ * CLI helper: perform interactive update
+ */
+export async function interactiveUpdate() {
+    console.log('Checking for updates...');
+    try {
+        const checkResult = await checkForUpdates();
+        if (!checkResult.updateAvailable) {
+            console.log(`✓ You are running the latest version (${checkResult.currentVersion})`);
+            return;
+        }
+        console.log(formatUpdateNotification(checkResult));
+        console.log('Starting update...\n');
+        const result = await performUpdate({ verbose: true });
+        if (result.success) {
+            console.log(`\n✓ ${result.message}`);
+            console.log('\nPlease restart your Claude Code session to use the new version.');
+        }
+        else {
+            console.error(`\n✗ ${result.message}`);
+            if (result.errors) {
+                result.errors.forEach(err => console.error(`  - ${err}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Update check failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+/** State file for tracking silent update status */
+const SILENT_UPDATE_STATE_FILE = join(CLAUDE_CONFIG_DIR, '.omc-silent-update.json');
+/**
+ * Read silent update state
+ */
+function getSilentUpdateState() {
+    if (!existsSync(SILENT_UPDATE_STATE_FILE)) {
+        return { consecutiveFailures: 0, pendingRestart: false };
+    }
+    try {
+        return JSON.parse(readFileSync(SILENT_UPDATE_STATE_FILE, 'utf-8'));
+    }
+    catch {
+        return { consecutiveFailures: 0, pendingRestart: false };
+    }
+}
+/**
+ * Save silent update state
+ */
+function saveSilentUpdateState(state) {
+    const dir = dirname(SILENT_UPDATE_STATE_FILE);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(SILENT_UPDATE_STATE_FILE, JSON.stringify(state, null, 2));
+}
+/**
+ * Log message to silent update log file (if configured)
+ */
+function silentLog(message, logFile) {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] ${message}\n`;
+    if (logFile) {
+        try {
+            const dir = dirname(logFile);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(logFile, logMessage, { flag: 'a' });
+        }
+        catch {
+            // Silently ignore log errors
+        }
+    }
+}
+/**
+ * Perform a completely silent update check and installation
+ *
+ * This function runs without any user interaction or console output.
+ * It's designed to be called from hooks or startup scripts to keep
+ * the system updated automatically without user awareness.
+ *
+ * Features:
+ * - Rate-limited to prevent excessive checks
+ * - Exponential backoff on failures
+ * - Optional logging to file for debugging
+ * - Tracks pending restart state
+ *
+ * @param config - Silent update configuration
+ * @returns Promise resolving to update result or null if skipped
+ */
+export async function silentAutoUpdate(config = {}) {
+    const { checkIntervalHours = 24, autoApply = true, logFile = join(CLAUDE_CONFIG_DIR, '.omc-update.log'), maxRetries = 3 } = config;
+    // SECURITY: Check if silent auto-update is enabled in configuration
+    // Default is disabled - users must explicitly opt-in during installation
+    if (!isSilentAutoUpdateEnabled()) {
+        silentLog('Silent auto-update is disabled (run installer to enable, or use /update)', logFile);
+        return null;
+    }
+    const state = getSilentUpdateState();
+    // Check rate limiting
+    if (!shouldCheckForUpdates(checkIntervalHours)) {
+        return null;
+    }
+    // Check for consecutive failures and apply exponential backoff
+    if (state.consecutiveFailures >= maxRetries) {
+        const backoffHours = Math.min(24 * state.consecutiveFailures, 168); // Max 1 week
+        const lastAttempt = state.lastAttempt ? new Date(state.lastAttempt).getTime() : 0;
+        const hoursSinceLastAttempt = (Date.now() - lastAttempt) / (1000 * 60 * 60);
+        if (hoursSinceLastAttempt < backoffHours) {
+            silentLog(`Skipping update check (in backoff period: ${backoffHours}h)`, logFile);
+            return null;
+        }
+    }
+    silentLog('Starting silent update check...', logFile);
+    state.lastAttempt = new Date().toISOString();
+    try {
+        // Check for updates
+        const checkResult = await checkForUpdates();
+        if (!checkResult.updateAvailable) {
+            silentLog(`No update available (current: ${checkResult.currentVersion})`, logFile);
+            state.consecutiveFailures = 0;
+            state.pendingRestart = false;
+            saveSilentUpdateState(state);
+            return null;
+        }
+        silentLog(`Update available: ${checkResult.currentVersion} -> ${checkResult.latestVersion}`, logFile);
+        if (!autoApply) {
+            silentLog('Auto-apply disabled, skipping installation', logFile);
+            return null;
+        }
+        // Perform the update silently
+        const result = await performUpdate({
+            skipConfirmation: true,
+            verbose: false
+        });
+        if (result.success) {
+            silentLog(`Update successful: ${result.previousVersion} -> ${result.newVersion}`, logFile);
+            state.consecutiveFailures = 0;
+            state.pendingRestart = true;
+            state.lastSuccess = new Date().toISOString();
+            state.lastVersion = result.newVersion;
+            saveSilentUpdateState(state);
+            return result;
+        }
+        else {
+            silentLog(`Update failed: ${result.message}`, logFile);
+            state.consecutiveFailures++;
+            saveSilentUpdateState(state);
+            return result;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        silentLog(`Update check error: ${errorMessage}`, logFile);
+        state.consecutiveFailures++;
+        saveSilentUpdateState(state);
+        return {
+            success: false,
+            previousVersion: null,
+            newVersion: 'unknown',
+            message: `Silent update failed: ${errorMessage}`,
+            errors: [errorMessage]
+        };
+    }
+}
+/**
+ * Check if there's a pending restart after a silent update
+ */
+export function hasPendingUpdateRestart() {
+    const state = getSilentUpdateState();
+    return state.pendingRestart;
+}
+/**
+ * Clear the pending restart flag (call after notifying user or restart)
+ */
+export function clearPendingUpdateRestart() {
+    const state = getSilentUpdateState();
+    state.pendingRestart = false;
+    saveSilentUpdateState(state);
+}
+/**
+ * Get the version that was silently updated to (if pending restart)
+ */
+export function getPendingUpdateVersion() {
+    const state = getSilentUpdateState();
+    return state.pendingRestart ? (state.lastVersion ?? null) : null;
+}
+/**
+ * Initialize silent auto-update on startup
+ *
+ * This is the main entry point for the silent update system.
+ * Call this function once when the application starts or from a hook.
+ * It runs the update check completely in the background without blocking.
+ *
+ * @param config - Silent update configuration
+ */
+export function initSilentAutoUpdate(config = {}) {
+    // Run update check in background without blocking
+    silentAutoUpdate(config).catch(() => {
+        // Silently ignore any errors - they're already logged
+    });
+}
+//# sourceMappingURL=auto-update.js.map