erosolar-cli 1.6.3 → 1.6.5

package/dist/tools/cloudTools.js

@@ -23,6 +23,7 @@
 import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import { verifiedSuccess, verifiedFailure, unverifiedResult, requiresUserAction, partialSuccess, analyzeOutput, OutputPatterns, verifyUrlAccessible, } from '../core/resultVerification.js';
 const CLOUD_PROVIDERS = {
     firebase: {
         id: 'firebase',
@@ -471,16 +472,44 @@ Supports:
                 const target = args['target'] || 'all';
                 const project = args['project'];
                 const dryRun = args['dry_run'] === true;
+                const startTime = Date.now();
+                const checks = [];
                 // First check status
                 const status = await getFullCLIStatus('firebase', workingDir);
+                checks.push({
+                    check: 'Firebase CLI installed',
+                    passed: status.installed,
+                    details: status.installed ? `v${status.version}` : 'Not found',
+                });
                 if (!status.installed) {
-                    return `Firebase CLI not installed.\n\n🔧 Auto-fix: Run \`npm install -g firebase-tools\`\n\nOr use cloud_fix tool with provider="firebase"`;
+                    return requiresUserAction('Firebase CLI not installed', 'The Firebase CLI (firebase-tools) must be installed before deployment.', [
+                        'Run: npm install -g firebase-tools',
+                        'Or use cloud_fix tool with provider="firebase"',
+                        'Documentation: https://firebase.google.com/docs/cli',
+                    ], Date.now() - startTime);
                 }
+                checks.push({
+                    check: 'Firebase authenticated',
+                    passed: status.authenticated,
+                    details: status.authenticated ? 'Credentials valid' : 'Not logged in',
+                });
                 if (!status.authenticated) {
-                    return `Firebase not authenticated.\n\n🔧 Fix options:\n1. Interactive: \`firebase login\`\n2. CI/Headless: \`firebase login:ci\` and set FIREBASE_TOKEN\n3. Service account: Set GOOGLE_APPLICATION_CREDENTIALS`;
+                    return requiresUserAction('Firebase authentication required', 'You must authenticate with Firebase before deploying.\nThe CLI is not currently logged in.', [
+                        'Interactive login: firebase login',
+                        'CI/Headless: firebase login:ci and set FIREBASE_TOKEN',
+                        'Service account: Set GOOGLE_APPLICATION_CREDENTIALS environment variable',
+                    ], Date.now() - startTime);
                 }
+                checks.push({
+                    check: 'firebase.json exists',
+                    passed: status.configExists,
+                    details: status.configExists ? 'Found' : 'Not found',
+                });
                 if (!status.configExists) {
-                    return `No firebase.json found in ${workingDir}.\n\n🔧 Initialize with: \`firebase init\``;
+                    return requiresUserAction('Firebase configuration missing', `No firebase.json found in ${workingDir}.\nThis file is required to deploy to Firebase.`, [
+                        'Initialize Firebase: firebase init',
+                        'Select the services you want to deploy (Hosting, Functions, etc.)',
+                    ], Date.now() - startTime);
                 }
                 // Build deploy command
                 let cmd = 'firebase deploy';
@@ -495,25 +524,76 @@ Supports:
                 }
                 cmd += ' 2>&1';
                 const result = await runCommand(`cd "${workingDir}" && ${cmd}`, 300000); // 5 min timeout
+                const durationMs = Date.now() - startTime;
+                const output = result.stdout + result.stderr;
+                // Analyze output with Firebase-specific patterns
+                const analysis = analyzeOutput(output, OutputPatterns.firebase, result.exitCode);
+                checks.push({
+                    check: 'Deployment command',
+                    passed: result.exitCode === 0,
+                    details: `Exit code: ${result.exitCode}`,
+                });
+                // Check for hosting URL in output (indicates actual successful deployment)
+                const hostingUrlMatch = output.match(/Hosting URL:\s*(https?:\/\/[^\s]+)/i);
+                const functionUrlMatch = output.match(/Function URL[^:]*:\s*(https?:\/\/[^\s]+)/i);
+                if (hostingUrlMatch && hostingUrlMatch[1]) {
+                    // Verify the deployed URL is actually accessible
+                    const urlCheck = await verifyUrlAccessible(hostingUrlMatch[1], 200, 15000);
+                    checks.push(urlCheck);
+                    if (urlCheck.passed && result.exitCode === 0) {
+                        return verifiedSuccess('Firebase deployment completed and verified', `Target: ${target}\n${project ? `Project: ${project}\n` : ''}${dryRun ? '(Dry run)\n' : ''}\nHosting URL: ${hostingUrlMatch[1]}\n\nDeployment Output:\n${output}`, checks, durationMs);
+                    }
+                    else if (result.exitCode === 0) {
+                        // Deployment said success but URL not accessible
+                        return partialSuccess('Firebase deployment completed but URL verification failed', `The deployment command succeeded but the hosting URL is not yet accessible.\nThis may be due to propagation delay.\n\nHosting URL: ${hostingUrlMatch[1]}\n\nDeployment Output:\n${output}`, checks, ['Wait 1-2 minutes for deployment to propagate', `Then verify: ${hostingUrlMatch[1]}`], durationMs);
+                    }
+                }
+                if (functionUrlMatch && result.exitCode === 0) {
+                    checks.push({
+                        check: 'Function deployment',
+                        passed: true,
+                        details: functionUrlMatch[1],
+                    });
+                    return verifiedSuccess('Firebase Functions deployment completed', `Target: ${target}\n${project ? `Project: ${project}\n` : ''}\nFunction URL: ${functionUrlMatch[1]}\n\nDeployment Output:\n${output}`, checks, durationMs);
+                }
+                // Exit code 0 but no URL found - might be config-only deployment
+                if (result.exitCode === 0 && analysis.isSuccess) {
+                    checks.push({
+                        check: 'Output analysis',
+                        passed: true,
+                        details: 'Success pattern detected',
+                    });
+                    return verifiedSuccess('Firebase deployment completed', `Target: ${target}\n${project ? `Project: ${project}\n` : ''}${dryRun ? '(Dry run)\n' : ''}\nDeployment Output:\n${output}`, checks, durationMs);
+                }
+                // Exit code 0 but output suggests problems
+                if (result.exitCode === 0 && analysis.isFailure) {
+                    const firebaseProvider = CLOUD_PROVIDERS['firebase'];
+                    const errorSuggestions = firebaseProvider
+                        ? analyzeDeploymentError(output, firebaseProvider).split('\n').slice(1).map(s => s.replace(/^[•]\s*/, ''))
+                        : [];
+                    return verifiedFailure('Firebase deployment command succeeded but output indicates errors', `The command exited with code 0 but the output contains error indicators.\n\nOutput:\n${output}`, errorSuggestions, checks, durationMs);
+                }
+                // Exit code 0 but can't verify
                 if (result.exitCode === 0) {
-                    return `✅ Firebase deployment successful!\n\n${result.stdout}`;
+                    return unverifiedResult('Firebase deployment may have completed', `The command exited with code 0 but we cannot verify the deployment succeeded.\nNo hosting URL or success patterns found in output.\n\nOutput:\n${output}`, ['Manually check Firebase Console: https://console.firebase.google.com', 'Verify your deployment target is configured in firebase.json'], durationMs);
                 }
-                // Analyze error and provide fixes
-                const output = result.stdout + result.stderr;
-                let fix = '';
-                if (output.includes('authentication') || output.includes('login')) {
-                    fix = '\n\n🔧 Fix: Run `firebase login --reauth`';
+                // Deployment failed - analyze the error
+                const firebaseProviderForError = CLOUD_PROVIDERS['firebase'];
+                const errorAnalysis = analyzeDeploymentError(output, firebaseProviderForError);
+                const suggestedFixes = [];
+                if (output.includes('authentication') || output.includes('login') || output.includes('not logged in')) {
+                    suggestedFixes.push('Run: firebase login --reauth');
                 }
-                else if (output.includes('permission') || output.includes('denied')) {
-                    fix = '\n\n🔧 Fix: Check Firebase project permissions at https://console.firebase.google.com';
+                if (output.includes('permission') || output.includes('denied') || output.includes('PERMISSION_DENIED')) {
+                    suggestedFixes.push('Check Firebase project permissions at https://console.firebase.google.com');
                 }
-                else if (output.includes('quota') || output.includes('limit')) {
-                    fix = '\n\n🔧 Fix: Quota exceeded. Check billing at https://console.firebase.google.com/billing';
+                if (output.includes('quota') || output.includes('limit')) {
+                    suggestedFixes.push('Check billing/quota at https://console.firebase.google.com/billing');
                 }
-                else if (output.includes('build') || output.includes('compile')) {
-                    fix = '\n\n🔧 Fix: Build errors detected. Run your build command first (e.g., npm run build)';
+                if (output.includes('build') || output.includes('compile')) {
+                    suggestedFixes.push('Fix build errors first: npm run build');
                 }
-                return `❌ Firebase deployment failed\n\n${output}${fix}`;
+                return verifiedFailure(`Firebase deployment failed with exit code ${result.exitCode}`, `Target: ${target}\n${project ? `Project: ${project}\n` : ''}\n${errorAnalysis}\n\nFull Output:\n${output}`, suggestedFixes.length > 0 ? suggestedFixes : ['Review the error output above', 'Check Firebase documentation for the specific error'], checks, durationMs);
             },
         },
         {
@@ -554,13 +634,34 @@ Automatically handles authentication and common issues.`,
                 const action = args['action'];
                 const region = args['region'];
                 const extraArgs = args['args'];
+                const startTime = Date.now();
+                const checks = [];
                 // Check status
                 const status = await getFullCLIStatus('aliyun', workingDir);
+                checks.push({
+                    check: 'Aliyun CLI installed',
+                    passed: status.installed,
+                    details: status.installed ? `v${status.version}` : 'Not found',
+                });
                 if (!status.installed) {
-                    return `Aliyun CLI not installed.\n\n🔧 Install:\n- macOS: brew install aliyun-cli\n- Linux: curl -O https://aliyuncli.alicdn.com/aliyun-cli-linux-latest-amd64.tgz\n\nDocs: https://www.alibabacloud.com/help/doc-detail/139508.htm`;
+                    return requiresUserAction('Aliyun CLI not installed', 'The Aliyun CLI must be installed before running commands.', [
+                        'macOS: brew install aliyun-cli',
+                        'Linux: curl -O https://aliyuncli.alicdn.com/aliyun-cli-linux-latest-amd64.tgz',
+                        'Docs: https://www.alibabacloud.com/help/doc-detail/139508.htm',
+                    ], Date.now() - startTime);
                 }
+                checks.push({
+                    check: 'Aliyun authenticated',
+                    passed: status.authenticated,
+                    details: status.authenticated ? 'Credentials valid' : 'Not configured',
+                });
                 if (!status.authenticated) {
-                    return `Aliyun not configured.\n\n🔧 Fix:\n1. Run: aliyun configure\n2. Enter your AccessKey ID and Secret\n3. Get keys at: https://ram.console.aliyun.com/manage/ak\n\nOr set environment variables:\n- ALIBABA_CLOUD_ACCESS_KEY_ID\n- ALIBABA_CLOUD_ACCESS_KEY_SECRET`;
+                    return requiresUserAction('Aliyun not configured', 'You must configure Aliyun credentials before running commands.', [
+                        'Run: aliyun configure',
+                        'Enter your AccessKey ID and Secret',
+                        'Get keys at: https://ram.console.aliyun.com/manage/ak',
+                        'Or set: ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET',
+                    ], Date.now() - startTime);
                 }
                 // Build command
                 let cmd = `aliyun ${service} ${action}`;
@@ -572,19 +673,47 @@ Automatically handles authentication and common issues.`,
                 }
                 cmd += ' 2>&1';
                 const result = await runCommand(cmd, 120000);
-                if (result.exitCode === 0) {
-                    return `✅ Aliyun ${service} ${action} successful!\n\n${result.stdout}`;
+                const durationMs = Date.now() - startTime;
+                const output = result.stdout + result.stderr;
+                checks.push({
+                    check: 'Command execution',
+                    passed: result.exitCode === 0,
+                    details: `Exit code: ${result.exitCode}`,
+                });
+                // Analyze output for success/failure patterns
+                const analysis = analyzeOutput(output, OutputPatterns.command, result.exitCode);
+                if (result.exitCode === 0 && analysis.confidence !== 'low') {
+                    // Try to parse JSON response for additional verification
+                    try {
+                        const jsonResponse = JSON.parse(output.trim());
+                        if (jsonResponse.RequestId) {
+                            checks.push({
+                                check: 'API response received',
+                                passed: true,
+                                details: `RequestId: ${jsonResponse.RequestId}`,
+                            });
+                        }
+                    }
+                    catch {
+                        // Not JSON, but command succeeded
+                    }
+                    return verifiedSuccess(`Aliyun ${service} ${action} completed`, `Service: ${service}\nAction: ${action}${region ? `\nRegion: ${region}` : ''}\n\nOutput:\n${output}`, checks, durationMs);
+                }
+                if (result.exitCode === 0 && analysis.confidence === 'low') {
+                    return unverifiedResult(`Aliyun ${service} ${action} may have completed`, `The command exited with code 0 but we cannot confirm success.\n\nOutput:\n${output}`, ['Manually verify the operation in Aliyun Console'], durationMs);
                 }
                 // Error analysis
-                const output = result.stdout + result.stderr;
-                let fix = '';
+                const suggestedFixes = [];
                 if (output.includes('InvalidAccessKeyId') || output.includes('SignatureDoesNotMatch')) {
-                    fix = '\n\n🔧 Fix: Invalid credentials. Run `aliyun configure` with correct AccessKey';
+                    suggestedFixes.push('Invalid credentials. Run `aliyun configure` with correct AccessKey');
                 }
-                else if (output.includes('Forbidden')) {
-                    fix = '\n\n🔧 Fix: Permission denied. Check RAM policies at https://ram.console.aliyun.com';
+                if (output.includes('Forbidden')) {
+                    suggestedFixes.push('Permission denied. Check RAM policies at https://ram.console.aliyun.com');
                 }
-                return `❌ Aliyun command failed\n\n${output}${fix}`;
+                if (output.includes('InvalidRegionId')) {
+                    suggestedFixes.push('Invalid region. Check available regions with: aliyun ecs DescribeRegions');
+                }
+                return verifiedFailure(`Aliyun ${service} ${action} failed with exit code ${result.exitCode}`, `Service: ${service}\nAction: ${action}${region ? `\nRegion: ${region}` : ''}\n\nOutput:\n${output}`, suggestedFixes.length > 0 ? suggestedFixes : ['Review the error message above'], checks, durationMs);
             },
         },
         {
@@ -624,37 +753,76 @@ Supports deployment to:
                 const providerId = args['provider']?.toLowerCase();
                 const command = args['command'] || 'deploy';
                 const autoFix = args['auto_fix'] !== false;
+                const startTime = Date.now();
+                const checks = [];
                 const provider = CLOUD_PROVIDERS[providerId];
                 if (!provider) {
-                    return `Unknown provider: ${providerId}\n\nAvailable: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`;
+                    return verifiedFailure(`Unknown cloud provider: ${providerId}`, `The provider "${providerId}" is not recognized.`, [`Available providers: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`], [], Date.now() - startTime);
                 }
                 // Check and potentially fix status
                 let status = await getFullCLIStatus(providerId, workingDir);
+                checks.push({
+                    check: `${provider.name} CLI installed`,
+                    passed: status.installed,
+                    details: status.installed ? `v${status.version}` : 'Not found',
+                });
                 if (!status.installed && autoFix) {
                     const fixes = await autoFixIssues(providerId, workingDir);
                     // Re-check after fix attempt
                     status = await getFullCLIStatus(providerId, workingDir);
                     if (!status.installed) {
-                        return `${provider.name} CLI could not be installed.\n\n${fixes.join('\n')}`;
+                        return requiresUserAction(`${provider.name} CLI could not be auto-installed`, `Automatic installation failed. Manual installation required.\n\nAuto-fix attempts:\n${fixes.join('\n')}`, [
+                            `Install manually: ${provider.installCommand}`,
+                            `Documentation: ${provider.installUrl}`,
+                        ], Date.now() - startTime);
                     }
                 }
                 if (!status.installed) {
-                    return `${provider.name} CLI not installed.\n\nInstall: ${provider.installCommand}\nDocs: ${provider.installUrl}`;
+                    return requiresUserAction(`${provider.name} CLI not installed`, `The ${provider.name} CLI must be installed before deployment.`, [
+                        `Install: ${provider.installCommand}`,
+                        `Docs: ${provider.installUrl}`,
+                    ], Date.now() - startTime);
                 }
+                checks.push({
+                    check: `${provider.name} authenticated`,
+                    passed: status.authenticated,
+                    details: status.authenticated ? 'Credentials valid' : 'Not logged in',
+                });
                 if (!status.authenticated) {
-                    return `${provider.name} not authenticated.\n\nFix: ${provider.loginCommand}\n\nFor CI, set: ${provider.envVars?.join(' or ') || 'appropriate credentials'}`;
+                    return requiresUserAction(`${provider.name} authentication required`, `You must authenticate with ${provider.name} before deploying.`, [
+                        `Login: ${provider.loginCommand}`,
+                        `For CI, set: ${provider.envVars?.join(' or ') || 'appropriate credentials'}`,
+                    ], Date.now() - startTime);
                 }
                 // Execute deployment
                 const cmd = `${provider.cliCommand} ${command} 2>&1`;
                 const result = await runCommand(`cd "${workingDir}" && ${cmd}`, 300000);
+                const durationMs = Date.now() - startTime;
+                const output = result.stdout + result.stderr;
+                checks.push({
+                    check: 'Deployment command',
+                    passed: result.exitCode === 0,
+                    details: `Exit code: ${result.exitCode}`,
+                });
+                // Analyze output
+                const analysis = analyzeOutput(output, OutputPatterns.command, result.exitCode);
+                if (result.exitCode === 0 && analysis.isSuccess) {
+                    return verifiedSuccess(`${provider.name} deployment completed`, `Command: ${provider.cliCommand} ${command}\n\nOutput:\n${output}`, checks, durationMs);
+                }
+                if (result.exitCode === 0 && analysis.isFailure) {
+                    return verifiedFailure(`${provider.name} deployment command succeeded but output indicates errors`, `The command exited with code 0 but the output contains error indicators.\n\nOutput:\n${output}`, [], checks, durationMs);
+                }
                 if (result.exitCode === 0) {
-                    return `✅ ${provider.name} deployment successful!\n\n${result.stdout}`;
+                    // Can't determine success - mark as unverified
+                    return unverifiedResult(`${provider.name} deployment may have completed`, `The command exited with code 0 but we cannot confirm success.\n\nOutput:\n${output}`, [`Manually verify deployment at ${provider.name} console`], durationMs);
                 }
-                // Provide error context and fixes
-                const output = result.stdout + result.stderr;
-                // AI-driven error analysis
+                // Deployment failed
                 const errorAnalysis = analyzeDeploymentError(output, provider);
-                return `❌ ${provider.name} deployment failed\n\n${output}\n\n${errorAnalysis}`;
+                const suggestedActions = errorAnalysis
+                    .split('\n')
+                    .filter(line => line.includes('•') || line.includes('Fix:'))
+                    .map(line => line.replace(/^[•\s]+/, '').replace(/^\s*Fix:\s*/i, ''));
+                return verifiedFailure(`${provider.name} deployment failed with exit code ${result.exitCode}`, `Command: ${provider.cliCommand} ${command}\n\n${errorAnalysis}\n\nFull Output:\n${output}`, suggestedActions.length > 0 ? suggestedActions : ['Review the error output', 'Check provider documentation'], checks, durationMs);
             },
         },
         {
@@ -700,6 +868,239 @@ Auto-detects project type (React, Vue, Angular, Next.js, etc.) and configures ap
                 return `📝 ${CLOUD_PROVIDERS[providerId]?.name || providerId} Configuration\n\nProject type: ${detectedType}\n\n${config}`;
             },
         },
+        {
+            name: 'cloud_login',
+            description: `Interactive login for cloud providers.
+
+Supports browser-based OAuth login for:
+- Firebase (firebase login)
+- Google Cloud (gcloud auth login)
+- AWS (aws configure)
+- Azure (az login)
+- Vercel (vercel login)
+- Netlify (netlify login)
+- Cloudflare (wrangler login)
+- Aliyun (aliyun configure)
+- Fly.io (flyctl auth login)
+- Railway (railway login)
+- Supabase (supabase login)
+
+Options:
+- reauth: Force re-authentication even if already logged in
+- no_localhost: Use device code flow (for remote/headless machines with browser access elsewhere)
+- ci_mode: Get instructions for CI/CD environment setup
+
+Use this when cloud_status shows authentication issues.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    provider: {
+                        type: 'string',
+                        description: 'Cloud provider to login: firebase, gcloud, aws, azure, vercel, netlify, cloudflare, aliyun, fly, railway, supabase',
+                    },
+                    reauth: {
+                        type: 'boolean',
+                        description: 'Force re-authentication (default: false)',
+                    },
+                    no_localhost: {
+                        type: 'boolean',
+                        description: 'Use device code flow instead of localhost redirect (default: false)',
+                    },
+                    ci_mode: {
+                        type: 'boolean',
+                        description: 'Show CI/CD setup instructions instead of interactive login (default: false)',
+                    },
+                },
+                required: ['provider'],
+            },
+            handler: async (args) => {
+                const providerId = args['provider']?.toLowerCase();
+                const reauth = args['reauth'] === true;
+                const noLocalhost = args['no_localhost'] === true;
+                const ciMode = args['ci_mode'] === true;
+                const provider = CLOUD_PROVIDERS[providerId];
+                if (!provider) {
+                    return `Unknown provider: ${providerId}\n\nAvailable: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`;
+                }
+                // Check if CLI is installed
+                const installCheck = await checkCLIInstalled(provider);
+                if (!installCheck.installed) {
+                    return `${provider.name} CLI not installed.\n\nInstall with: ${provider.installCommand}\nDocs: ${provider.installUrl}`;
+                }
+                // Build login command based on provider and options
+                const loginCommands = {
+                    firebase: {
+                        standard: 'firebase login',
+                        reauth: 'firebase login --reauth',
+                        no_localhost: 'firebase login --no-localhost',
+                        ci: 'firebase login:ci',
+                    },
+                    gcloud: {
+                        standard: 'gcloud auth login',
+                        reauth: 'gcloud auth login --force',
+                        no_localhost: 'gcloud auth login --no-browser',
+                        ci: 'gcloud auth activate-service-account --key-file=',
+                    },
+                    aws: {
+                        standard: 'aws configure',
+                        reauth: 'aws configure',
+                        no_localhost: 'aws configure',
+                        ci: 'aws configure set',
+                    },
+                    azure: {
+                        standard: 'az login',
+                        reauth: 'az login',
+                        no_localhost: 'az login --use-device-code',
+                        ci: 'az login --service-principal',
+                    },
+                    vercel: {
+                        standard: 'vercel login',
+                        reauth: 'vercel login',
+                        no_localhost: 'vercel login',
+                        ci: 'vercel login --token',
+                    },
+                    netlify: {
+                        standard: 'netlify login',
+                        reauth: 'netlify login',
+                        no_localhost: 'netlify login',
+                        ci: 'netlify login --new',
+                    },
+                    cloudflare: {
+                        standard: 'wrangler login',
+                        reauth: 'wrangler login',
+                        no_localhost: 'wrangler login',
+                        ci: 'wrangler login',
+                    },
+                    aliyun: {
+                        standard: 'aliyun configure',
+                        reauth: 'aliyun configure',
+                        no_localhost: 'aliyun configure',
+                        ci: 'aliyun configure set',
+                    },
+                    fly: {
+                        standard: 'flyctl auth login',
+                        reauth: 'flyctl auth login',
+                        no_localhost: 'flyctl auth login',
+                        ci: 'flyctl auth token',
+                    },
+                    railway: {
+                        standard: 'railway login',
+                        reauth: 'railway login',
+                        no_localhost: 'railway login',
+                        ci: 'railway login --browserless',
+                    },
+                    supabase: {
+                        standard: 'supabase login',
+                        reauth: 'supabase login',
+                        no_localhost: 'supabase login',
+                        ci: 'supabase login',
+                    },
+                };
+                const providerCommands = loginCommands[providerId] || {
+                    standard: provider.loginCommand,
+                    reauth: provider.loginCommand,
+                    no_localhost: provider.loginCommand,
+                    ci: provider.loginCommand,
+                };
+                // Select the appropriate command
+                if (ciMode) {
+                    const cmd = providerCommands['ci'] || provider.loginCommand;
+                    return `CI/Headless Authentication for ${provider.name}
+
+For CI/CD environments, you need to set environment variables instead of interactive login.
+
+Command (for generating token): ${cmd}
+
+Environment variables to set:
+${provider.envVars?.map(v => `  - ${v}`).join('\n') || '  (none defined)'}
+
+For Firebase specifically:
+1. Run locally: firebase login:ci
+2. Copy the token
+3. Set FIREBASE_TOKEN in your CI environment
+
+For service accounts (Firebase/GCP):
+1. Create a service account in Google Cloud Console
+2. Download the JSON key file
+3. Set GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json`;
+                }
+                let cmd;
+                if (reauth) {
+                    cmd = providerCommands['reauth'] || provider.loginCommand;
+                }
+                else if (noLocalhost) {
+                    cmd = providerCommands['no_localhost'] || provider.loginCommand;
+                }
+                else {
+                    cmd = providerCommands['standard'] || provider.loginCommand;
+                }
+                // Use 'script' command to provide pseudo-TTY for the login command
+                // This enables browser-based OAuth even in non-interactive shells
+                const platform = process.platform;
+                let wrappedCmd;
+                if (platform === 'darwin') {
+                    // macOS: script -q /dev/null <command>
+                    wrappedCmd = `script -q /dev/null ${cmd}`;
+                }
+                else if (platform === 'linux') {
+                    // Linux: script -q -c "<command>" /dev/null
+                    wrappedCmd = `script -q -c "${cmd}" /dev/null`;
+                }
+                else {
+                    // Windows or other: try direct execution
+                    wrappedCmd = cmd;
+                }
+                try {
+                    const loginStartTime = Date.now();
+                    // Run with longer timeout for OAuth flow (user needs to complete in browser)
+                    const result = await runCommand(wrappedCmd, 180000);
+                    const loginDurationMs = Date.now() - loginStartTime;
+                    const loginChecks = [];
+                    loginChecks.push({
+                        check: 'Login command executed',
+                        passed: result.exitCode === 0,
+                        details: `Exit code: ${result.exitCode}`,
+                    });
+                    // CRITICAL: Don't trust string matching for "success" - actually verify authentication
+                    // The word "success" can appear in error messages like "Failed to verify success"
+                    // Always verify by actually checking authentication state
+                    const authCheck = await checkAuthentication(provider);
+                    loginChecks.push({
+                        check: 'Authentication verification',
+                        passed: authCheck.authenticated,
+                        details: authCheck.authenticated ? 'Credentials valid' : (authCheck.error || 'Not authenticated'),
+                    });
+                    if (authCheck.authenticated) {
+                        return verifiedSuccess(`${provider.name} login completed and verified`, `Provider: ${provider.name}\nCommand: ${cmd}\n\n${authCheck.details || 'Authentication verified.'}`, loginChecks, loginDurationMs);
+                    }
+                    else if (result.exitCode === 0) {
+                        // Command succeeded but auth verification failed
+                        // This can happen with race conditions or when auth takes time to propagate
+                        return unverifiedResult(`${provider.name} login command completed but verification failed`, `The login command exited successfully but we could not verify authentication.\n\nCommand output:\n${result.stdout}\n\nThis may be a temporary issue or the authentication may not have propagated yet.`, [
+                            `Wait a moment and try: ${provider.checkAuthCommand}`,
+                            `Re-run login: ${cmd}`,
+                            `Check credentials manually`,
+                        ], loginDurationMs);
+                    }
+                    else {
+                        // Command failed
+                        const combined = result.stdout + result.stderr;
+                        return verifiedFailure(`${provider.name} login failed`, `Exit code: ${result.exitCode}\n\nOutput:\n${combined || '(no output)'}`, [
+                            `Try again: ${cmd}`,
+                            `For browser issues: ${providerCommands['no_localhost'] || cmd}`,
+                            `Check network connection`,
+                            `Documentation: ${provider.installUrl}`,
+                        ], loginChecks, loginDurationMs);
+                    }
+                }
+                catch (error) {
+                    return verifiedFailure(`Error during ${provider.name} login`, error instanceof Error ? error.message : String(error), [
+                        `Run manually: ${cmd}`,
+                        `For headless environments, set: ${provider.envVars?.join(', ') || 'appropriate credentials'}`,
+                    ]);
+                }
+            },
+        },
     ];
 }
 // Helper functions