@compass-ai/nova 1.0.72 → 1.0.74

package/dist/commands/setup.js

@@ -0,0 +1,863 @@
+/**
+ * Setup command implementation for first-time setup wizard
+ *
+ * This module provides the CLI command for running the first-time setup wizard,
+ * which guides users through:
+ * - Welcome message and introduction
+ * - Data collection consent (GDPR compliant)
+ * - Optional telemetry opt-in
+ * - Anthropic API key configuration
+ *
+ * The setup wizard can be invoked via:
+ * - `compass setup` - Explicit setup command
+ * - Automatically on first run when consent or API key is missing
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getConsentManager } from '../services/consent-manager.js';
+import { getCredentialStore } from '../services/credential-store.js';
+import { getCompassAuthService } from '../services/compass-auth-service.js';
+import { logger } from '../utils/logger.js';
+import { ensureDir } from '../utils/file-system.js';
+import { getGlobalCompassDir } from '../utils/path.js';
+import { renderBanner, renderWelcome } from '../templates/ascii-art.js';
+import { CONSENT_PROMPTS } from '../types/consent.js';
+import { getEventEmitter } from '../core/event-emitter.js';
+import { decryptFernet } from '../utils/crypto.js';
+/**
+ * Application version - should match package.json
+ */
+const VERSION = '1.0.73';
+/**
+ * Checks if setup is required (missing consent or API keys)
+ *
+ * @returns Object indicating whether setup is needed and why
+ */
+export async function checkSetupRequired() {
+    try {
+        const consentManager = await getConsentManager();
+        const consentStatus = await consentManager.getStatus();
+        const credentialStore = await getCredentialStore();
+        const hasCompassApiKey = await credentialStore.hasCompassApiKey();
+        const hasApiKey = await credentialStore.hasApiKey();
+        const missingConsent = !consentStatus.isValid;
+        const missingCompassApiKey = !hasCompassApiKey;
+        const missingApiKey = !hasApiKey;
+        const consentExpired = consentStatus.daysUntilExpiry !== null && consentStatus.daysUntilExpiry <= 0;
+        const consentNeedsRenewal = consentStatus.needsRenewal;
+        return {
+            required: missingConsent || missingApiKey,
+            missingConsent,
+            missingCompassApiKey,
+            missingApiKey,
+            consentExpired,
+            consentNeedsRenewal,
+        };
+    }
+    catch (error) {
+        logger.error('Failed to check setup status', error);
+        // If we can't check, assume setup is required
+        return {
+            required: true,
+            missingConsent: true,
+            missingCompassApiKey: true,
+            missingApiKey: true,
+            consentExpired: false,
+            consentNeedsRenewal: false,
+        };
+    }
+}
+/**
+ * Runs the interactive setup wizard using inquirer (non-React version)
+ * This is used when running `compass setup` directly from the command line
+ *
+ * @returns Promise that resolves when setup is complete or rejects on cancellation
+ */
+export async function runInteractiveSetup() {
+    // Ensure global directory exists
+    await ensureDir(getGlobalCompassDir());
+    // Display welcome banner
+    console.log(renderBanner(VERSION));
+    console.log(renderWelcome());
+    console.log(chalk.bold.cyan('━━━ First-Time Setup Wizard ━━━'));
+    console.log('');
+    console.log(chalk.gray('This wizard will help you configure Compass for first-time use.'));
+    console.log(chalk.gray('Press Ctrl+C at any time to cancel.'));
+    console.log('');
+    // Step 1: Data Collection Consent (Required)
+    console.log(chalk.bold.white('📋 Step 1: Data Collection Consent'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log('');
+    console.log(chalk.bold(CONSENT_PROMPTS.dataCollection.title));
+    console.log(chalk.gray(CONSENT_PROMPTS.dataCollection.description));
+    console.log('');
+    console.log(chalk.gray('This consent is required for Compass to function.'));
+    console.log('');
+    const { dataCollectionConsent } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'dataCollectionConsent',
+            message: 'Do you consent to local data collection?',
+            default: true,
+        },
+    ]);
+    if (!dataCollectionConsent) {
+        console.log('');
+        console.log(chalk.yellow('⚠️  Data collection consent is required to use Compass.'));
+        console.log(chalk.gray('   Setup cancelled.'));
+        console.log('');
+        throw new Error('Setup cancelled: Data collection consent is required');
+    }
+    // Step 2: Optional Telemetry
+    console.log('');
+    console.log(chalk.bold.white('📊 Step 2: Anonymous Telemetry (Optional)'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log('');
+    console.log(chalk.bold(CONSENT_PROMPTS.telemetry.title));
+    console.log(chalk.gray(CONSENT_PROMPTS.telemetry.description));
+    console.log('');
+    console.log(chalk.gray('This is completely optional and helps improve Compass.'));
+    console.log(chalk.gray('No personal data or code content is ever collected.'));
+    console.log('');
+    const { telemetryConsent } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'telemetryConsent',
+            message: 'Enable anonymous telemetry?',
+            default: false,
+        },
+    ]);
+    // Step 3: Error Reporting (Optional)
+    console.log('');
+    console.log(chalk.bold.white('🐛 Step 3: Error Reporting (Optional)'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log('');
+    console.log(chalk.bold(CONSENT_PROMPTS.errorReporting.title));
+    console.log(chalk.gray(CONSENT_PROMPTS.errorReporting.description));
+    console.log('');
+    const { errorReportingConsent } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'errorReportingConsent',
+            message: 'Enable automatic error reporting?',
+            default: true,
+        },
+    ]);
+    // Build consent object
+    const consent = {
+        dataCollection: true,
+        telemetry: telemetryConsent,
+        analytics: telemetryConsent, // Analytics follows telemetry preference
+        errorReporting: errorReportingConsent,
+    };
+    // Step 4: Compass API Key Configuration (Optional)
+    console.log('');
+    console.log(chalk.bold.white('🔑 Step 4: Compass API Key (Optional)'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log('');
+    console.log(chalk.gray('The Compass API key enables:'));
+    console.log(chalk.gray('  • Usage tracking and cost management'));
+    console.log(chalk.gray('  • Automatic retrieval of API keys from your Compass account'));
+    console.log('');
+    console.log(chalk.yellow('This step is OPTIONAL - you can skip it if you don\'t have a Compass account.'));
+    console.log('');
+    const credentialStore = await getCredentialStore();
+    const compassAuthService = getCompassAuthService();
+    const { skipCompassKey } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'skipCompassKey',
+            message: 'Skip Compass API key configuration?',
+            default: false,
+        },
+    ]);
+    let compassApiKey = '';
+    if (!skipCompassKey) {
+        console.log('');
+        console.log(chalk.gray('Get your API key from your Compass account settings.'));
+        console.log(chalk.gray('Your API key will be stored securely using system keychain or encrypted file.'));
+        console.log('');
+        const { key } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'key',
+                message: 'Enter your Compass API key:',
+                mask: '*',
+                validate: async (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed) {
+                        return 'Please enter a valid API key or go back and choose to skip.';
+                    }
+                    // Validate the key with Compass API
+                    try {
+                        console.log(chalk.gray('\n  Validating API key...'));
+                        await compassAuthService.validateApiKey(trimmed);
+                        console.log(chalk.green('  ✓ API key validated successfully'));
+                        return true;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : 'Invalid API key';
+                        return `API key validation failed: ${message}`;
+                    }
+                },
+            },
+        ]);
+        compassApiKey = key;
+    }
+    else {
+        console.log(chalk.yellow('  Skipping Compass API key configuration.'));
+    }
+    // Try to fetch and decrypt Anthropic API key from Compass backend (only if Compass API key provided)
+    let anthropicApiKey = null;
+    if (compassApiKey && compassApiKey.trim()) {
+        console.log('');
+        console.log(chalk.gray('Checking for Anthropic API key in your Compass account...'));
+        logger.info('Attempting to fetch Anthropic API key from Compass backend');
+        try {
+            // Fetch LLM config for claude-sonnet-4-5-20250929
+            logger.debug('Calling getLLMConfig with model: claude-sonnet-4-5-20250929');
+            const llmConfig = await compassAuthService.getLLMConfig('claude-sonnet-4-5-20250929', compassApiKey.trim());
+            logger.debug('LLM config received', {
+                hasConfig: !!llmConfig,
+                hasApiKey: !!llmConfig?.api_key,
+                model: llmConfig?.model,
+                apiType: llmConfig?.api_type,
+                encryptedKeyLength: llmConfig?.api_key?.length || 0
+            });
+            if (llmConfig && llmConfig.api_key) {
+                console.log(chalk.gray('  ✓ Found encrypted API key in your account'));
+                logger.info('Encrypted API key found, attempting decryption');
+                // Try to decrypt the API key using the provider name as password
+                try {
+                    logger.debug('Starting Fernet decryption with password: CLAUDE');
+                    anthropicApiKey = decryptFernet(llmConfig.api_key, 'CLAUDE');
+                    logger.info('✓ Anthropic API key successfully decrypted', { keyLength: anthropicApiKey.length });
+                    console.log(chalk.green('  ✓ Anthropic API key retrieved from your Compass account'));
+                }
+                catch (decryptError) {
+                    const errorMsg = decryptError instanceof Error ? decryptError.message : 'Unknown error';
+                    logger.error('Failed to decrypt Anthropic API key', { error: errorMsg });
+                    console.log(chalk.yellow('  ⚠ Failed to decrypt API key from Compass account'));
+                    console.log(chalk.gray(`    Reason: ${errorMsg}`));
+                    anthropicApiKey = null;
+                }
+            }
+            else {
+                logger.warn('No API key found in LLM config response');
+                console.log(chalk.yellow('  ⚠ No Anthropic API key found in your Compass account'));
+            }
+        }
+        catch (fetchError) {
+            const errorMsg = fetchError instanceof Error ? fetchError.message : 'Unknown error';
+            logger.error('Failed to fetch LLM config from Compass backend', { error: errorMsg });
+            console.log(chalk.yellow('  ⚠ Could not retrieve API key from Compass account'));
+            console.log(chalk.gray(`    Reason: ${errorMsg}`));
+            anthropicApiKey = null;
+        }
+    }
+    else {
+        console.log('');
+        console.log(chalk.yellow('Skipping Compass API key configuration'));
+    }
+    // Step 5: Anthropic API Key Configuration (only if not retrieved from backend)
+    let apiKey;
+    if (anthropicApiKey) {
+        // We already have the API key from the backend, skip asking the user
+        apiKey = anthropicApiKey;
+        console.log('');
+        console.log(chalk.gray('Skipping Anthropic API key entry (already configured in your Compass account)'));
+    }
+    else {
+        // We need to ask the user for the API key
+        console.log('');
+        console.log(chalk.bold.white('🔑 Step 5: Anthropic API Key'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log('');
+        console.log(chalk.gray('Enter your Anthropic API key to enable Claude integration.'));
+        console.log(chalk.gray('Get your API key at: ') + chalk.blue.underline('https://console.anthropic.com/'));
+        console.log('');
+        console.log(chalk.gray('Your API key will be:'));
+        console.log(chalk.green('  ✓ Stored securely using system keychain when available'));
+        console.log(chalk.green('  ✓ Encrypted with AES-256 as fallback'));
+        console.log(chalk.green('  ✓ Never transmitted except to Anthropic\'s API'));
+        console.log('');
+        const { apiKey: userApiKey } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your Anthropic API key:',
+                mask: '*',
+                validate: (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed) {
+                        return 'API key is required to use Compass';
+                    }
+                    if (!credentialStore.validateApiKeyFormat(trimmed)) {
+                        return 'Invalid API key format. Anthropic API keys should start with "sk-ant-"';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        apiKey = userApiKey;
+    }
+    // Step 6: Additional Provider API Keys (Optional)
+    console.log('');
+    console.log(chalk.bold.white('🔌 Step 6: Additional Providers (Optional)'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log('');
+    console.log(chalk.gray('You can configure API keys for additional providers:'));
+    console.log(chalk.gray('  • Ollama - for local/cloud Ollama models'));
+    console.log(chalk.gray('  • Z.AI - for Z.AI GLM models'));
+    console.log(chalk.gray('  • MiniMax - for MiniMax models'));
+    console.log('');
+    console.log(chalk.yellow('This step is OPTIONAL - you can configure these later with "compass setup --api-key".'));
+    console.log('');
+    const { configureAdditionalProviders } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'configureAdditionalProviders',
+            message: 'Configure API keys for additional providers now?',
+            default: false,
+        },
+    ]);
+    const additionalProviderKeys = [];
+    if (configureAdditionalProviders) {
+        const otherProviders = ['ollama', 'zai', 'minimax'];
+        for (const provider of otherProviders) {
+            console.log('');
+            const { configure } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'configure',
+                    message: `Configure ${provider.toUpperCase()} API key?`,
+                    default: false,
+                },
+            ]);
+            if (configure) {
+                const { providerKey } = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'providerKey',
+                        message: `Enter your ${provider.toUpperCase()} API key:`,
+                        mask: '*',
+                        validate: (input) => {
+                            const trimmed = input.trim();
+                            if (!trimmed) {
+                                return 'Please enter an API key or skip this provider.';
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                additionalProviderKeys.push({ provider, apiKey: providerKey.trim() });
+                console.log(chalk.green(`  ✓ ${provider.toUpperCase()} API key captured`));
+            }
+        }
+    }
+    // Save everything
+    console.log('');
+    console.log(chalk.gray('Saving settings...'));
+    try {
+        // Save Compass API key (only if provided)
+        if (compassApiKey && compassApiKey.trim()) {
+            await credentialStore.setCompassApiKey(compassApiKey.trim());
+            logger.info('Compass API key saved successfully');
+        }
+        // Save Anthropic API key (also as provider-specific key)
+        await credentialStore.setApiKey(apiKey.trim());
+        await credentialStore.setProviderApiKey('anthropic', apiKey.trim());
+        logger.info('Anthropic API key saved successfully');
+        // Save additional provider API keys
+        for (const { provider, apiKey: providerApiKey } of additionalProviderKeys) {
+            await credentialStore.setProviderApiKey(provider, providerApiKey);
+            logger.info(`${provider} API key saved successfully`);
+        }
+        // Save consent
+        const consentManager = await getConsentManager();
+        await consentManager.grantConsent(consent);
+        logger.info('Consent saved successfully');
+        // Emit consent changed event
+        const eventEmitter = getEventEmitter();
+        eventEmitter.emit('consent-changed', { granted: true });
+        // Display success message
+        console.log('');
+        console.log(chalk.green.bold('✅ Setup Complete!'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log('');
+        console.log(chalk.gray('Compass has been configured successfully.'));
+        console.log('');
+        console.log(chalk.bold.white('Quick Tips:'));
+        console.log(chalk.gray('  • Run ') + chalk.cyan('compass') + chalk.gray(' to start an interactive session'));
+        console.log(chalk.gray('  • Type natural language requests to interact with Nova'));
+        console.log(chalk.gray('  • Use ') + chalk.cyan('/help') + chalk.gray(' to see available commands'));
+        console.log(chalk.gray('  • Use ') + chalk.cyan('/model') + chalk.gray(' to switch between models'));
+        console.log(chalk.gray('  • Use ') + chalk.cyan('/exit') + chalk.gray(' to exit Nova'));
+        console.log('');
+        console.log(chalk.gray('Your consent settings:'));
+        console.log(chalk.gray('  • Data Collection: ') + chalk.green('Enabled (required)'));
+        console.log(chalk.gray('  • Telemetry: ') + (telemetryConsent ? chalk.green('Enabled') : chalk.yellow('Disabled')));
+        console.log(chalk.gray('  • Error Reporting: ') + (errorReportingConsent ? chalk.green('Enabled') : chalk.yellow('Disabled')));
+        console.log('');
+        console.log(chalk.gray('API keys configured:'));
+        console.log(chalk.gray('  • Anthropic: ') + chalk.green('Configured'));
+        if (compassApiKey && compassApiKey.trim()) {
+            console.log(chalk.gray('  • Compass: ') + chalk.green('Configured'));
+        }
+        for (const { provider } of additionalProviderKeys) {
+            console.log(chalk.gray(`  • ${provider.charAt(0).toUpperCase() + provider.slice(1)}: `) + chalk.green('Configured'));
+        }
+        console.log('');
+        console.log(chalk.gray('You can modify these settings anytime with ') + chalk.cyan('compass consent') + chalk.gray('.'));
+        console.log(chalk.gray('To configure more API keys, run ') + chalk.cyan('compass setup --api-key') + chalk.gray('.'));
+        console.log('');
+    }
+    catch (error) {
+        logger.error('Failed to save setup settings', error);
+        console.log('');
+        console.log(chalk.red('❌ Failed to save settings'));
+        if (error instanceof Error) {
+            console.log(chalk.red(`   ${error.message}`));
+        }
+        throw error;
+    }
+}
+/**
+ * Displays the current setup status
+ */
+export async function displaySetupStatus() {
+    const status = await checkSetupRequired();
+    const credentialStore = await getCredentialStore();
+    console.log('');
+    console.log(chalk.bold.white('🔧 Setup Status'));
+    console.log(chalk.dim('─'.repeat(50)));
+    // Consent status
+    const consentIcon = status.missingConsent ? chalk.red('✗') : chalk.green('✓');
+    const consentText = status.missingConsent
+        ? chalk.red('Not configured')
+        : status.consentExpired
+            ? chalk.yellow('Expired')
+            : status.consentNeedsRenewal
+                ? chalk.yellow('Needs renewal')
+                : chalk.green('Valid');
+    console.log(`  ${chalk.gray('Consent:')}           ${consentIcon} ${consentText}`);
+    // Compass API key status (optional)
+    const compassApiKeyIcon = status.missingCompassApiKey ? chalk.yellow('○') : chalk.green('✓');
+    const compassApiKeyText = status.missingCompassApiKey
+        ? chalk.yellow('Not configured (optional)')
+        : chalk.green('Configured');
+    console.log(`  ${chalk.gray('Compass API Key:')}   ${compassApiKeyIcon} ${compassApiKeyText}`);
+    // Provider-specific API key status
+    console.log('');
+    console.log(chalk.bold.white('  Provider API Keys:'));
+    // Anthropic API key status
+    const apiKeyIcon = status.missingApiKey ? chalk.red('✗') : chalk.green('✓');
+    const apiKeyText = status.missingApiKey
+        ? chalk.red('Not configured')
+        : chalk.green('Configured');
+    console.log(`    ${chalk.gray('Anthropic:')}       ${apiKeyIcon} ${apiKeyText}`);
+    // Check other providers
+    const otherProviders = ['ollama', 'zai', 'minimax'];
+    for (const provider of otherProviders) {
+        const hasKey = await credentialStore.hasProviderApiKey(provider);
+        const providerIcon = hasKey ? chalk.green('✓') : chalk.yellow('○');
+        const providerText = hasKey ? chalk.green('Configured') : chalk.yellow('Not configured');
+        const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
+        console.log(`    ${chalk.gray(`${providerName}:`)}${' '.repeat(11 - providerName.length)}${providerIcon} ${providerText}`);
+    }
+    // Overall status
+    console.log('');
+    if (status.required) {
+        console.log(chalk.yellow('⚠️  Setup is required before using Compass.'));
+        console.log(chalk.gray('   Run "compass setup" to configure.'));
+    }
+    else {
+        console.log(chalk.green('✅ Compass is fully configured and ready to use.'));
+        console.log(chalk.gray('   Run "compass" to start an interactive session.'));
+    }
+    console.log('');
+}
+/**
+ * Reconfigures specific setup components
+ */
+export async function reconfigureSetup(options) {
+    await ensureDir(getGlobalCompassDir());
+    if (options.consent) {
+        console.log('');
+        console.log(chalk.bold.white('📋 Reconfigure Consent Settings'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log('');
+        const { dataCollection } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'dataCollection',
+                message: 'Enable data collection (required)?',
+                default: true,
+            },
+        ]);
+        if (!dataCollection) {
+            console.log(chalk.yellow('⚠️  Data collection is required. Keeping current settings.'));
+            return;
+        }
+        const { telemetry } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'telemetry',
+                message: 'Enable anonymous telemetry?',
+                default: false,
+            },
+        ]);
+        const { errorReporting } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'errorReporting',
+                message: 'Enable error reporting?',
+                default: true,
+            },
+        ]);
+        const consent = {
+            dataCollection: true,
+            telemetry,
+            analytics: telemetry,
+            errorReporting,
+        };
+        const consentManager = await getConsentManager();
+        await consentManager.grantConsent(consent);
+        console.log(chalk.green('✅ Consent settings updated'));
+    }
+    if (options.apiKey) {
+        console.log('');
+        console.log(chalk.bold.white('🔑 Reconfigure API Keys'));
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log('');
+        const credentialStore = await getCredentialStore();
+        // Show available providers
+        console.log(chalk.gray('Available providers:'));
+        console.log(chalk.gray('  1. Anthropic (default for Claude models)'));
+        console.log(chalk.gray('  2. Ollama (for Ollama/cloud models)'));
+        console.log(chalk.gray('  3. Z.AI (for Z.AI GLM models)'));
+        console.log(chalk.gray('  4. MiniMax (for MiniMax models)'));
+        console.log('');
+        const providerOptions = [
+            { name: 'Anthropic', value: 'anthropic' },
+            { name: 'Ollama', value: 'ollama' },
+            { name: 'Z.AI', value: 'zai' },
+            { name: 'MiniMax', value: 'minimax' },
+        ];
+        const { selectedProviders } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedProviders',
+                message: 'Select which providers to configure:',
+                choices: providerOptions,
+                default: ['anthropic'],
+            },
+        ]);
+        for (const provider of selectedProviders) {
+            console.log('');
+            const hasExisting = await credentialStore.hasProviderApiKey(provider);
+            if (hasExisting) {
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `${provider.toUpperCase()} API key is already configured. Replace it?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    console.log(chalk.gray(`${provider.toUpperCase()} API key unchanged.`));
+                    continue;
+                }
+            }
+            const { apiKey } = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'apiKey',
+                    message: `Enter your ${provider.toUpperCase()} API key:`,
+                    mask: '*',
+                    validate: (input) => {
+                        const trimmed = input.trim();
+                        if (!trimmed) {
+                            return 'API key is required';
+                        }
+                        // Only validate format for Anthropic keys
+                        if (provider === 'anthropic' && !credentialStore.validateApiKeyFormat(trimmed)) {
+                            return 'Invalid API key format. Anthropic keys should start with "sk-ant-"';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            await credentialStore.setProviderApiKey(provider, apiKey.trim());
+            // Also update the default API key if this is Anthropic
+            if (provider === 'anthropic') {
+                await credentialStore.setApiKey(apiKey.trim());
+            }
+            console.log(chalk.green(`✅ ${provider.toUpperCase()} API key updated`));
+        }
+    }
+}
+/**
+ * Creates the setup command for the CLI
+ */
+export function createSetupCommand() {
+    const command = new Command('setup')
+        .description('Run first-time setup wizard for consent and API key configuration')
+        .option('--status', 'Display current setup status without running wizard')
+        .option('--consent', 'Reconfigure consent settings only')
+        .option('--api-key', 'Reconfigure API key only')
+        .option('--non-interactive', 'Run in non-interactive mode (requires environment variables)')
+        .option('--compass-key <compass-api-key>', 'Configure Compass API key non-interactively')
+        .option('--validate-key', 'Validate the stored Compass API key without modifying anything')
+        .action(async (options) => {
+        try {
+            // Status check mode
+            if (options.status) {
+                await displaySetupStatus();
+                return;
+            }
+            // Validate stored Compass API key (read-only)
+            if (options.validateKey) {
+                await validateStoredApiKeys();
+                return;
+            }
+            // Direct Compass API key configuration (non-interactive)
+            if (options.compassKey) {
+                await configureCompassApiKey(options.compassKey);
+                return;
+            }
+            // Reconfigure specific components
+            if (options.consent || options.apiKey) {
+                await reconfigureSetup({
+                    consent: options.consent,
+                    apiKey: options.apiKey,
+                });
+                return;
+            }
+            // Non-interactive mode
+            if (options.nonInteractive) {
+                await runNonInteractiveSetup();
+                return;
+            }
+            // Full interactive setup
+            await runInteractiveSetup();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('cancelled')) {
+                // User cancelled, exit gracefully
+                process.exit(0);
+            }
+            logger.error('Setup command failed', error);
+            console.error(chalk.red('❌ Setup failed'));
+            if (error instanceof Error) {
+                console.error(chalk.red(`   ${error.message}`));
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}
+/**
+ * Validates stored API keys for all configured providers.
+ * Checks Compass, Anthropic, and other provider keys.
+ * Exits with code 0 if at least one provider is properly configured,
+ * exits with code 1 if no valid API keys are found.
+ *
+ * Usage: nova setup --validate-key
+ */
+export async function validateStoredApiKeys() {
+    const credentialStore = await getCredentialStore();
+    const compassAuthService = getCompassAuthService();
+    let hasAnyValidKey = false;
+    let hasAnyError = false;
+    console.log(chalk.bold.white('Validating stored API keys...'));
+    console.log('');
+    // 1. Validate Compass API key
+    const hasCompassKey = await credentialStore.hasCompassApiKey();
+    if (hasCompassKey) {
+        try {
+            const storedKey = await credentialStore.getCompassApiKey();
+            if (!storedKey) {
+                console.log(chalk.red('  ✗ Compass: Failed to retrieve stored key'));
+                hasAnyError = true;
+            }
+            else {
+                const result = await compassAuthService.validateApiKey(storedKey);
+                console.log(chalk.green(`  ✓ Compass: Valid (${result.user?.email || 'authenticated'})`));
+                hasAnyValidKey = true;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`  ✗ Compass: Invalid (${message})`));
+            hasAnyError = true;
+        }
+    }
+    else {
+        console.log(chalk.yellow('  ○ Compass: Not configured'));
+    }
+    // 2. Validate Anthropic API key
+    const hasAnthropicKey = await credentialStore.hasApiKey();
+    if (hasAnthropicKey) {
+        try {
+            const storedKey = await credentialStore.getApiKey();
+            if (!storedKey) {
+                console.log(chalk.red('  ✗ Anthropic: Failed to retrieve stored key'));
+                hasAnyError = true;
+            }
+            else if (!credentialStore.validateApiKeyFormat(storedKey)) {
+                console.log(chalk.red('  ✗ Anthropic: Invalid key format (expected "sk-ant-" prefix)'));
+                hasAnyError = true;
+            }
+            else {
+                console.log(chalk.green('  ✓ Anthropic: Valid format'));
+                hasAnyValidKey = true;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk.red(`  ✗ Anthropic: Error (${message})`));
+            hasAnyError = true;
+        }
+    }
+    else {
+        console.log(chalk.yellow('  ○ Anthropic: Not configured'));
+    }
+    // 3. Validate other provider API keys
+    const otherProviders = ['ollama', 'zai', 'minimax'];
+    for (const provider of otherProviders) {
+        const hasKey = await credentialStore.hasProviderApiKey(provider);
+        if (hasKey) {
+            console.log(chalk.green(`  ✓ ${provider.charAt(0).toUpperCase() + provider.slice(1)}: Configured`));
+            hasAnyValidKey = true;
+        }
+    }
+    // Summary
+    console.log('');
+    if (!hasAnyValidKey) {
+        console.log(chalk.red('❌ No valid API keys found'));
+        console.log(chalk.gray('   Run "nova setup" to configure API keys.'));
+        process.exit(1);
+    }
+    else if (hasAnyError) {
+        console.log(chalk.yellow('⚠  Some API keys are invalid or missing'));
+        console.log(chalk.gray('   Run "nova setup --api-key" to reconfigure.'));
+        process.exit(1);
+    }
+    else {
+        console.log(chalk.green('✅ All configured API keys are valid'));
+    }
+}
+/**
+ * Configures a Compass API key non-interactively.
+ * Validates the key against the Compass API before storing it.
+ *
+ * Usage: nova setup --compass-key sk_xxxxxx
+ */
+async function configureCompassApiKey(apiKey) {
+    const trimmedKey = apiKey.trim();
+    if (!trimmedKey) {
+        console.log(chalk.red('❌ Compass API key cannot be empty'));
+        throw new Error('Compass API key cannot be empty');
+    }
+    // Validate against Compass API
+    console.log(chalk.gray('Validating Compass API key...'));
+    const compassAuthService = await getCompassAuthService();
+    try {
+        const result = await compassAuthService.validateApiKey(trimmedKey);
+        console.log(chalk.green(`✓ API key validated (${result.user?.email || 'authenticated'})`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Invalid API key';
+        console.log(chalk.red(`❌ API key validation failed: ${message}`));
+        throw new Error(`Compass API key validation failed: ${message}`);
+    }
+    // Store the key
+    const credentialStore = await getCredentialStore();
+    await credentialStore.setCompassApiKey(trimmedKey);
+    console.log(chalk.green('✓ Compass API key saved'));
+    console.log('');
+    console.log(chalk.green('✅ Compass API key configured successfully'));
+    console.log('');
+}
+/**
+ * Runs setup in non-interactive mode using environment variables
+ * Useful for CI/CD environments or automated deployments
+ */
+async function runNonInteractiveSetup() {
+    console.log(chalk.gray('Running setup in non-interactive mode...'));
+    console.log('');
+    // Check for required environment variables
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        console.log(chalk.red('❌ ANTHROPIC_API_KEY environment variable is required'));
+        console.log(chalk.gray('   Set the environment variable and try again.'));
+        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+    }
+    // Validate API key format
+    const credentialStore = await getCredentialStore();
+    if (!credentialStore.validateApiKeyFormat(apiKey)) {
+        console.log(chalk.red('❌ Invalid API key format in ANTHROPIC_API_KEY'));
+        throw new Error('Invalid API key format');
+    }
+    // Ensure global directory exists
+    await ensureDir(getGlobalCompassDir());
+    // Read optional consent settings from environment
+    const telemetryEnabled = process.env.COMPASS_TELEMETRY === 'true';
+    const errorReportingEnabled = process.env.COMPASS_ERROR_REPORTING !== 'false';
+    // Build consent object
+    const consent = {
+        dataCollection: true, // Always required
+        telemetry: telemetryEnabled,
+        analytics: telemetryEnabled,
+        errorReporting: errorReportingEnabled,
+    };
+    // Save API key
+    await credentialStore.setApiKey(apiKey);
+    console.log(chalk.green('✓ API key configured'));
+    // Save consent
+    const consentManager = await getConsentManager();
+    await consentManager.grantConsent(consent);
+    console.log(chalk.green('✓ Consent configured'));
+    // Emit consent changed event
+    const eventEmitter = getEventEmitter();
+    eventEmitter.emit('consent-changed', { granted: true });
+    console.log('');
+    console.log(chalk.green('✅ Non-interactive setup complete'));
+    console.log('');
+}
+/**
+ * Executes the setup command directly (for use in slash commands or programmatic access)
+ *
+ * @param options - Setup options
+ */
+export async function executeSetupCommand(options = {}) {
+    if (options.status) {
+        await displaySetupStatus();
+        return;
+    }
+    if (options.validateKey) {
+        await validateStoredApiKeys();
+        return;
+    }
+    if (options.compassKey) {
+        await configureCompassApiKey(options.compassKey);
+        return;
+    }
+    if (options.consent || options.apiKey) {
+        await reconfigureSetup({
+            consent: options.consent,
+            apiKey: options.apiKey,
+        });
+        return;
+    }
+    if (options.nonInteractive) {
+        await runNonInteractiveSetup();
+        return;
+    }
+    await runInteractiveSetup();
+}
+export default createSetupCommand;
+//# sourceMappingURL=setup.js.map