erosolar-cli 1.5.2 → 1.5.3

package/dist/tools/cloudTools.js

@@ -0,0 +1,854 @@
+/**
+ * Cloud Deployment Tools - Unified cloud CLI capabilities with auto-detection and auto-fix
+ *
+ * Supports:
+ * - Firebase (Hosting, Functions, Firestore, Storage, Auth)
+ * - Aliyun/Alibaba Cloud (OSS, FC, ACR, etc.)
+ * - AWS (S3, Lambda, CloudFront, etc.)
+ * - GCP (Cloud Run, Storage, Functions)
+ * - Azure (Static Web Apps, Functions, Blob Storage)
+ * - Vercel, Netlify, Cloudflare Pages
+ *
+ * Features:
+ * - Automatic CLI detection and installation checking
+ * - Authentication status verification
+ * - Auto-fix for common issues
+ * - AI-driven error resolution
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+const CLOUD_PROVIDERS = {
+    firebase: {
+        id: 'firebase',
+        name: 'Firebase',
+        cliCommand: 'firebase',
+        versionFlag: '--version',
+        installCommand: 'npm install -g firebase-tools',
+        installUrl: 'https://firebase.google.com/docs/cli',
+        loginCommand: 'firebase login',
+        checkAuthCommand: 'firebase projects:list',
+        configFile: 'firebase.json',
+        envVars: ['FIREBASE_TOKEN', 'GOOGLE_APPLICATION_CREDENTIALS'],
+    },
+    aliyun: {
+        id: 'aliyun',
+        name: 'Alibaba Cloud (Aliyun)',
+        cliCommand: 'aliyun',
+        versionFlag: 'version',
+        installCommand: 'brew install aliyun-cli || curl -O https://aliyuncli.alicdn.com/aliyun-cli-linux-amd64-*.tgz',
+        installUrl: 'https://www.alibabacloud.com/help/doc-detail/139508.htm',
+        loginCommand: 'aliyun configure',
+        checkAuthCommand: 'aliyun ecs DescribeRegions',
+        configFile: '~/.aliyun/config.json',
+        envVars: ['ALIBABA_CLOUD_ACCESS_KEY_ID', 'ALIBABA_CLOUD_ACCESS_KEY_SECRET'],
+    },
+    aws: {
+        id: 'aws',
+        name: 'Amazon Web Services',
+        cliCommand: 'aws',
+        versionFlag: '--version',
+        installCommand: 'brew install awscli || pip install awscli',
+        installUrl: 'https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html',
+        loginCommand: 'aws configure',
+        checkAuthCommand: 'aws sts get-caller-identity',
+        configFile: '~/.aws/credentials',
+        envVars: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN'],
+    },
+    gcloud: {
+        id: 'gcloud',
+        name: 'Google Cloud Platform',
+        cliCommand: 'gcloud',
+        versionFlag: '--version',
+        installCommand: 'brew install --cask google-cloud-sdk',
+        installUrl: 'https://cloud.google.com/sdk/docs/install',
+        loginCommand: 'gcloud auth login',
+        checkAuthCommand: 'gcloud auth list',
+        configFile: '~/.config/gcloud/credentials.db',
+        envVars: ['GOOGLE_APPLICATION_CREDENTIALS', 'CLOUDSDK_CORE_PROJECT'],
+    },
+    azure: {
+        id: 'azure',
+        name: 'Microsoft Azure',
+        cliCommand: 'az',
+        versionFlag: '--version',
+        installCommand: 'brew install azure-cli || curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash',
+        installUrl: 'https://docs.microsoft.com/en-us/cli/azure/install-azure-cli',
+        loginCommand: 'az login',
+        checkAuthCommand: 'az account show',
+        configFile: '~/.azure/accessTokens.json',
+        envVars: ['AZURE_CLIENT_ID', 'AZURE_CLIENT_SECRET', 'AZURE_TENANT_ID'],
+    },
+    vercel: {
+        id: 'vercel',
+        name: 'Vercel',
+        cliCommand: 'vercel',
+        versionFlag: '--version',
+        installCommand: 'npm install -g vercel',
+        installUrl: 'https://vercel.com/docs/cli',
+        loginCommand: 'vercel login',
+        checkAuthCommand: 'vercel whoami',
+        envVars: ['VERCEL_TOKEN'],
+    },
+    netlify: {
+        id: 'netlify',
+        name: 'Netlify',
+        cliCommand: 'netlify',
+        versionFlag: '--version',
+        installCommand: 'npm install -g netlify-cli',
+        installUrl: 'https://docs.netlify.com/cli/get-started/',
+        loginCommand: 'netlify login',
+        checkAuthCommand: 'netlify status',
+        envVars: ['NETLIFY_AUTH_TOKEN'],
+    },
+    cloudflare: {
+        id: 'cloudflare',
+        name: 'Cloudflare',
+        cliCommand: 'wrangler',
+        versionFlag: '--version',
+        installCommand: 'npm install -g wrangler',
+        installUrl: 'https://developers.cloudflare.com/workers/wrangler/install-and-update/',
+        loginCommand: 'wrangler login',
+        checkAuthCommand: 'wrangler whoami',
+        envVars: ['CLOUDFLARE_API_TOKEN', 'CLOUDFLARE_ACCOUNT_ID'],
+    },
+    fly: {
+        id: 'fly',
+        name: 'Fly.io',
+        cliCommand: 'flyctl',
+        versionFlag: 'version',
+        installCommand: 'brew install flyctl || curl -L https://fly.io/install.sh | sh',
+        installUrl: 'https://fly.io/docs/hands-on/install-flyctl/',
+        loginCommand: 'flyctl auth login',
+        checkAuthCommand: 'flyctl auth whoami',
+        envVars: ['FLY_API_TOKEN'],
+    },
+    railway: {
+        id: 'railway',
+        name: 'Railway',
+        cliCommand: 'railway',
+        versionFlag: '--version',
+        installCommand: 'npm install -g @railway/cli',
+        installUrl: 'https://docs.railway.app/develop/cli',
+        loginCommand: 'railway login',
+        checkAuthCommand: 'railway whoami',
+        envVars: ['RAILWAY_TOKEN'],
+    },
+    supabase: {
+        id: 'supabase',
+        name: 'Supabase',
+        cliCommand: 'supabase',
+        versionFlag: '--version',
+        installCommand: 'npm install -g supabase',
+        installUrl: 'https://supabase.com/docs/guides/cli',
+        loginCommand: 'supabase login',
+        checkAuthCommand: 'supabase projects list',
+        envVars: ['SUPABASE_ACCESS_TOKEN'],
+    },
+};
+async function runCommand(command, timeout = 30000) {
+    return new Promise((resolve) => {
+        const child = spawn('sh', ['-c', command], {
+            timeout,
+            env: { ...process.env },
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: code ?? 1 });
+        });
+        child.on('error', (err) => {
+            resolve({ stdout: '', stderr: err.message, exitCode: 1 });
+        });
+    });
+}
+async function checkCLIInstalled(provider) {
+    try {
+        const result = await runCommand(`which ${provider.cliCommand} && ${provider.cliCommand} ${provider.versionFlag} 2>&1 | head -5`);
+        if (result.exitCode === 0 && result.stdout) {
+            // Extract version from output
+            const versionMatch = result.stdout.match(/(\d+\.\d+\.\d+[\w.-]*)/);
+            return {
+                installed: true,
+                version: versionMatch?.[1] || result.stdout.split('\n')[1] || 'unknown',
+            };
+        }
+        return { installed: false, error: result.stderr || 'CLI not found in PATH' };
+    }
+    catch (error) {
+        return { installed: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function checkAuthentication(provider) {
+    try {
+        const result = await runCommand(provider.checkAuthCommand, 15000);
+        if (result.exitCode === 0) {
+            return {
+                authenticated: true,
+                details: result.stdout.slice(0, 500),
+            };
+        }
+        // Check for specific auth errors
+        const errorLower = (result.stderr + result.stdout).toLowerCase();
+        if (errorLower.includes('not logged in') ||
+            errorLower.includes('authentication') ||
+            errorLower.includes('credentials') ||
+            errorLower.includes('login') ||
+            errorLower.includes('token') ||
+            errorLower.includes('unauthorized')) {
+            return {
+                authenticated: false,
+                error: 'Not authenticated. Run: ' + provider.loginCommand,
+            };
+        }
+        return { authenticated: false, error: result.stderr || result.stdout };
+    }
+    catch (error) {
+        return { authenticated: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function checkConfigFile(provider, workingDir) {
+    if (!provider.configFile) {
+        return true;
+    }
+    // Check for project-level config
+    const projectConfig = path.join(workingDir, provider.configFile);
+    if (fs.existsSync(projectConfig)) {
+        return true;
+    }
+    // Check for user-level config (expand ~)
+    if (provider.configFile.startsWith('~')) {
+        const homeConfig = provider.configFile.replace('~', process.env['HOME'] || '');
+        if (fs.existsSync(homeConfig)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function getFullCLIStatus(providerId, workingDir) {
+    const provider = CLOUD_PROVIDERS[providerId];
+    if (!provider) {
+        return {
+            installed: false,
+            authenticated: false,
+            configExists: false,
+            errors: [`Unknown provider: ${providerId}`],
+            suggestions: ['Available providers: ' + Object.keys(CLOUD_PROVIDERS).join(', ')],
+        };
+    }
+    const status = {
+        installed: false,
+        authenticated: false,
+        configExists: false,
+        errors: [],
+        suggestions: [],
+    };
+    // Check installation
+    const installCheck = await checkCLIInstalled(provider);
+    status.installed = installCheck.installed;
+    status.version = installCheck.version;
+    if (!installCheck.installed) {
+        status.errors.push(`${provider.name} CLI not installed`);
+        status.suggestions.push(`Install with: ${provider.installCommand}`);
+        status.suggestions.push(`Documentation: ${provider.installUrl}`);
+        return status;
+    }
+    // Check authentication
+    const authCheck = await checkAuthentication(provider);
+    status.authenticated = authCheck.authenticated;
+    status.authDetails = authCheck.details;
+    if (!authCheck.authenticated) {
+        status.errors.push(authCheck.error || 'Not authenticated');
+        status.suggestions.push(`Authenticate with: ${provider.loginCommand}`);
+        if (provider.envVars?.length) {
+            status.suggestions.push(`Or set environment variables: ${provider.envVars.join(', ')}`);
+        }
+    }
+    // Check config file
+    status.configExists = await checkConfigFile(provider, workingDir);
+    if (!status.configExists && provider.configFile) {
+        status.errors.push(`Config file not found: ${provider.configFile}`);
+        if (provider.configFile.includes('firebase.json')) {
+            status.suggestions.push('Initialize project with: firebase init');
+        }
+        else if (provider.configFile.includes('aliyun')) {
+            status.suggestions.push('Configure with: aliyun configure');
+        }
+    }
+    return status;
+}
+async function autoFixIssues(providerId, workingDir) {
+    const fixes = [];
+    const provider = CLOUD_PROVIDERS[providerId];
+    if (!provider) {
+        return ['Unknown provider'];
+    }
+    const status = await getFullCLIStatus(providerId, workingDir);
+    // Try to install if not present
+    if (!status.installed) {
+        fixes.push(`Attempting to install ${provider.name} CLI...`);
+        // Try npm install first for npm-based CLIs
+        if (provider.installCommand.includes('npm install')) {
+            const result = await runCommand(provider.installCommand, 120000);
+            if (result.exitCode === 0) {
+                fixes.push(`✅ Successfully installed ${provider.name} CLI`);
+            }
+            else {
+                fixes.push(`❌ Failed to install: ${result.stderr}`);
+                fixes.push(`Manual install: ${provider.installCommand}`);
+            }
+        }
+        else {
+            fixes.push(`Manual installation required: ${provider.installCommand}`);
+            fixes.push(`Visit: ${provider.installUrl}`);
+        }
+    }
+    // Check for CI environment variables if not authenticated
+    if (!status.authenticated && provider.envVars) {
+        const hasEnvAuth = provider.envVars.some((v) => process.env[v]);
+        if (hasEnvAuth) {
+            fixes.push(`Environment credentials detected for ${provider.name}`);
+        }
+        else {
+            fixes.push(`Authentication required. Run: ${provider.loginCommand}`);
+            // For headless/CI environments
+            if (process.env['CI'] || !process.stdin.isTTY) {
+                fixes.push(`For CI/headless environments, set: ${provider.envVars.join(' or ')}`);
+            }
+        }
+    }
+    return fixes;
+}
+export function createCloudTools(workingDir = process.cwd()) {
+    return [
+        {
+            name: 'cloud_status',
+            description: `Check the status of cloud CLIs on this system.
+
+Detects and reports on:
+- CLI installation status and versions
+- Authentication status
+- Project configuration
+- Required environment variables
+
+Supports: Firebase, Aliyun, AWS, GCP, Azure, Vercel, Netlify, Cloudflare, Fly.io, Railway, Supabase
+
+Use this before attempting any cloud deployment to ensure everything is properly configured.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    providers: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Specific providers to check (default: all). Options: firebase, aliyun, aws, gcloud, azure, vercel, netlify, cloudflare, fly, railway, supabase',
+                    },
+                },
+            },
+            handler: async (args) => {
+                const providersToCheck = args['providers'] || Object.keys(CLOUD_PROVIDERS);
+                const results = ['☁️ Cloud CLI Status Report\n'];
+                for (const providerId of providersToCheck) {
+                    const provider = CLOUD_PROVIDERS[providerId];
+                    if (!provider) {
+                        results.push(`❓ Unknown provider: ${providerId}`);
+                        continue;
+                    }
+                    results.push(`\n--- ${provider.name} (${provider.cliCommand}) ---`);
+                    const status = await getFullCLIStatus(providerId, workingDir);
+                    if (status.installed) {
+                        results.push(`✅ Installed: v${status.version}`);
+                    }
+                    else {
+                        results.push(`❌ Not installed`);
+                    }
+                    if (status.installed) {
+                        if (status.authenticated) {
+                            results.push(`✅ Authenticated`);
+                            if (status.authDetails) {
+                                results.push(`   ${status.authDetails.split('\n')[0]}`);
+                            }
+                        }
+                        else {
+                            results.push(`❌ Not authenticated`);
+                        }
+                        if (status.configExists) {
+                            results.push(`✅ Project config found`);
+                        }
+                        else if (provider.configFile) {
+                            results.push(`⚠️ No project config (${provider.configFile})`);
+                        }
+                    }
+                    if (status.errors.length > 0) {
+                        results.push(`\nIssues:`);
+                        for (const err of status.errors) {
+                            results.push(`  ⚠️ ${err}`);
+                        }
+                    }
+                    if (status.suggestions.length > 0) {
+                        results.push(`\nSuggestions:`);
+                        for (const sug of status.suggestions) {
+                            results.push(`  💡 ${sug}`);
+                        }
+                    }
+                }
+                return results.join('\n');
+            },
+        },
+        {
+            name: 'cloud_fix',
+            description: `Automatically fix cloud CLI issues.
+
+Attempts to:
+- Install missing CLIs (via npm/brew where possible)
+- Detect environment credentials
+- Provide step-by-step fix instructions for issues that can't be auto-fixed
+
+Use this when cloud_status reports issues.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    provider: {
+                        type: 'string',
+                        description: 'The cloud provider to fix. Options: firebase, aliyun, aws, gcloud, azure, vercel, netlify, cloudflare, fly, railway, supabase',
+                    },
+                },
+                required: ['provider'],
+            },
+            handler: async (args) => {
+                const providerId = args['provider']?.toLowerCase();
+                if (!CLOUD_PROVIDERS[providerId]) {
+                    return `Unknown provider: ${providerId}\n\nAvailable: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`;
+                }
+                const fixes = await autoFixIssues(providerId, workingDir);
+                return `🔧 Auto-Fix Results for ${CLOUD_PROVIDERS[providerId]?.name}\n\n${fixes.join('\n')}`;
+            },
+        },
+        {
+            name: 'firebase_deploy',
+            description: `Deploy to Firebase (Hosting, Functions, Firestore rules, Storage rules).
+
+Automatically:
+- Checks Firebase CLI status
+- Validates firebase.json configuration
+- Handles authentication issues
+- Provides detailed deployment logs
+
+Supports:
+- firebase deploy --only hosting
+- firebase deploy --only functions
+- firebase deploy --only firestore
+- firebase deploy --only storage
+- firebase deploy (all)`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        description: 'Deployment target: "hosting", "functions", "firestore", "storage", "all" (default: all)',
+                    },
+                    project: {
+                        type: 'string',
+                        description: 'Firebase project ID (uses default if not specified)',
+                    },
+                    dry_run: {
+                        type: 'boolean',
+                        description: 'Preview deployment without actually deploying (default: false)',
+                    },
+                },
+            },
+            handler: async (args) => {
+                const target = args['target'] || 'all';
+                const project = args['project'];
+                const dryRun = args['dry_run'] === true;
+                // First check status
+                const status = await getFullCLIStatus('firebase', workingDir);
+                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"`;
+                }
+                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`;
+                }
+                if (!status.configExists) {
+                    return `No firebase.json found in ${workingDir}.\n\n🔧 Initialize with: \`firebase init\``;
+                }
+                // Build deploy command
+                let cmd = 'firebase deploy';
+                if (target !== 'all') {
+                    cmd += ` --only ${target}`;
+                }
+                if (project) {
+                    cmd += ` --project ${project}`;
+                }
+                if (dryRun) {
+                    cmd += ' --dry-run';
+                }
+                cmd += ' 2>&1';
+                const result = await runCommand(`cd "${workingDir}" && ${cmd}`, 300000); // 5 min timeout
+                if (result.exitCode === 0) {
+                    return `✅ Firebase deployment successful!\n\n${result.stdout}`;
+                }
+                // 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`';
+                }
+                else if (output.includes('permission') || output.includes('denied')) {
+                    fix = '\n\n🔧 Fix: 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';
+                }
+                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)';
+                }
+                return `❌ Firebase deployment failed\n\n${output}${fix}`;
+            },
+        },
+        {
+            name: 'aliyun_deploy',
+            description: `Deploy to Alibaba Cloud (Aliyun).
+
+Supports:
+- OSS (Object Storage Service) - static file hosting
+- FC (Function Compute) - serverless functions
+- ACR (Container Registry) - Docker images
+- ECS (Elastic Compute Service) - VM management
+
+Automatically handles authentication and common issues.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    service: {
+                        type: 'string',
+                        description: 'Service to deploy: "oss", "fc", "acr", "ecs"',
+                    },
+                    action: {
+                        type: 'string',
+                        description: 'Action to perform (service-specific)',
+                    },
+                    region: {
+                        type: 'string',
+                        description: 'Aliyun region (e.g., cn-hangzhou, cn-shanghai)',
+                    },
+                    args: {
+                        type: 'string',
+                        description: 'Additional CLI arguments',
+                    },
+                },
+                required: ['service', 'action'],
+            },
+            handler: async (args) => {
+                const service = args['service'];
+                const action = args['action'];
+                const region = args['region'];
+                const extraArgs = args['args'];
+                // Check status
+                const status = await getFullCLIStatus('aliyun', workingDir);
+                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`;
+                }
+                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`;
+                }
+                // Build command
+                let cmd = `aliyun ${service} ${action}`;
+                if (region) {
+                    cmd += ` --region ${region}`;
+                }
+                if (extraArgs) {
+                    cmd += ` ${extraArgs}`;
+                }
+                cmd += ' 2>&1';
+                const result = await runCommand(cmd, 120000);
+                if (result.exitCode === 0) {
+                    return `✅ Aliyun ${service} ${action} successful!\n\n${result.stdout}`;
+                }
+                // Error analysis
+                const output = result.stdout + result.stderr;
+                let fix = '';
+                if (output.includes('InvalidAccessKeyId') || output.includes('SignatureDoesNotMatch')) {
+                    fix = '\n\n🔧 Fix: 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';
+                }
+                return `❌ Aliyun command failed\n\n${output}${fix}`;
+            },
+        },
+        {
+            name: 'cloud_deploy',
+            description: `Universal cloud deployment command that works across providers.
+
+Automatically:
+- Detects project type and configuration
+- Selects appropriate deployment target
+- Handles provider-specific requirements
+- Auto-fixes common issues
+
+Supports deployment to:
+- Firebase, Vercel, Netlify for web apps
+- AWS Lambda, GCP Functions, Azure Functions for serverless
+- Cloudflare Workers/Pages for edge deployments
+- Fly.io, Railway for containers`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    provider: {
+                        type: 'string',
+                        description: 'Cloud provider: firebase, vercel, netlify, cloudflare, fly, railway, aws, gcloud, azure',
+                    },
+                    command: {
+                        type: 'string',
+                        description: 'Deployment command (e.g., "deploy", "deploy --prod")',
+                    },
+                    auto_fix: {
+                        type: 'boolean',
+                        description: 'Automatically attempt to fix issues (default: true)',
+                    },
+                },
+                required: ['provider'],
+            },
+            handler: async (args) => {
+                const providerId = args['provider']?.toLowerCase();
+                const command = args['command'] || 'deploy';
+                const autoFix = args['auto_fix'] !== false;
+                const provider = CLOUD_PROVIDERS[providerId];
+                if (!provider) {
+                    return `Unknown provider: ${providerId}\n\nAvailable: ${Object.keys(CLOUD_PROVIDERS).join(', ')}`;
+                }
+                // Check and potentially fix status
+                let status = await getFullCLIStatus(providerId, workingDir);
+                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')}`;
+                    }
+                }
+                if (!status.installed) {
+                    return `${provider.name} CLI not installed.\n\nInstall: ${provider.installCommand}\nDocs: ${provider.installUrl}`;
+                }
+                if (!status.authenticated) {
+                    return `${provider.name} not authenticated.\n\nFix: ${provider.loginCommand}\n\nFor CI, set: ${provider.envVars?.join(' or ') || 'appropriate credentials'}`;
+                }
+                // Execute deployment
+                const cmd = `${provider.cliCommand} ${command} 2>&1`;
+                const result = await runCommand(`cd "${workingDir}" && ${cmd}`, 300000);
+                if (result.exitCode === 0) {
+                    return `✅ ${provider.name} deployment successful!\n\n${result.stdout}`;
+                }
+                // Provide error context and fixes
+                const output = result.stdout + result.stderr;
+                // AI-driven error analysis
+                const errorAnalysis = analyzeDeploymentError(output, provider);
+                return `❌ ${provider.name} deployment failed\n\n${output}\n\n${errorAnalysis}`;
+            },
+        },
+        {
+            name: 'cloud_init',
+            description: `Initialize a cloud project configuration.
+
+Creates configuration files and sets up project structure for:
+- Firebase (firebase.json, .firebaserc)
+- Vercel (vercel.json)
+- Netlify (netlify.toml)
+- Cloudflare (wrangler.toml)
+
+Auto-detects project type (React, Vue, Angular, Next.js, etc.) and configures appropriately.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    provider: {
+                        type: 'string',
+                        description: 'Cloud provider to initialize: firebase, vercel, netlify, cloudflare',
+                    },
+                    project_type: {
+                        type: 'string',
+                        description: 'Project type: react, vue, angular, nextjs, static, node (auto-detected if not specified)',
+                    },
+                },
+                required: ['provider'],
+            },
+            handler: async (args) => {
+                const providerId = args['provider']?.toLowerCase();
+                const projectType = args['project_type'];
+                // Detect project type if not specified
+                const detectedType = projectType || detectProjectType(workingDir);
+                const configs = {
+                    firebase: () => generateFirebaseConfig(detectedType, workingDir),
+                    vercel: () => generateVercelConfig(detectedType),
+                    netlify: () => generateNetlifyConfig(detectedType),
+                    cloudflare: () => generateCloudflareConfig(detectedType),
+                };
+                if (!configs[providerId]) {
+                    return `Initialization not supported for: ${providerId}\n\nSupported: firebase, vercel, netlify, cloudflare`;
+                }
+                const config = configs[providerId]();
+                return `📝 ${CLOUD_PROVIDERS[providerId]?.name || providerId} Configuration\n\nProject type: ${detectedType}\n\n${config}`;
+            },
+        },
+    ];
+}
+// Helper functions
+function analyzeDeploymentError(output, provider) {
+    const suggestions = ['🔍 Error Analysis:'];
+    const lower = output.toLowerCase();
+    // Authentication issues
+    if (lower.includes('auth') || lower.includes('login') || lower.includes('token') || lower.includes('credential')) {
+        suggestions.push(`• Authentication issue detected`);
+        suggestions.push(`  Fix: ${provider.loginCommand}`);
+        if (provider.envVars?.length) {
+            suggestions.push(`  CI: Set ${provider.envVars[0]}`);
+        }
+    }
+    // Permission issues
+    if (lower.includes('permission') || lower.includes('denied') || lower.includes('forbidden') || lower.includes('access')) {
+        suggestions.push(`• Permission issue detected`);
+        suggestions.push(`  Check your account permissions/roles`);
+    }
+    // Build issues
+    if (lower.includes('build') || lower.includes('compile') || lower.includes('error') || lower.includes('failed')) {
+        suggestions.push(`• Build/compile error detected`);
+        suggestions.push(`  Run your build command locally first`);
+    }
+    // Network issues
+    if (lower.includes('network') || lower.includes('timeout') || lower.includes('econnrefused') || lower.includes('dns')) {
+        suggestions.push(`• Network connectivity issue`);
+        suggestions.push(`  Check your internet connection`);
+    }
+    // Quota/limits
+    if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded') || lower.includes('billing')) {
+        suggestions.push(`• Quota/billing issue detected`);
+        suggestions.push(`  Check your account billing status`);
+    }
+    // Config issues
+    if (lower.includes('config') || lower.includes('not found') || lower.includes('missing')) {
+        suggestions.push(`• Configuration issue detected`);
+        suggestions.push(`  Use cloud_init to create configuration`);
+    }
+    if (suggestions.length === 1) {
+        suggestions.push(`• Unable to determine specific cause`);
+        suggestions.push(`  Try running the command directly for more details`);
+    }
+    return suggestions.join('\n');
+}
+function detectProjectType(dir) {
+    // Check for common framework indicators
+    const packageJsonPath = path.join(dir, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps['next'])
+                return 'nextjs';
+            if (deps['@angular/core'])
+                return 'angular';
+            if (deps['vue'])
+                return 'vue';
+            if (deps['react'])
+                return 'react';
+            if (deps['svelte'])
+                return 'svelte';
+            if (deps['express'] || deps['fastify'] || deps['koa'])
+                return 'node';
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // Check for index.html (static site)
+    if (fs.existsSync(path.join(dir, 'index.html')) || fs.existsSync(path.join(dir, 'public', 'index.html'))) {
+        return 'static';
+    }
+    return 'unknown';
+}
+function generateFirebaseConfig(projectType, _dir) {
+    const buildDirs = {
+        react: 'build',
+        nextjs: 'out',
+        angular: 'dist',
+        vue: 'dist',
+        svelte: 'public',
+        static: 'public',
+        unknown: 'public',
+    };
+    const buildDir = buildDirs[projectType] || 'public';
+    const config = {
+        hosting: {
+            public: buildDir,
+            ignore: ['firebase.json', '**/.*', '**/node_modules/**'],
+            rewrites: [{ source: '**', destination: '/index.html' }],
+        },
+    };
+    return `Create firebase.json:
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+
+Then run: firebase init
+Select Hosting and follow the prompts.`;
+}
+function generateVercelConfig(projectType) {
+    const configs = {
+        nextjs: {}, // Vercel auto-detects Next.js
+        react: { buildCommand: 'npm run build', outputDirectory: 'build' },
+        vue: { buildCommand: 'npm run build', outputDirectory: 'dist' },
+        angular: { buildCommand: 'npm run build', outputDirectory: 'dist' },
+        static: { buildCommand: null, outputDirectory: '.' },
+        unknown: {},
+    };
+    const config = configs[projectType] || configs['unknown'];
+    return `Create vercel.json:
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+
+Then run: vercel`;
+}
+function generateNetlifyConfig(projectType) {
+    const configs = {
+        react: { command: 'npm run build', publish: 'build' },
+        nextjs: { command: 'npm run build', publish: '.next' },
+        vue: { command: 'npm run build', publish: 'dist' },
+        angular: { command: 'npm run build', publish: 'dist' },
+        static: { command: '', publish: '.' },
+        unknown: { command: 'npm run build', publish: 'public' },
+    };
+    const config = configs[projectType] || configs['unknown'] || { command: 'npm run build', publish: 'public' };
+    return `Create netlify.toml:
+\`\`\`toml
+[build]
+  command = "${config.command}"
+  publish = "${config.publish}"
+
+[[redirects]]
+  from = "/*"
+  to = "/index.html"
+  status = 200
+\`\`\`
+
+Then run: netlify deploy`;
+}
+function generateCloudflareConfig(projectType) {
+    return `Create wrangler.toml:
+\`\`\`toml
+name = "my-${projectType}-app"
+main = "src/index.js"
+compatibility_date = "${new Date().toISOString().split('T')[0]}"
+
+[site]
+bucket = "./dist"
+\`\`\`
+
+For Pages, run: npx wrangler pages project create`;
+}
+export { CLOUD_PROVIDERS, getFullCLIStatus, autoFixIssues };
+//# sourceMappingURL=cloudTools.js.map