snow-flow 8.5.7 → 8.5.8

package/dist/cli/auth.js

@@ -32,12 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerAuthCommands = registerAuthCommands;
-const chalk_1 = __importDefault(require("chalk"));
+const prompts = __importStar(require("@clack/prompts"));
 const snow_oauth_js_1 = require("../utils/snow-oauth.js");
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const logger_js_1 = require("../utils/logger.js");
@@ -51,44 +48,44 @@ function registerAuthCommands(program) {
         .option('-p, --provider <provider>', 'Provider to list models for (anthropic, openai, google, ollama)')
         .action(async (options) => {
         const { getAllProviderModels, getProviderModels } = await Promise.resolve().then(() => __importStar(require('../utils/dynamic-models.js')));
-        console.log(chalk_1.default.blue('\n🤖 Available LLM Models\n'));
+        prompts.log.step('Available LLM Models');
         if (options.provider) {
             // List models for specific provider
-            console.log(chalk_1.default.cyan(`${options.provider.toUpperCase()}:\n`));
+            prompts.log.info(`${options.provider.toUpperCase()}:`);
             const models = await getProviderModels(options.provider);
             if (models.length > 0) {
                 models.forEach((model, i) => {
-                    console.log(`  ${i + 1}. ${chalk_1.default.white(model.name)}`);
-                    console.log(`     ${chalk_1.default.dim('ID:')} ${chalk_1.default.yellow(model.value)}`);
+                    prompts.log.message(`  ${i + 1}. ${model.name}`);
+                    prompts.log.message(`     ID: ${model.value}`);
                     if (model.contextWindow) {
-                        console.log(`     ${chalk_1.default.dim('Context:')} ${chalk_1.default.green(model.contextWindow.toLocaleString() + ' tokens')}`);
+                        prompts.log.message(`     Context: ${model.contextWindow.toLocaleString()} tokens`);
                     }
                     console.log();
                 });
             }
             else {
-                console.log(chalk_1.default.yellow('  No models available for this provider\n'));
+                prompts.log.warn('  No models available for this provider');
             }
         }
         else {
             // List all providers
             const allModels = await getAllProviderModels();
             for (const [provider, models] of Object.entries(allModels)) {
-                console.log(chalk_1.default.cyan(`${provider.toUpperCase()}:\n`));
+                prompts.log.info(`${provider.toUpperCase()}:`);
                 if (models.length > 0) {
                     models.forEach((model, i) => {
-                        console.log(`  ${i + 1}. ${chalk_1.default.white(model.name)}`);
-                        console.log(`     ${chalk_1.default.dim('ID:')} ${chalk_1.default.yellow(model.value)}`);
+                        prompts.log.message(`  ${i + 1}. ${model.name}`);
+                        prompts.log.message(`     ID: ${model.value}`);
                         console.log();
                     });
                 }
                 else {
-                    console.log(chalk_1.default.yellow('  No models available\n'));
+                    prompts.log.warn('  No models available');
                 }
             }
         }
-        console.log(chalk_1.default.dim('💡 Tip: Use --provider to see models for a specific provider'));
-        console.log(chalk_1.default.dim('Example: snow-flow auth models --provider anthropic\n'));
+        prompts.log.message('Tip: Use --provider to see models for a specific provider');
+        prompts.log.message('Example: snow-flow auth models --provider anthropic');
     });
     auth
         .command('login')
@@ -99,49 +96,46 @@ function registerAuthCommands(program) {
         const path = require('path');
         const inquirer = require('inquirer');
         console.log(); // Empty line for spacing
-        // Step 1: LLM Provider Authentication (OpenCode-style)
-        console.log(chalk_1.default.blue('╭────────────────────────────────────────────╮'));
-        console.log(chalk_1.default.blue('│  Add LLM credential                        │'));
-        console.log(chalk_1.default.blue('╰────────────────────────────────────────────╯\n'));
+        // Step 0: Check if we need LLM authentication
         let provider = process.env.DEFAULT_LLM_PROVIDER;
-        // Check if ANY provider API key is already configured
+        // Check if ANY provider API key is configured
         const hasApiKey = (process.env.ANTHROPIC_API_KEY && process.env.ANTHROPIC_API_KEY.trim() !== '') ||
             (process.env.OPENAI_API_KEY && process.env.OPENAI_API_KEY.trim() !== '') ||
             (process.env.GOOGLE_API_KEY && process.env.GOOGLE_API_KEY.trim() !== '') ||
             (process.env.GROQ_API_KEY && process.env.GROQ_API_KEY.trim() !== '') ||
             (process.env.MISTRAL_API_KEY && process.env.MISTRAL_API_KEY.trim() !== '');
-        // Simplified flow - always ask for provider and API key
+        // Only do SnowCode auth if no API key is configured
         if (!hasApiKey) {
-            // Check if opencode is installed
+            // Check if snowcode is installed
             try {
-                execSync('which opencode', { stdio: 'ignore' });
+                execSync('which snowcode', { stdio: 'ignore' });
             }
             catch {
-                console.error(chalk_1.default.red('❌ OpenCode is not installed'));
-                console.log(chalk_1.default.yellow('Please install OpenCode first: ') + chalk_1.default.cyan('npm install -g opencode-ai'));
-                console.log(chalk_1.default.blue('Or configure an API key in .env: ') + chalk_1.default.cyan('ANTHROPIC_API_KEY=your-key'));
+                prompts.log.error('SnowCode is not installed');
+                prompts.log.warn('Please install SnowCode first: npm install -g @groeimetai/snowcode');
+                prompts.log.info('Or configure an API key in .env: ANTHROPIC_API_KEY=your-key');
                 return;
             }
-            console.log(chalk_1.default.blue('🔐 Authenticating with Anthropic...'));
-            // Fix common OpenCode directory issue (agents vs agent) in ALL possible directories
+            prompts.intro('Starting authentication');
+            // Fix common SnowCode directory issue (agents vs agent) in ALL possible directories
             try {
                 const fs = require('fs');
                 const path = require('path');
                 const directoriesToFix = [
-                    // Fix 1: Global ~/.opencode directory
-                    process.env.HOME + '/.opencode',
+                    // Fix 1: Global ~/.snowcode directory
+                    process.env.HOME + '/.snowcode',
                     // Fix 2: Current working directory
-                    path.join(process.cwd(), '.opencode'),
+                    path.join(process.cwd(), '.snowcode'),
                     // Fix 3: Parent directory (in case we're in a subdirectory)
-                    path.join(process.cwd(), '..', '.opencode'),
+                    path.join(process.cwd(), '..', '.snowcode'),
                     // Fix 4: Snow-flow package directory (for development)
-                    path.join(__dirname, '..', '..', '.opencode')
+                    path.join(__dirname, '..', '..', '.snowcode')
                 ];
-                for (const opencodeDir of directoriesToFix) {
-                    const agentsDir = path.join(opencodeDir, 'agents');
-                    const agentDir = path.join(opencodeDir, 'agent');
+                for (const snowcodeDir of directoriesToFix) {
+                    const agentsDir = path.join(snowcodeDir, 'agents');
+                    const agentDir = path.join(snowcodeDir, 'agent');
                     if (fs.existsSync(agentsDir) && !fs.existsSync(agentDir)) {
-                        console.log(chalk_1.default.dim(`   Fixing OpenCode directory structure in ${opencodeDir}...`));
+                        prompts.log.message(`   Fixing SnowCode directory structure in ${snowcodeDir}...`);
                         try {
                             fs.renameSync(agentsDir, agentDir);
                         }
@@ -152,265 +146,514 @@ function registerAuthCommands(program) {
                 }
             }
             catch (dirError) {
-                // Ignore directory fix errors - OpenCode will handle it
-                console.log(chalk_1.default.dim('   (Directory fix skipped - will auto-correct)'));
+                // Ignore directory fix errors - SnowCode will handle it
+                prompts.log.message('   (Directory fix skipped - will auto-correct)');
             }
             try {
-                // Run opencode auth login interactively
-                execSync('opencode auth login', { stdio: 'inherit' });
-                console.log(chalk_1.default.green('✅ LLM authentication completed\n'));
-                // Ask which provider they used and save it
-                if (!provider || provider.trim() === '') {
-                    const { selectedProvider } = await inquirer.prompt([{
-                            type: 'list',
-                            name: 'selectedProvider',
-                            message: 'Which provider did you just authenticate with?',
-                            choices: [
-                                { name: 'Anthropic (Claude)', value: 'anthropic' },
-                                { name: 'OpenAI (GPT)', value: 'openai' },
-                                { name: 'Google (Gemini)', value: 'google' },
-                                { name: 'Ollama (Local)', value: 'ollama' },
-                                { name: 'Other', value: 'other' }
-                            ]
-                        }]);
-                    if (selectedProvider !== 'other') {
-                        // Dynamically fetch latest models from provider APIs
-                        const { getProviderModels } = await Promise.resolve().then(() => __importStar(require('../utils/dynamic-models.js')));
-                        console.log(chalk_1.default.dim(`   Fetching latest ${selectedProvider} models...`));
-                        const models = await getProviderModels(selectedProvider);
-                        // Ask for preferred model
-                        let selectedModel = '';
-                        if (models && models.length > 0) {
-                            const choices = models.map(m => ({
-                                name: m.name,
-                                value: m.value
-                            }));
-                            const { chosenModel } = await inquirer.prompt([{
-                                    type: 'list',
-                                    name: 'chosenModel',
-                                    message: `Which ${selectedProvider} model do you want to use by default?`,
-                                    choices: choices
-                                }]);
-                            selectedModel = chosenModel;
-                        }
-                        else {
-                            console.log(chalk_1.default.yellow(`   ⚠️  Could not fetch models for ${selectedProvider}, skipping model selection`));
-                        }
-                        // Save provider AND model to .env file
-                        const envPath = path.join(process.cwd(), '.env');
-                        let envContent = '';
-                        try {
-                            envContent = fs.readFileSync(envPath, 'utf8');
-                        }
-                        catch {
-                            // .env doesn't exist yet, use .env.example as template
-                            const examplePath = path.join(process.cwd(), '.env.example');
-                            if (fs.existsSync(examplePath)) {
-                                envContent = fs.readFileSync(examplePath, 'utf8');
-                            }
-                        }
-                        // Update DEFAULT_LLM_PROVIDER in .env content
-                        if (envContent.includes('DEFAULT_LLM_PROVIDER=')) {
-                            envContent = envContent.replace(/DEFAULT_LLM_PROVIDER=.*/g, `DEFAULT_LLM_PROVIDER=${selectedProvider}`);
-                        }
-                        else {
-                            envContent += `\nDEFAULT_LLM_PROVIDER=${selectedProvider}\n`;
-                        }
-                        // Update DEFAULT_MODEL in .env content
-                        if (selectedModel) {
-                            if (envContent.includes('DEFAULT_MODEL=')) {
-                                envContent = envContent.replace(/DEFAULT_MODEL=.*/g, `DEFAULT_MODEL=${selectedModel}`);
-                            }
-                            else {
-                                envContent += `DEFAULT_MODEL=${selectedModel}\n`;
-                            }
-                        }
-                        fs.writeFileSync(envPath, envContent);
-                        console.log(chalk_1.default.green(`✅ Provider saved: ${selectedProvider}`));
-                        if (selectedModel) {
-                            console.log(chalk_1.default.green(`✅ Default model saved: ${selectedModel}\n`));
-                        }
-                        else {
-                            console.log();
-                        }
-                        provider = selectedProvider;
-                        process.env.DEFAULT_LLM_PROVIDER = provider;
-                        if (selectedModel) {
-                            process.env.DEFAULT_MODEL = selectedModel;
-                        }
-                    }
+                // Run SnowCode auth login - prefer local installation (has platform binaries)
+                const localSnowCode = path.join(process.cwd(), 'node_modules', '@groeimetai', 'snowcode', 'bin', 'snowcode');
+                let snowcodeCommand = 'snowcode'; // fallback to global
+                if (fs.existsSync(localSnowCode)) {
+                    prompts.log.message('   Using local SnowCode installation (with platform binaries)');
+                    snowcodeCommand = `"${localSnowCode}"`;
+                }
+                else {
+                    prompts.log.message('   Using global SnowCode installation');
                 }
+                execSync(`${snowcodeCommand} auth login`, { stdio: 'inherit' });
             }
             catch (error) {
-                console.error(chalk_1.default.red('\n❌ LLM authentication failed'));
-                // Check if it's the known OpenCode directory bug
+                prompts.log.error('Authentication failed');
+                // Check if it's the bun dependency error
                 const errorMsg = error?.message || error?.toString() || '';
-                if (errorMsg.includes('agents') && errorMsg.includes('agent')) {
-                    console.log(chalk_1.default.yellow('\n⚠️  OpenCode directory issue detected'));
-                    console.log(chalk_1.default.blue('   Run this fix: ') + chalk_1.default.cyan('mv ~/.opencode/agents ~/.opencode/agent'));
-                    console.log(chalk_1.default.blue('   Then try: ') + chalk_1.default.cyan('snow-flow auth login'));
+                if (errorMsg.includes('Cannot find package \'bun\'') || errorMsg.includes('ERR_MODULE_NOT_FOUND')) {
+                    prompts.log.warn('SnowCode dependency issue detected');
+                    prompts.log.message('   This is a known issue with SnowCode versions 0.15.18 and earlier');
+                    prompts.log.message('   Please update SnowCode to the latest version:');
+                    prompts.log.message('   npm update -g @groeimetai/snowcode');
+                    prompts.log.message('   Alternatively, use an API key instead:');
+                    prompts.log.message('   1. Add to .env: ANTHROPIC_API_KEY=your-api-key');
+                    prompts.log.message('   2. Then run: snow-flow auth login');
+                }
+                else if (errorMsg.includes('agents') && errorMsg.includes('agent')) {
+                    prompts.log.warn('SnowCode directory issue detected');
+                    prompts.log.message('   Run this fix: mv ~/.snowcode/agents ~/.snowcode/agent');
+                    prompts.log.message('   Then try: snow-flow auth login');
                 }
                 else {
-                    console.log(chalk_1.default.yellow('💡 You can try again later or use an API key instead'));
-                    console.log(chalk_1.default.blue('   Add to .env: ') + chalk_1.default.cyan('ANTHROPIC_API_KEY=your-api-key'));
+                    prompts.log.warn('You can try again later or use an API key instead');
+                    prompts.log.message('   Add to .env: ANTHROPIC_API_KEY=your-api-key');
                 }
                 return;
             }
         }
-        // Step 2: ServiceNow OAuth authentication
-        console.log(chalk_1.default.blue('🔐 Authenticating with ServiceNow...'));
-        const oauth = new snow_oauth_js_1.ServiceNowOAuth();
+        // ServiceNow setup - continue the flow (maintain @clack/prompts styling)
         // Read credentials from .env file
         let instance = process.env.SNOW_INSTANCE;
-        let clientId = process.env.SNOW_CLIENT_ID;
-        let clientSecret = process.env.SNOW_CLIENT_SECRET;
-        // Validate credentials (check if they exist AND are valid)
-        const credentialsValid = instance && instance.trim() !== '' && instance.includes('.service-now.com') &&
-            clientId && clientId.trim() !== '' && clientId.length >= 32 &&
-            clientSecret && clientSecret.trim() !== '' && clientSecret.length >= 32;
-        // If credentials are missing or invalid, ask user interactively
-        if (!credentialsValid) {
-            if (instance || clientId || clientSecret) {
-                console.log(chalk_1.default.yellow('\n⚠️  Invalid ServiceNow OAuth credentials detected in .env'));
-                if (instance && !instance.includes('.service-now.com')) {
-                    console.log(chalk_1.default.red('   ❌ Instance URL must be a .service-now.com domain'));
-                }
-                if (clientId && clientId.length < 32) {
-                    console.log(chalk_1.default.red('   ❌ Client ID too short (expected 32+ characters)'));
-                }
-                if (clientSecret && clientSecret.length < 32) {
-                    console.log(chalk_1.default.red('   ❌ Client Secret too short (expected 32+ characters)'));
-                }
+        let authMethod = process.env.SNOW_AUTH_METHOD;
+        // Check if we have complete credentials for either method
+        const hasOAuthCreds = process.env.SNOW_CLIENT_ID && process.env.SNOW_CLIENT_SECRET;
+        const hasBasicCreds = process.env.SNOW_USERNAME && process.env.SNOW_PASSWORD;
+        const hasCompleteCredentials = instance && instance.includes('.service-now.com') &&
+            ((authMethod === 'oauth' && hasOAuthCreds) || (authMethod === 'basic' && hasBasicCreds));
+        // If no complete credentials, ask for auth method FIRST
+        if (!hasCompleteCredentials) {
+            const method = await prompts.select({
+                message: 'Choose authentication method',
+                options: [
+                    { value: 'oauth', label: 'OAuth 2.0', hint: 'recommended' },
+                    { value: 'basic', label: 'Basic Auth', hint: 'username/password' }
+                ]
+            });
+            if (prompts.isCancel(method)) {
+                prompts.cancel('Setup cancelled');
+                process.exit(0);
             }
-            else {
-                console.log(chalk_1.default.yellow('\n⚠️  ServiceNow OAuth credentials not found in .env'));
-            }
-            console.log(chalk_1.default.dim('   You need to set up OAuth in ServiceNow first\n'));
-            const { setupNow } = await inquirer.prompt([{
-                    type: 'confirm',
-                    name: 'setupNow',
-                    message: 'Do you want to enter your ServiceNow OAuth credentials now?',
-                    default: true
-                }]);
-            if (!setupNow) {
-                console.log(chalk_1.default.yellow('\n💡 To set up OAuth credentials manually:'));
-                console.log('   1. Log into ServiceNow as admin');
-                console.log('   2. Navigate to: System OAuth > Application Registry');
-                console.log('   3. Create a new OAuth application');
-                console.log('   4. Add these to your .env file:');
-                console.log('      SNOW_INSTANCE=your-instance.service-now.com');
-                console.log('      SNOW_CLIENT_ID=your-client-id');
-                console.log('      SNOW_CLIENT_SECRET=your-client-secret');
-                console.log('\n   Then run: snow-flow auth login');
-                return;
+            authMethod = method;
+            // Ask for ServiceNow instance (common for both methods)
+            instance = await prompts.text({
+                message: 'ServiceNow instance',
+                placeholder: 'dev12345.service-now.com',
+                defaultValue: instance || '',
+                validate: (value) => {
+                    if (!value || value.trim() === '')
+                        return 'Instance URL is required';
+                    const cleaned = value.replace(/^https?:\/\//, '').replace(/\/$/, '');
+                    if (!cleaned.includes('.service-now.com')) {
+                        return 'Must be a ServiceNow domain (e.g., dev12345.service-now.com)';
+                    }
+                }
+            });
+            if (prompts.isCancel(instance)) {
+                prompts.cancel('Setup cancelled');
+                process.exit(0);
             }
-            console.log(chalk_1.default.blue('\n📋 ServiceNow OAuth Setup'));
-            console.log(chalk_1.default.dim('   Need help? See: https://docs.servicenow.com/oauth\n'));
-            const credentials = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'instance',
-                    message: 'ServiceNow instance (e.g., dev12345.service-now.com):',
-                    default: instance,
-                    validate: (input) => {
-                        if (!input || input.trim() === '') {
-                            return 'Instance URL is required';
-                        }
-                        // Remove https:// and trailing slash if present
-                        const cleaned = input.replace(/^https?:\/\//, '').replace(/\/$/, '');
-                        if (!cleaned.includes('.service-now.com')) {
-                            return 'Instance must be a ServiceNow domain (e.g., dev12345.service-now.com)';
-                        }
-                        return true;
-                    },
-                    filter: (input) => input.replace(/^https?:\/\//, '').replace(/\/$/, '')
-                },
-                {
-                    type: 'input',
-                    name: 'clientId',
-                    message: 'OAuth Client ID:',
-                    default: clientId,
-                    validate: (input) => {
-                        if (!input || input.trim() === '') {
+            instance = instance.replace(/^https?:\/\//, '').replace(/\/$/, '');
+        }
+        // OAuth 2.0 Flow
+        if (authMethod === 'oauth') {
+            const oauth = new snow_oauth_js_1.ServiceNowOAuth();
+            let clientId = process.env.SNOW_CLIENT_ID;
+            let clientSecret = process.env.SNOW_CLIENT_SECRET;
+            // Check if OAuth credentials need to be collected
+            const needsCredentials = !clientId || !clientSecret || clientId.length < 32 || clientSecret.length < 32;
+            // If credentials are missing, prompt for them
+            if (needsCredentials) {
+                // OAuth Client ID
+                clientId = await prompts.text({
+                    message: 'OAuth Client ID',
+                    placeholder: '32-character hex string from ServiceNow',
+                    defaultValue: clientId || '',
+                    validate: (value) => {
+                        if (!value || value.trim() === '')
                             return 'Client ID is required';
-                        }
-                        if (input.length < 32) {
-                            return 'Client ID seems too short. Expected a 32-character hex string from ServiceNow';
-                        }
-                        return true;
+                        if (value.length < 32)
+                            return 'Client ID too short (expected 32+ characters)';
                     }
-                },
-                {
-                    type: 'password',
-                    name: 'clientSecret',
-                    message: 'OAuth Client Secret:',
-                    mask: '*',
-                    validate: (input) => {
-                        if (!input || input.trim() === '') {
+                });
+                if (prompts.isCancel(clientId)) {
+                    prompts.cancel('Setup cancelled');
+                    process.exit(0);
+                }
+                // OAuth Client Secret
+                clientSecret = await prompts.password({
+                    message: 'OAuth Client Secret',
+                    validate: (value) => {
+                        if (!value || value.trim() === '')
                             return 'Client Secret is required';
-                        }
-                        if (input.length < 32) {
-                            return 'Client Secret too short. Expected 32+ character random string from ServiceNow';
-                        }
-                        return true;
+                        if (value.length < 32)
+                            return 'Client Secret too short (expected 32+ characters)';
                     }
+                });
+                if (prompts.isCancel(clientSecret)) {
+                    prompts.cancel('Setup cancelled');
+                    process.exit(0);
                 }
-            ]);
-            instance = credentials.instance;
-            clientId = credentials.clientId;
-            clientSecret = credentials.clientSecret;
-            // Save to .env file
-            const envPath = path.join(process.cwd(), '.env');
-            let envContent = '';
-            try {
-                envContent = fs.readFileSync(envPath, 'utf8');
-            }
-            catch {
-                // .env doesn't exist yet, use .env.example as template
-                const examplePath = path.join(process.cwd(), '.env.example');
-                if (fs.existsSync(examplePath)) {
-                    envContent = fs.readFileSync(examplePath, 'utf8');
+                // Save to .env file
+                const envPath = path.join(process.cwd(), '.env');
+                let envContent = '';
+                try {
+                    envContent = fs.readFileSync(envPath, 'utf8');
+                }
+                catch {
+                    const examplePath = path.join(process.cwd(), '.env.example');
+                    if (fs.existsSync(examplePath)) {
+                        envContent = fs.readFileSync(examplePath, 'utf8');
+                    }
+                }
+                // Update credentials
+                const updates = [
+                    { key: 'SNOW_INSTANCE', value: instance },
+                    { key: 'SNOW_AUTH_METHOD', value: 'oauth' },
+                    { key: 'SNOW_CLIENT_ID', value: clientId },
+                    { key: 'SNOW_CLIENT_SECRET', value: clientSecret }
+                ];
+                for (const { key, value } of updates) {
+                    if (envContent.includes(`${key}=`)) {
+                        envContent = envContent.replace(new RegExp(`${key}=.*`, 'g'), `${key}=${value}`);
+                    }
+                    else {
+                        envContent += `\n${key}=${value}\n`;
+                    }
                 }
+                fs.writeFileSync(envPath, envContent);
+                process.env.SNOW_INSTANCE = instance;
+                process.env.SNOW_AUTH_METHOD = 'oauth';
+                process.env.SNOW_CLIENT_ID = clientId;
+                process.env.SNOW_CLIENT_SECRET = clientSecret;
             }
-            // Update credentials in .env content
-            const updates = [
-                { key: 'SNOW_INSTANCE', value: instance },
-                { key: 'SNOW_CLIENT_ID', value: clientId },
-                { key: 'SNOW_CLIENT_SECRET', value: clientSecret }
-            ];
-            for (const { key, value } of updates) {
-                if (envContent.includes(`${key}=`)) {
-                    envContent = envContent.replace(new RegExp(`${key}=.*`, 'g'), `${key}=${value}`);
+            // Start OAuth flow with localhost callback server
+            const result = await oauth.authenticate(instance, clientId, clientSecret);
+            if (result.success) {
+                prompts.log.success('ServiceNow authentication successful');
+                // Test connection
+                const client = new servicenow_client_js_1.ServiceNowClient();
+                const testResult = await client.testConnection();
+                if (testResult.success) {
+                    prompts.log.success(`Logged in as: ${testResult.data.name} (${testResult.data.user_name})`);
                 }
-                else {
-                    envContent += `\n${key}=${value}\n`;
+                // 🔧 Auto-refresh MCP configuration with new credentials
+                try {
+                    const { setupMCPConfig } = await Promise.resolve().then(() => __importStar(require('../cli.js')));
+                    const spinner2 = prompts.spinner();
+                    spinner2.start('Updating MCP configuration');
+                    await setupMCPConfig(process.cwd(), instance, clientId, clientSecret, true);
+                    spinner2.stop('MCP servers ready for SnowCode/Claude Code');
+                }
+                catch (error) {
+                    prompts.log.warn('Could not update MCP config - run "snow-flow init" to set up');
                 }
+                prompts.outro('Setup complete!');
+            }
+            else {
+                prompts.cancel(result.error || 'Unknown error');
+                process.exit(1);
             }
-            fs.writeFileSync(envPath, envContent);
-            console.log(chalk_1.default.green('\n✅ Credentials saved to .env file\n'));
-            // Reload environment variables
-            process.env.SNOW_INSTANCE = instance;
-            process.env.SNOW_CLIENT_ID = clientId;
-            process.env.SNOW_CLIENT_SECRET = clientSecret;
         }
-        // Start OAuth flow (this opens browser automatically)
-        const result = await oauth.authenticate(instance, clientId, clientSecret);
-        if (result.success) {
-            console.log(chalk_1.default.green('✅ ServiceNow authentication successful!'));
-            // Test connection
+        // Basic Auth Flow
+        else if (authMethod === 'basic') {
+            let username = process.env.SNOW_USERNAME;
+            let password = process.env.SNOW_PASSWORD;
+            // Check if Basic Auth credentials need to be collected
+            const needsCredentials = !username || !password || username.trim() === '' || password.trim() === '';
+            if (needsCredentials) {
+                // Username
+                username = await prompts.text({
+                    message: 'ServiceNow username',
+                    placeholder: 'admin',
+                    defaultValue: username || '',
+                    validate: (value) => {
+                        if (!value || value.trim() === '')
+                            return 'Username is required';
+                    }
+                });
+                if (prompts.isCancel(username)) {
+                    prompts.cancel('Setup cancelled');
+                    process.exit(0);
+                }
+                // Password
+                password = await prompts.password({
+                    message: 'ServiceNow password',
+                    validate: (value) => {
+                        if (!value || value.trim() === '')
+                            return 'Password is required';
+                    }
+                });
+                if (prompts.isCancel(password)) {
+                    prompts.cancel('Setup cancelled');
+                    process.exit(0);
+                }
+                // Save to .env file
+                const envPath = path.join(process.cwd(), '.env');
+                let envContent = '';
+                try {
+                    envContent = fs.readFileSync(envPath, 'utf8');
+                }
+                catch {
+                    const examplePath = path.join(process.cwd(), '.env.example');
+                    if (fs.existsSync(examplePath)) {
+                        envContent = fs.readFileSync(examplePath, 'utf8');
+                    }
+                }
+                // Update credentials
+                const updates = [
+                    { key: 'SNOW_INSTANCE', value: instance },
+                    { key: 'SNOW_AUTH_METHOD', value: 'basic' },
+                    { key: 'SNOW_USERNAME', value: username },
+                    { key: 'SNOW_PASSWORD', value: password }
+                ];
+                for (const { key, value } of updates) {
+                    if (envContent.includes(`${key}=`)) {
+                        envContent = envContent.replace(new RegExp(`${key}=.*`, 'g'), `${key}=${value}`);
+                    }
+                    else {
+                        envContent += `\n${key}=${value}\n`;
+                    }
+                }
+                fs.writeFileSync(envPath, envContent);
+                process.env.SNOW_INSTANCE = instance;
+                process.env.SNOW_AUTH_METHOD = 'basic';
+                process.env.SNOW_USERNAME = username;
+                process.env.SNOW_PASSWORD = password;
+            }
+            // Test Basic Auth connection
+            const spinner = prompts.spinner();
+            spinner.start('Authenticating with ServiceNow');
             const client = new servicenow_client_js_1.ServiceNowClient();
             const testResult = await client.testConnection();
             if (testResult.success) {
-                console.log(chalk_1.default.green(`✅ Logged in as: ${testResult.data.name} (${testResult.data.user_name})`));
+                spinner.stop('ServiceNow authentication successful');
+                prompts.log.success(`Logged in as: ${testResult.data.name} (${testResult.data.user_name})`);
+                // 🔧 Auto-refresh MCP configuration with new credentials
+                try {
+                    const { setupMCPConfig } = await Promise.resolve().then(() => __importStar(require('../cli.js')));
+                    const spinner2 = prompts.spinner();
+                    spinner2.start('Updating MCP configuration');
+                    await setupMCPConfig(process.cwd(), instance, username, password, true);
+                    spinner2.stop('MCP servers ready for SnowCode/Claude Code');
+                }
+                catch (error) {
+                    prompts.log.warn('Could not update MCP config - run "snow-flow init" to set up');
+                }
+                prompts.outro('Setup complete!');
+            }
+            else {
+                spinner.stop('Authentication failed');
+                prompts.cancel(testResult.error || 'Invalid credentials');
+                process.exit(1);
             }
-            console.log(chalk_1.default.blue('\n🎉 Ready to start developing!'));
-            console.log(chalk_1.default.cyan('   snow-flow swarm "create incident dashboard"'));
-            console.log(chalk_1.default.dim('   or: ') + chalk_1.default.cyan('opencode\n'));
         }
-        else {
-            console.error(chalk_1.default.red(`\n❌ ServiceNow authentication failed: ${result.error}`));
-            process.exit(1);
+        // ═══════════════════════════════════════════════════════════════════
+        // 🚀 ENTERPRISE FEATURES SETUP (Optional)
+        // ═══════════════════════════════════════════════════════════════════
+        console.log(); // Spacing
+        prompts.log.step('Enterprise Features (Optional)');
+        const hasEnterprise = await prompts.confirm({
+            message: 'Do you have a Snow-Flow Enterprise license?',
+            initialValue: false
+        });
+        if (prompts.isCancel(hasEnterprise) || !hasEnterprise) {
+            prompts.log.info('Skipping enterprise setup - you can add it later with "snow-flow auth login"');
+            prompts.outro('Setup complete!');
+            return;
+        }
+        // Enterprise license key
+        const licenseKey = await prompts.text({
+            message: 'Enterprise license key',
+            placeholder: 'SNOW-ENT-YOURCOMPANY-20261231-ABC123',
+            validate: (value) => {
+                if (!value || value.trim() === '')
+                    return 'License key is required';
+                if (!value.startsWith('SNOW-'))
+                    return 'Invalid format (should start with SNOW-)';
+                const parts = value.split('-');
+                if (parts.length !== 5)
+                    return 'Invalid format (expected: SNOW-TIER-ORG-DATE-HASH)';
+            }
+        });
+        if (prompts.isCancel(licenseKey)) {
+            prompts.log.info('Enterprise setup skipped');
+            prompts.outro('Setup complete!');
+            return;
+        }
+        // License server URL (with sensible default)
+        const licenseServerUrl = await prompts.text({
+            message: 'Enterprise license server URL',
+            placeholder: 'https://license.snow-flow.dev',
+            defaultValue: 'https://license.snow-flow.dev',
+            validate: (value) => {
+                if (!value || value.trim() === '')
+                    return 'URL is required';
+                if (!value.startsWith('https://'))
+                    return 'Must be HTTPS URL';
+            }
+        });
+        if (prompts.isCancel(licenseServerUrl)) {
+            prompts.log.info('Enterprise setup skipped');
+            prompts.outro('Setup complete!');
+            return;
+        }
+        // Ask which integrations to configure
+        const integrations = await prompts.multiselect({
+            message: 'Configure integrations (optional)',
+            options: [
+                { value: 'jira', label: 'Jira', hint: 'Atlassian Jira Cloud' },
+                { value: 'azdo', label: 'Azure DevOps', hint: 'Microsoft Azure DevOps' },
+                { value: 'confluence', label: 'Confluence', hint: 'Atlassian Confluence' }
+            ],
+            required: false
+        });
+        const enterpriseEnv = {
+            SNOW_LICENSE_KEY: licenseKey,
+            SNOW_ENTERPRISE_URL: licenseServerUrl
+        };
+        // Jira credentials
+        if (integrations && integrations.includes('jira')) {
+            prompts.log.message('Jira Configuration');
+            const jiraHost = await prompts.text({
+                message: 'Jira host',
+                placeholder: 'yourcompany.atlassian.net',
+                validate: (v) => v && v.includes('.') ? undefined : 'Invalid host'
+            });
+            if (!prompts.isCancel(jiraHost)) {
+                const jiraEmail = await prompts.text({
+                    message: 'Jira email',
+                    placeholder: 'you@company.com',
+                    validate: (v) => v && v.includes('@') ? undefined : 'Invalid email'
+                });
+                if (!prompts.isCancel(jiraEmail)) {
+                    const jiraToken = await prompts.password({
+                        message: 'Jira API token',
+                        validate: (v) => v && v.length > 10 ? undefined : 'Token required'
+                    });
+                    if (!prompts.isCancel(jiraToken)) {
+                        enterpriseEnv.JIRA_BASE_URL = `https://${jiraHost}`;
+                        enterpriseEnv.JIRA_EMAIL = jiraEmail;
+                        enterpriseEnv.JIRA_API_TOKEN = jiraToken;
+                        prompts.log.success('Jira configured');
+                    }
+                }
+            }
+        }
+        // Azure DevOps credentials
+        if (integrations && integrations.includes('azdo')) {
+            prompts.log.message('Azure DevOps Configuration');
+            const azdoOrg = await prompts.text({
+                message: 'Azure DevOps organization',
+                placeholder: 'yourcompany',
+                validate: (v) => v && v.length > 0 ? undefined : 'Organization required'
+            });
+            if (!prompts.isCancel(azdoOrg)) {
+                const azdoPat = await prompts.password({
+                    message: 'Azure DevOps Personal Access Token (PAT)',
+                    validate: (v) => v && v.length > 20 ? undefined : 'PAT required'
+                });
+                if (!prompts.isCancel(azdoPat)) {
+                    enterpriseEnv.AZDO_ORG_URL = `https://dev.azure.com/${azdoOrg}`;
+                    enterpriseEnv.AZDO_PAT = azdoPat;
+                    prompts.log.success('Azure DevOps configured');
+                }
+            }
+        }
+        // Confluence credentials
+        if (integrations && integrations.includes('confluence')) {
+            prompts.log.message('Confluence Configuration');
+            const confluenceHost = await prompts.text({
+                message: 'Confluence host',
+                placeholder: 'yourcompany.atlassian.net',
+                validate: (v) => v && v.includes('.') ? undefined : 'Invalid host'
+            });
+            if (!prompts.isCancel(confluenceHost)) {
+                const confluenceEmail = await prompts.text({
+                    message: 'Confluence email',
+                    placeholder: 'you@company.com',
+                    validate: (v) => v && v.includes('@') ? undefined : 'Invalid email'
+                });
+                if (!prompts.isCancel(confluenceEmail)) {
+                    const confluenceToken = await prompts.password({
+                        message: 'Confluence API token',
+                        validate: (v) => v && v.length > 10 ? undefined : 'Token required'
+                    });
+                    if (!prompts.isCancel(confluenceToken)) {
+                        enterpriseEnv.CONFLUENCE_BASE_URL = `https://${confluenceHost}`;
+                        enterpriseEnv.CONFLUENCE_EMAIL = confluenceEmail;
+                        enterpriseEnv.CONFLUENCE_API_TOKEN = confluenceToken;
+                        prompts.log.success('Confluence configured');
+                    }
+                }
+            }
+        }
+        // Save enterprise credentials to .env
+        const envPath = path.join(process.cwd(), '.env');
+        let envContent = '';
+        try {
+            envContent = fs.readFileSync(envPath, 'utf8');
+        }
+        catch {
+            // File doesn't exist, will create
+        }
+        for (const [key, value] of Object.entries(enterpriseEnv)) {
+            if (envContent.includes(`${key}=`)) {
+                envContent = envContent.replace(new RegExp(`${key}=.*`, 'g'), `${key}=${value}`);
+            }
+            else {
+                envContent += `\n${key}=${value}\n`;
+            }
+            process.env[key] = value;
+        }
+        fs.writeFileSync(envPath, envContent);
+        prompts.log.success('Enterprise credentials saved to .env');
+        // Configure enterprise MCP proxy
+        const spinner3 = prompts.spinner();
+        spinner3.start('Configuring enterprise MCP proxy');
+        try {
+            // Find the enterprise proxy path
+            const enterpriseProxyPath = path.join(process.cwd(), '..', 'snow-flow-enterprise', 'mcp-proxy', 'dist', 'enterprise-proxy.js');
+            // Check if proxy exists
+            if (!fs.existsSync(enterpriseProxyPath)) {
+                spinner3.stop('Enterprise proxy not found - will use remote server only');
+                prompts.log.warn('Enterprise proxy not built yet');
+                prompts.log.message('   Run: cd ../snow-flow-enterprise/mcp-proxy && npm run build');
+            }
+            else {
+                // Configure for SnowCode (prioritize SnowCode config)
+                const snowcodeConfigPath = path.join(process.env.HOME || '', '.snowcode', 'config.json');
+                const snowcodeConfigDirPath = path.join(process.env.HOME || '', '.snowcode');
+                if (!fs.existsSync(snowcodeConfigDirPath)) {
+                    fs.mkdirSync(snowcodeConfigDirPath, { recursive: true });
+                }
+                let snowcodeConfig = { mcpServers: {} };
+                if (fs.existsSync(snowcodeConfigPath)) {
+                    try {
+                        snowcodeConfig = JSON.parse(fs.readFileSync(snowcodeConfigPath, 'utf8'));
+                    }
+                    catch {
+                        snowcodeConfig = { mcpServers: {} };
+                    }
+                }
+                if (!snowcodeConfig.mcpServers) {
+                    snowcodeConfig.mcpServers = {};
+                }
+                // Add enterprise MCP server
+                snowcodeConfig.mcpServers['snow-flow-enterprise'] = {
+                    command: 'node',
+                    args: [enterpriseProxyPath],
+                    env: enterpriseEnv
+                };
+                fs.writeFileSync(snowcodeConfigPath, JSON.stringify(snowcodeConfig, null, 2));
+                spinner3.stop('Enterprise MCP proxy configured for SnowCode');
+                prompts.log.success(`Config saved: ${snowcodeConfigPath}`);
+                // Also try Claude Code config
+                const claudeConfigPath = path.join(process.env.HOME || '', '.claude', 'settings.json');
+                if (fs.existsSync(path.dirname(claudeConfigPath))) {
+                    try {
+                        let claudeConfig = { mcpServers: {} };
+                        if (fs.existsSync(claudeConfigPath)) {
+                            claudeConfig = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf8'));
+                        }
+                        if (!claudeConfig.mcpServers) {
+                            claudeConfig.mcpServers = {};
+                        }
+                        claudeConfig.mcpServers['snow-flow-enterprise'] = {
+                            command: 'node',
+                            args: [enterpriseProxyPath],
+                            env: enterpriseEnv
+                        };
+                        fs.writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2));
+                        prompts.log.success('Also configured for Claude Code');
+                    }
+                    catch {
+                        // Claude Code config optional
+                    }
+                }
+            }
+        }
+        catch (error) {
+            spinner3.stop('Enterprise proxy configuration failed');
+            prompts.log.warn(`Error: ${error.message}`);
+            prompts.log.message('You can configure manually later');
         }
+        prompts.outro('🎉 Enterprise setup complete! Restart your AI coding assistant to use enterprise features.');
     });
     auth
         .command('logout')
@@ -418,45 +661,48 @@ function registerAuthCommands(program) {
         .action(async () => {
         const oauth = new snow_oauth_js_1.ServiceNowOAuth();
         await oauth.logout();
-        console.log(chalk_1.default.green('✅ Logged out successfully'));
+        prompts.log.success('Logged out successfully');
     });
     auth
         .command('status')
         .description('Show ServiceNow authentication status')
         .action(async () => {
         const oauth = new snow_oauth_js_1.ServiceNowOAuth();
-        console.log(chalk_1.default.blue('\n📊 ServiceNow Authentication Status:'));
+        prompts.log.step('ServiceNow Authentication Status');
         const isAuthenticated = await oauth.isAuthenticated();
         const credentials = await oauth.loadCredentials();
         if (isAuthenticated && credentials) {
-            console.log('   ├── Status: ✅ Authenticated');
-            console.log(`   ├── Instance: ${credentials.instance}`);
-            console.log('   ├── Method: OAuth 2.0');
-            console.log(`   ├── Client ID: ${credentials.clientId}`);
+            prompts.log.success('Status: Authenticated');
+            prompts.log.info(`Instance: ${credentials.instance}`);
+            prompts.log.info('Method: OAuth 2.0');
+            prompts.log.info(`Client ID: ${credentials.clientId}`);
             if (credentials.expiresAt) {
                 const expiresAt = new Date(credentials.expiresAt);
-                console.log(`   └── Token expires: ${expiresAt.toLocaleString()}`);
+                prompts.log.info(`Token expires: ${expiresAt.toLocaleString()}`);
             }
             // Test connection
+            const spinner = prompts.spinner();
+            spinner.start('Testing connection');
             const client = new servicenow_client_js_1.ServiceNowClient();
             const testResult = await client.testConnection();
             if (testResult.success) {
-                console.log(`\n🔍 Connection test: ✅ Success`);
+                spinner.stop('Connection test successful');
                 if (testResult.data.message) {
-                    console.log(`   ${testResult.data.message}`);
+                    prompts.log.message(`   ${testResult.data.message}`);
                 }
-                console.log(`🌐 Instance: ${testResult.data.email || credentials.instance}`);
+                prompts.log.info(`Instance: ${testResult.data.email || credentials.instance}`);
             }
             else {
-                console.log(`\n🔍 Connection test: ❌ Failed`);
-                console.log(`   Error: ${testResult.error}`);
+                spinner.stop('Connection test failed');
+                prompts.log.error(`Error: ${testResult.error}`);
             }
         }
         else {
-            console.log('   ├── Status: ❌ Not authenticated');
-            console.log('   ├── Instance: Not configured');
-            console.log('   └── Method: Not set');
-            console.log('\n💡 Create .env file and run "snow-flow auth login"');
+            prompts.log.error('Status: Not authenticated');
+            prompts.log.message('Instance: Not configured');
+            prompts.log.message('Method: Not set');
+            prompts.log.message('');
+            prompts.log.info('Create .env file and run "snow-flow auth login"');
         }
     });
 }