@friggframework/devtools 2.0.0--canary.517.179491e.0 → 2.0.0--canary.522.893db5d.0

package/frigg-cli/start-command/application/RunPreflightChecksUseCase.js

@@ -0,0 +1,376 @@
+/**
+ * RunPreflightChecksUseCase - Orchestrates pre-flight checks before starting Frigg
+ *
+ * Application Layer - Use Case that coordinates multiple infrastructure adapters
+ * to verify the environment is ready for Frigg to start.
+ *
+ * Checks performed:
+ * 1. DATABASE_URL environment variable exists
+ * 2. Docker is installed
+ * 3. Docker daemon is running
+ * 4. Database is reachable
+ */
+
+class RunPreflightChecksUseCase {
+    constructor({ dockerAdapter, databaseAdapter }) {
+        this.dockerAdapter = dockerAdapter;
+        this.databaseAdapter = databaseAdapter;
+    }
+
+    /**
+     * Execute all pre-flight checks
+     * @param {object} options - Options
+     * @param {string} options.projectPath - Path to the Frigg project
+     * @returns {Promise<{allPassed: boolean, checks: Array}>}
+     */
+    async execute({ projectPath }) {
+        const checks = [];
+
+        // Check 1: DATABASE_URL exists
+        const dbUrlCheck = this._checkDatabaseUrl();
+        checks.push(dbUrlCheck);
+
+        // Short-circuit if DATABASE_URL is missing
+        if (dbUrlCheck.status === 'failed') {
+            return { allPassed: false, checks };
+        }
+
+        // Check 2: Docker is installed
+        const dockerInstalledCheck = await this._checkDockerInstalled();
+        checks.push(dockerInstalledCheck);
+
+        // Short-circuit if Docker is not installed
+        if (dockerInstalledCheck.status === 'failed') {
+            return { allPassed: false, checks };
+        }
+
+        // Check 3: Docker is running
+        const dockerRunningCheck = await this._checkDockerRunning();
+        checks.push(dockerRunningCheck);
+
+        // Short-circuit if Docker is not running
+        if (dockerRunningCheck.status === 'failed') {
+            return { allPassed: false, checks };
+        }
+
+        // Check 4: Database is reachable
+        const dbReachableCheck = await this._checkDatabaseReachable(projectPath);
+        checks.push(dbReachableCheck);
+
+        // Short-circuit if database is not reachable
+        if (dbReachableCheck.status === 'failed') {
+            return { allPassed: false, checks };
+        }
+
+        // Check 5: PostgreSQL migrations (only for PostgreSQL databases)
+        const dbType = this.databaseAdapter.getDatabaseType(process.env.DATABASE_URL);
+        if (dbType === 'postgresql') {
+            const migrationCheck = await this._checkPostgresMigrations(projectPath);
+            checks.push(migrationCheck);
+        }
+
+        // Check 6: LocalStack is reachable (only if AWS_ENDPOINT is configured for local)
+        const localstackCheck = await this._checkLocalStackReachable(projectPath);
+        if (localstackCheck) {
+            checks.push(localstackCheck);
+        }
+
+        const allPassed = checks.every(check => check.status === 'passed');
+        return { allPassed, checks };
+    }
+
+    /**
+     * Check if DATABASE_URL environment variable is set
+     * @returns {object} Check result
+     */
+    _checkDatabaseUrl() {
+        const databaseUrl = process.env.DATABASE_URL;
+
+        if (!databaseUrl || databaseUrl.trim() === '') {
+            return {
+                name: 'database_url',
+                status: 'failed',
+                message: 'DATABASE_URL environment variable is not set',
+                canResolve: true,
+                resolution: {
+                    type: 'create_env',
+                    prompt: 'Would you like to create a .env file from the template?',
+                    action: 'copy_env_template'
+                }
+            };
+        }
+
+        const dbType = this.databaseAdapter.getDatabaseType(databaseUrl);
+
+        return {
+            name: 'database_url',
+            status: 'passed',
+            message: `DATABASE_URL is configured (${dbType || 'unknown'} database)`,
+            canResolve: false,
+            resolution: null
+        };
+    }
+
+    /**
+     * Check if Docker is installed
+     * @returns {Promise<object>} Check result
+     */
+    async _checkDockerInstalled() {
+        const isInstalled = await this.dockerAdapter.isDockerInstalled();
+
+        if (!isInstalled) {
+            return {
+                name: 'docker_installed',
+                status: 'failed',
+                message: 'Docker is not installed',
+                canResolve: false,
+                resolution: {
+                    type: 'manual',
+                    instructions: 'Please install Docker Desktop from https://www.docker.com/products/docker-desktop'
+                }
+            };
+        }
+
+        return {
+            name: 'docker_installed',
+            status: 'passed',
+            message: 'Docker is installed',
+            canResolve: false,
+            resolution: null
+        };
+    }
+
+    /**
+     * Check if Docker daemon is running
+     * @returns {Promise<object>} Check result
+     */
+    async _checkDockerRunning() {
+        const isRunning = await this.dockerAdapter.isDockerRunning();
+
+        if (!isRunning) {
+            return {
+                name: 'docker_running',
+                status: 'failed',
+                message: 'Docker is not running. Please start Docker Desktop.',
+                canResolve: true,
+                resolution: {
+                    type: 'start_docker',
+                    prompt: 'Would you like to start Docker Desktop?',
+                    action: 'start_docker_desktop'
+                }
+            };
+        }
+
+        return {
+            name: 'docker_running',
+            status: 'passed',
+            message: 'Docker daemon is running',
+            canResolve: false,
+            resolution: null
+        };
+    }
+
+    /**
+     * Check if database is reachable
+     * @param {string} projectPath - Path to project
+     * @returns {Promise<object>} Check result
+     */
+    async _checkDatabaseReachable(projectPath) {
+        const databaseUrl = process.env.DATABASE_URL;
+        const result = await this.databaseAdapter.isDatabaseReachable(databaseUrl);
+
+        if (!result.reachable) {
+            // Check for docker-compose file
+            const composePath = await this.dockerAdapter.findDockerComposeFile(projectPath);
+
+            if (composePath) {
+                return {
+                    name: 'database_reachable',
+                    status: 'failed',
+                    message: `Database is not reachable: ${result.error || 'Connection failed'}`,
+                    canResolve: true,
+                    resolution: {
+                        type: 'start_docker_compose',
+                        prompt: 'Would you like to start the database using docker-compose?',
+                        composePath,
+                        action: 'docker_compose_up'
+                    }
+                };
+            }
+
+            return {
+                name: 'database_reachable',
+                status: 'failed',
+                message: `Database is not reachable: ${result.error || 'Connection failed'}`,
+                canResolve: false,
+                resolution: {
+                    type: 'manual',
+                    instructions: 'Please ensure your database server is running and accessible at the configured DATABASE_URL.'
+                }
+            };
+        }
+
+        return {
+            name: 'database_reachable',
+            status: 'passed',
+            message: `Database is reachable at ${result.host}:${result.port}`,
+            canResolve: false,
+            resolution: null
+        };
+    }
+
+    /**
+     * Check if LocalStack is reachable (for local development)
+     *
+     * The serverless plugin defaults to http://localhost:4566 for LocalStack
+     * even if AWS_ENDPOINT isn't set. So we check LocalStack in local dev
+     * mode by default.
+     *
+     * @param {string} projectPath - Path to project
+     * @returns {Promise<object|null>} Check result, or null if LocalStack check is not applicable
+     */
+    async _checkLocalStackReachable(projectPath) {
+        // Default LocalStack endpoint - same as serverless plugin default
+        const defaultEndpoint = 'http://localhost:4566';
+        const awsEndpoint = process.env.AWS_ENDPOINT;
+
+        // If AWS_ENDPOINT is set to a non-local address, skip LocalStack check
+        if (awsEndpoint) {
+            const isLocalEndpoint = awsEndpoint.includes('localhost') ||
+                                    awsEndpoint.includes('127.0.0.1') ||
+                                    awsEndpoint.includes('localstack');
+
+            if (!isLocalEndpoint) {
+                // Using real AWS, not LocalStack
+                return null;
+            }
+        }
+
+        // Use configured endpoint or default LocalStack endpoint
+        const endpoint = awsEndpoint || defaultEndpoint;
+
+        // Try to reach LocalStack health endpoint
+        const result = await this.dockerAdapter.waitForLocalStack({
+            maxAttempts: 1,  // Just one check, not waiting
+            intervalMs: 0,
+            endpoint: endpoint
+        });
+
+        if (!result.ready) {
+            // Check for docker-compose file
+            const composePath = await this.dockerAdapter.findDockerComposeFile(projectPath);
+
+            if (composePath) {
+                return {
+                    name: 'localstack_reachable',
+                    status: 'failed',
+                    message: `LocalStack is not reachable at ${endpoint}`,
+                    canResolve: true,
+                    resolution: {
+                        type: 'start_docker_compose',
+                        prompt: 'Would you like to start LocalStack using docker-compose?',
+                        composePath,
+                        action: 'docker_compose_up'
+                    }
+                };
+            }
+
+            return {
+                name: 'localstack_reachable',
+                status: 'failed',
+                message: `LocalStack is not reachable at ${endpoint}`,
+                canResolve: false,
+                resolution: {
+                    type: 'manual',
+                    instructions: `Please ensure LocalStack is running at ${endpoint}. You can start it with: docker-compose up -d`
+                }
+            };
+        }
+
+        return {
+            name: 'localstack_reachable',
+            status: 'passed',
+            message: `LocalStack is reachable at ${endpoint}`,
+            canResolve: false,
+            resolution: null
+        };
+    }
+
+    /**
+     * Check if PostgreSQL migrations have been applied
+     * @param {string} projectPath - Path to project
+     * @returns {Promise<object>} Check result
+     */
+    async _checkPostgresMigrations(projectPath) {
+        const result = await this.databaseAdapter.checkMigrationStatus(projectPath);
+
+        if (result.migrated) {
+            return {
+                name: 'postgres_migrations',
+                status: 'passed',
+                message: 'PostgreSQL database schema is up to date',
+                canResolve: false,
+                resolution: null
+            };
+        }
+
+        // Handle Prisma not installed case
+        if (result.needsInstall) {
+            return {
+                name: 'postgres_migrations',
+                status: 'failed',
+                message: result.error,
+                canResolve: false,
+                resolution: {
+                    type: 'manual',
+                    instructions: 'Run "npm install" or "pnpm install" to properly install Prisma, then try again.'
+                }
+            };
+        }
+
+        // Determine if this is auto-resolvable
+        const canResolve = result.needsSetup || result.pendingMigrations?.length > 0;
+
+        let message = result.error || 'PostgreSQL migrations have not been applied';
+        if (result.pendingMigrations?.length > 0) {
+            message = `${result.pendingMigrations.length} pending migration(s) need to be applied`;
+        }
+
+        return {
+            name: 'postgres_migrations',
+            status: 'failed',
+            message,
+            canResolve,
+            resolution: canResolve ? {
+                type: 'run_migrations',
+                prompt: 'Would you like to run database migrations now?',
+                action: 'prisma_migrate',
+                pendingMigrations: result.pendingMigrations,
+                needsSetup: result.needsSetup
+            } : {
+                type: 'manual',
+                instructions: 'Run "frigg db:setup" or "npx prisma migrate dev" to apply database migrations.'
+            }
+        };
+    }
+
+    /**
+     * Get only the failed checks from a result
+     * @param {object} result - Result from execute()
+     * @returns {Array} Failed checks
+     */
+    getFailedChecks(result) {
+        return result.checks.filter(check => check.status === 'failed');
+    }
+
+    /**
+     * Get only the checks that can be auto-resolved
+     * @param {object} result - Result from execute()
+     * @returns {Array} Resolvable failed checks
+     */
+    getResolvableChecks(result) {
+        return result.checks.filter(check => check.status === 'failed' && check.canResolve);
+    }
+}
+
+module.exports = { RunPreflightChecksUseCase };

package/frigg-cli/start-command/index.js

@@ -1,5 +1,6 @@
 const { spawn } = require('node:child_process');
 const path = require('node:path');
+const fs = require('node:fs');
 const dotenv = require('dotenv');
 const chalk = require('chalk');
 const {
@@ -13,6 +14,12 @@ const {
     getPrismaClientNotGeneratedError
 } = require('../utils/error-messages');
 
+// Import new pre-flight infrastructure
+const { DockerAdapter } = require('./infrastructure/DockerAdapter');
+const { DatabaseAdapter } = require('./infrastructure/DatabaseAdapter');
+const { RunPreflightChecksUseCase } = require('./application/RunPreflightChecksUseCase');
+const { InteractivePromptAdapter } = require('./presentation/InteractivePromptAdapter');
+
 async function startCommand(options) {
     if (options.verbose) {
         console.log('Verbose mode enabled');
@@ -25,7 +32,26 @@ async function startCommand(options) {
     const envPath = path.join(process.cwd(), '.env');
     dotenv.config({ path: envPath });
 
-    // Pre-flight database checks
+    const projectPath = process.cwd();
+
+    // Run interactive pre-flight checks if enabled (default: true)
+    if (options.interactive !== false) {
+        try {
+            const preflightPassed = await runInteractivePreflightChecks(projectPath, options);
+            if (!preflightPassed) {
+                console.error(chalk.red('\n❌ Pre-flight checks failed'));
+                console.error(chalk.gray('Fix the issues above before starting the application.\n'));
+                process.exit(1);
+            }
+        } catch (error) {
+            if (options.verbose) {
+                console.error(chalk.yellow(`Pre-flight check error: ${error.message}`));
+            }
+            // Fall back to legacy checks if new system fails
+        }
+    }
+
+    // Legacy pre-flight database checks (still run for Prisma validation)
     try {
         await performDatabaseChecks(options.verbose);
     } catch (error) {
@@ -34,7 +60,7 @@ async function startCommand(options) {
         process.exit(1);
     }
 
-    console.log(chalk.green('✓ Database checks passed\n'));
+    console.log(chalk.green('✓ Pre-flight checks passed\n'));
     console.log('Starting backend and optional frontend...');
 
     // Suppress AWS SDK warning message about maintenance mode
@@ -83,6 +109,224 @@ async function startCommand(options) {
     });
 }
 
+/**
+ * Run interactive pre-flight checks with resolution prompts
+ * @param {string} projectPath - Path to the Frigg project
+ * @param {object} options - Command options
+ * @returns {Promise<boolean>} True if all checks pass or were resolved
+ */
+async function runInteractivePreflightChecks(projectPath, options) {
+    // Create adapters and use case
+    const dockerAdapter = new DockerAdapter();
+    const databaseAdapter = new DatabaseAdapter();
+    const preflightUseCase = new RunPreflightChecksUseCase({
+        dockerAdapter,
+        databaseAdapter
+    });
+
+    // Create prompt adapter based on mode (terminal or IPC)
+    const promptMode = options.ipc ? 'ipc' : 'terminal';
+    const promptAdapter = InteractivePromptAdapter.create({ mode: promptMode });
+
+    if (options.verbose) {
+        console.log(chalk.gray('Running pre-flight checks...'));
+    }
+
+    // Track which checks we've already processed to avoid infinite loops
+    const processedChecks = new Set();
+
+    // Keep running checks and resolving issues until all pass or no more can be resolved
+    let maxIterations = 10; // Safety limit to prevent infinite loops
+    while (maxIterations > 0) {
+        maxIterations--;
+
+        // Run checks
+        const result = await preflightUseCase.execute({ projectPath });
+
+        // If all passed, we're done
+        if (result.allPassed) {
+            return true;
+        }
+
+        // Get resolvable checks that we haven't already processed
+        const resolvableChecks = preflightUseCase.getResolvableChecks(result)
+            .filter(check => !processedChecks.has(check.name));
+
+        // If no new resolvable checks, show failures and exit
+        if (resolvableChecks.length === 0) {
+            const failedChecks = result.checks.filter(c => c.status === 'failed');
+            for (const check of failedChecks) {
+                console.log(chalk.red(`   ✗ ${check.name}: ${check.message}`));
+                if (check.resolution?.instructions) {
+                    console.log(chalk.gray(`      ${check.resolution.instructions}`));
+                }
+            }
+            return false;
+        }
+
+        // Process the first resolvable check
+        const check = resolvableChecks[0];
+        processedChecks.add(check.name);
+
+        // Display the failure
+        console.log(chalk.yellow(`\n⚠️  ${check.message}`));
+
+        // Only prompt if check is resolvable
+        if (!check.canResolve) {
+            if (check.resolution?.instructions) {
+                console.log(chalk.gray(`   ${check.resolution.instructions}`));
+            }
+            continue;
+        }
+
+        // Ask user if they want to resolve
+        const response = await promptAdapter.promptForResolution(check);
+
+        if (!response.shouldResolve) {
+            console.log(chalk.gray('   Skipping resolution'));
+            // User declined, show remaining failures and exit
+            const failedChecks = result.checks.filter(c => c.status === 'failed');
+            for (const failedCheck of failedChecks) {
+                if (failedCheck.name !== check.name) {
+                    console.log(chalk.red(`   ✗ ${failedCheck.name}: ${failedCheck.message}`));
+                }
+            }
+            return false;
+        }
+
+        // Execute the resolution
+        const resolved = await executeResolution(check, dockerAdapter, options);
+
+        if (!resolved) {
+            return false;
+        }
+
+        // Loop will continue and re-run checks
+    }
+
+    // If we exhausted iterations, something went wrong
+    console.log(chalk.yellow('   ⚠️  Pre-flight check loop limit reached'));
+    return false;
+}
+
+/**
+ * Execute a resolution action
+ * @param {object} check - The check that failed
+ * @param {DockerAdapter} dockerAdapter - Docker adapter
+ * @param {object} options - Command options
+ * @returns {Promise<boolean>} True if resolution succeeded
+ */
+async function executeResolution(check, dockerAdapter, options) {
+    const { resolution } = check;
+
+    switch (resolution.type) {
+        case 'start_docker':
+            console.log(chalk.blue('   Starting Docker Desktop...'));
+            const dockerResult = await dockerAdapter.startDockerDesktop();
+            if (!dockerResult.success) {
+                console.error(chalk.red(`   Failed to start Docker: ${dockerResult.error}`));
+                return false;
+            }
+            // Wait for Docker to be ready
+            console.log(chalk.gray('   Waiting for Docker to start...'));
+            const isReady = await dockerAdapter.waitForDockerReady({
+                maxAttempts: 60,
+                intervalMs: 1000
+            });
+            if (!isReady) {
+                console.error(chalk.red('   Docker did not start in time'));
+                return false;
+            }
+            console.log(chalk.green('   ✓ Docker is now running'));
+            return true;
+
+        case 'start_docker_compose':
+            console.log(chalk.blue('   Starting Docker Compose services...'));
+            const composeResult = await dockerAdapter.startDockerCompose(resolution.composePath);
+            if (!composeResult.success) {
+                console.error(chalk.red(`   Failed to start services: ${composeResult.error}`));
+                return false;
+            }
+            console.log(chalk.green('   ✓ Docker Compose services started'));
+            // Poll LocalStack health endpoint until services are ready
+            console.log(chalk.gray('   Waiting for LocalStack to initialize...'));
+            const localstackResult = await dockerAdapter.waitForLocalStack({
+                maxAttempts: 30,
+                intervalMs: 2000
+            });
+            if (localstackResult.ready) {
+                console.log(chalk.green('   ✓ LocalStack services ready'));
+                if (options.verbose && localstackResult.services) {
+                    console.log(chalk.gray(`     Services: ${Object.keys(localstackResult.services).join(', ')}`));
+                }
+            } else {
+                console.log(chalk.yellow('   ⚠️  LocalStack may not be fully ready'));
+                if (localstackResult.error) {
+                    console.log(chalk.gray(`     ${localstackResult.error}`));
+                }
+                // Continue anyway - the service might still work
+            }
+            return true;
+
+        case 'create_env':
+            // Try to copy .env.example to .env
+            const projectPath = process.cwd();
+            const envExamplePath = path.join(projectPath, '.env.example');
+            const envPath = path.join(projectPath, '.env');
+
+            if (fs.existsSync(envExamplePath)) {
+                try {
+                    fs.copyFileSync(envExamplePath, envPath);
+                    console.log(chalk.green('   ✓ Created .env file from .env.example'));
+                    console.log(chalk.yellow('   ⚠️  Please edit .env to set your DATABASE_URL'));
+
+                    // Reload environment variables from the new .env file
+                    dotenv.config({ path: envPath, override: true });
+
+                    // Check if DATABASE_URL is now set
+                    if (process.env.DATABASE_URL && process.env.DATABASE_URL.trim() !== '') {
+                        console.log(chalk.green('   ✓ DATABASE_URL is now configured'));
+                        return true;
+                    } else {
+                        console.log(chalk.yellow('   ⚠️  DATABASE_URL is still not set in .env'));
+                        console.log(chalk.gray('   Please edit .env and set DATABASE_URL, then try again'));
+                        return false;
+                    }
+                } catch (err) {
+                    console.error(chalk.red(`   Failed to create .env: ${err.message}`));
+                    return false;
+                }
+            } else {
+                console.log(chalk.yellow('   No .env.example file found'));
+                console.log(chalk.gray('   Please create a .env file manually with DATABASE_URL'));
+                return false;
+            }
+
+        case 'run_migrations':
+            console.log(chalk.blue('   Running PostgreSQL migrations...'));
+            const databaseAdapter = new DatabaseAdapter();
+            const migrationProjectPath = process.cwd();
+
+            // Use deploy mode (default) - non-interactive, applies existing migrations
+            const migrateResult = await databaseAdapter.runMigrations(migrationProjectPath);
+
+            if (!migrateResult.success) {
+                console.error(chalk.red(`   Failed to run migrations: ${migrateResult.error}`));
+                console.log(chalk.gray('   Try running "frigg db:setup" manually'));
+                return false;
+            }
+
+            console.log(chalk.green('   ✓ Database migrations applied successfully'));
+            return true;
+
+        default:
+            if (options.verbose) {
+                console.log(chalk.gray(`   Unknown resolution type: ${resolution.type}`));
+            }
+            return false;
+    }
+}
+
 /**
  * Performs pre-flight database validation checks
  * @param {boolean} verbose - Enable verbose output