@friggframework/devtools 2.0.0--canary.522.923dfae.0 → 2.0.0--canary.540.c5ef83f.0

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

@@ -1,6 +1,5 @@
 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 {
@@ -14,12 +13,6 @@ 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');
@@ -32,26 +25,7 @@ async function startCommand(options) {
     const envPath = path.join(process.cwd(), '.env');
     dotenv.config({ path: envPath });
 
-    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)
+    // Pre-flight database checks
     try {
         await performDatabaseChecks(options.verbose);
     } catch (error) {
@@ -60,7 +34,7 @@ async function startCommand(options) {
         process.exit(1);
     }
 
-    console.log(chalk.green('✓ Pre-flight checks passed\n'));
+    console.log(chalk.green('✓ Database checks passed\n'));
     console.log('Starting backend and optional frontend...');
 
     // Suppress AWS SDK warning message about maintenance mode
@@ -109,224 +83,6 @@ 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

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

@@ -2,19 +2,16 @@ const open = require('open');
 const chalk = require('chalk');
 const path = require('path');
 const ProcessManager = require('../utils/process-manager');
-const {
-    getCurrentRepositoryInfo,
-    discoverFriggRepositories,
+const { 
+    getCurrentRepositoryInfo, 
+    discoverFriggRepositories, 
     promptRepositorySelection,
-    formatRepositoryInfo
+    formatRepositoryInfo 
 } = require('../utils/repo-detection');
 
 async function uiCommand(options) {
-    const { port = 3210, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
-
-    // Fix: --no-open should set open to false, not use the default true
-    const shouldOpenBrowser = options.open !== false;
-
+    const { port = 3001, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
+    
     let targetRepo = null;
     let workingDirectory = process.cwd();
 
@@ -28,7 +25,7 @@ async function uiCommand(options) {
         // Check if we're already in a Frigg repository
         console.log(chalk.blue('Detecting Frigg repository...'));
         const currentRepo = await getCurrentRepositoryInfo();
-
+        
         if (currentRepo) {
             console.log(chalk.green(`✓ Found Frigg repository: ${formatRepositoryInfo(currentRepo)}`));
             if (currentRepo.currentSubPath) {
@@ -40,40 +37,40 @@ async function uiCommand(options) {
             // Discover Frigg repositories
             console.log(chalk.yellow('Current directory is not a Frigg repository.'));
             console.log(chalk.blue('Searching for Frigg repositories...'));
-
+            
             const discoveredRepos = await discoverFriggRepositories();
-
+            
             if (discoveredRepos.length === 0) {
                 console.log(chalk.red('No Frigg repositories found. Please create one first.'));
                 process.exit(1);
             }
-
+            
             // For UI command, we'll let the UI handle repository selection
             // Set a placeholder and pass the discovered repos via environment
-            targetRepo = {
-                name: 'Multiple Repositories Available',
+            targetRepo = { 
+                name: 'Multiple Repositories Available', 
                 path: process.cwd(),
                 isMultiRepo: true,
                 availableRepos: discoveredRepos
             };
             workingDirectory = process.cwd();
-
+            
             console.log(chalk.blue(`Found ${discoveredRepos.length} Frigg repositories. You'll be able to select one in the UI.`));
         }
     }
 
     console.log(chalk.blue('🚀 Starting Frigg Management UI...'));
-
+    
     const processManager = new ProcessManager();
-
+    
     try {
         const managementUiPath = path.join(__dirname, '../../management-ui');
-
+        
         // Check if we're in development mode
         // For CLI usage, we prefer development mode unless explicitly set to production
         const fs = require('fs');
         const isDevelopment = dev || process.env.NODE_ENV !== 'production';
-
+        
         if (isDevelopment) {
             const env = {
                 ...process.env,
@@ -83,15 +80,15 @@ async function uiCommand(options) {
                 REPOSITORY_INFO: JSON.stringify(targetRepo),
                 AVAILABLE_REPOSITORIES: targetRepo.isMultiRepo ? JSON.stringify(targetRepo.availableRepos) : null
             };
-
-            // Start backend server with nodemon for auto-restart
+            
+            // Start backend server
             processManager.spawnProcess(
                 'backend',
                 'npm',
-                ['run', 'server:dev'],
+                ['run', 'server'],
                 { cwd: managementUiPath, env }
             );
-
+            
             // Start frontend dev server
             processManager.spawnProcess(
                 'frontend',
@@ -99,71 +96,52 @@ async function uiCommand(options) {
                 ['run', 'dev'],
                 { cwd: managementUiPath, env }
             );
-
-            // Wait for backend to be ready by polling health endpoint
-            const maxAttempts = 20;
-            const delayMs = 250;
-            let backendReady = false;
-
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                try {
-                    const response = await fetch(`http://localhost:${port}/api/health`);
-                    if (response.ok) {
-                        backendReady = true;
-                        break;
-                    }
-                } catch (err) {
-                    // Backend not ready yet, wait and retry
-                }
-                await new Promise(resolve => setTimeout(resolve, delayMs));
-            }
-
-            if (!backendReady) {
-                console.warn('⚠️  Backend health check timed out, but continuing anyway...');
-            }
-
+            
+            // Wait for servers to start
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
             // Display clean status
             processManager.printStatus(
                 'http://localhost:5173',
                 `http://localhost:${port}`,
                 targetRepo.name
             );
-
+            
             // Open browser if requested
-            if (shouldOpenBrowser) {
+            if (shouldOpen) {
                 setTimeout(() => {
                     open('http://localhost:5173');
                 }, 1000);
             }
-
+            
         } else {
             // Production mode - just start the backend server
             const { FriggManagementServer } = await import('../../management-ui/server/index.js');
-
-            const server = new FriggManagementServer({
-                port,
+            
+            const server = new FriggManagementServer({ 
+                port, 
                 projectRoot: workingDirectory,
                 repositoryInfo: targetRepo,
                 availableRepositories: targetRepo.isMultiRepo ? targetRepo.availableRepos : null
             });
             await server.start();
-
+            
             processManager.printStatus(
                 `http://localhost:${port}`,
                 `http://localhost:${port}/api`,
                 targetRepo.name
             );
-
-            if (shouldOpenBrowser) {
+            
+            if (shouldOpen) {
                 setTimeout(() => {
                     open(`http://localhost:${port}`);
                 }, 1000);
             }
         }
-
+        
         // Keep the process running
         process.stdin.resume();
-
+        
     } catch (error) {
         console.error(chalk.red('Failed to start Management UI:'), error.message);
         if (error.code === 'EADDRINUSE') {

package/frigg-cli/utils/repo-detection.js

@@ -37,70 +37,17 @@ async function isFriggRepository(directory) {
             friggDependencies: []
         };
 
-        // Check for @friggframework/core v2.0+ specifically (REQUIRED for Frigg apps)
-        // Check both root package.json and backend/package.json for workspace projects
+        // Check for @friggframework dependencies
         const allDeps = {
             ...packageJson.dependencies,
-            ...packageJson.devDependencies
+            ...packageJson.devDependencies,
+            ...packageJson.peerDependencies
         };
 
-        // Check root package.json for core dependency
-        let coreVersion = allDeps['@friggframework/core'];
-        let hasFriggCore = coreVersion && (
-            coreVersion === 'next' ||
-            coreVersion.includes('2.0.0') ||
-            coreVersion.includes('next') ||
-            coreVersion.startsWith('^2.') ||
-            coreVersion.startsWith('~2.') ||
-            coreVersion.startsWith('2.')
-        );
-
-        // If not in root, check backend/package.json for workspace projects
-        if (!hasFriggCore) {
-            const backendPackagePath = path.join(directory, 'backend', 'package.json');
-            if (fs.existsSync(backendPackagePath)) {
-                try {
-                    const backendPackageJson = await fs.readJson(backendPackagePath);
-                    const backendDeps = {
-                        ...backendPackageJson.dependencies,
-                        ...backendPackageJson.devDependencies
-                    };
-                    coreVersion = backendDeps['@friggframework/core'];
-                    hasFriggCore = coreVersion && (
-                        coreVersion === 'next' ||
-                        coreVersion.includes('2.0.0') ||
-                        coreVersion.includes('next') ||
-                        coreVersion.startsWith('^2.') ||
-                        coreVersion.startsWith('~2.') ||
-                        coreVersion.startsWith('2.')
-                    );
-                } catch (error) {
-                    // Ignore errors reading backend package.json
-                }
-            }
-        }
-
-        if (hasFriggCore) {
-            indicators.hasFriggDependencies = true;
-            indicators.friggDependencies.push('@friggframework/core');
-        }
-
-        // Also track other Frigg dependencies for reference
         for (const dep in allDeps) {
-            if (dep.startsWith('@friggframework/') && dep !== '@friggframework/core') {
-                const version = allDeps[dep];
-                const isV2Plus = version && (
-                    version === 'next' ||
-                    version.includes('2.0.0') ||
-                    version.includes('next') ||
-                    version.startsWith('^2.') ||
-                    version.startsWith('~2.') ||
-                    version.startsWith('2.')
-                );
-
-                if (isV2Plus) {
-                    indicators.friggDependencies.push(dep);
-                }
+            if (dep.startsWith('@friggframework/')) {
+                indicators.hasFriggDependencies = true;
+                indicators.friggDependencies.push(dep);
             }
         }
 
@@ -189,33 +136,42 @@ async function isFriggRepository(directory) {
             }
         }
 
-        // STRICT VALIDATION: A directory is considered a Frigg app repository ONLY if:
-        // 1. Has @friggframework/core v2.0+ as a direct dependency (MANDATORY)
-        // 2. Has actual Frigg app structure (index.js with Definition OR backend/serverless.yml)
-        // 3. Is NOT a framework package itself (no @friggframework/* package name)
-
-        // Check for Frigg app structure indicators
-        const hasRootIndexJs = fs.existsSync(path.join(directory, 'index.js'));
-        const hasBackendIndexJs = fs.existsSync(path.join(directory, 'backend', 'index.js'));
-        const hasBackendServerless = fs.existsSync(path.join(directory, 'backend', 'serverless.yml'));
-        const hasAppStructure = hasRootIndexJs || hasBackendIndexJs || hasBackendServerless;
+        // A directory is considered a Frigg repo if it has:
+        // 1. Frigg dependencies (MANDATORY - most reliable indicator) OR
+        // 2. Frigg-specific configuration files OR
+        // 3. Frigg-specific directories OR
+        // 4. Frigg-specific scripts in package.json OR
+        // 5. Serverless config with explicit Frigg references AND proper structure
+        // 
+        // For Zapier apps, we require explicit Frigg indicators
+        const hasFriggIndicators = indicators.hasFriggDependencies || 
+                                  indicators.hasFriggConfig || 
+                                  indicators.hasFriggDirectories ||
+                                  indicators.hasFriggScripts ||
+                                  hasFriggServerlessIndicators;
+
+        // Determine if it's a Frigg repository
+        let isFriggRepo = false;
+        
+        if (isZapierApp) {
+            // For Zapier apps, require explicit Frigg dependencies or config
+            isFriggRepo = indicators.hasFriggDependencies || indicators.hasFriggConfig;
+        } else {
+            // For non-Zapier apps, any Frigg indicator is sufficient
+            isFriggRepo = hasFriggIndicators;
+        }
 
-        // Determine if it's a Frigg repository with STRICT criteria
-        const isFriggRepo = indicators.hasFriggDependencies && hasAppStructure;
+        // Additional validation for edge cases
+        if (isZapierApp && !indicators.hasFriggDependencies && !indicators.hasFriggConfig) {
+            return { isFriggRepo: false, repoInfo: null };
+        }
 
         if (isFriggRepo) {
-            // IMPORTANT: If backend/ has a Frigg app structure, use backend/ as the path
-            // This handles workspace projects where the actual app is in backend/
-            let actualPath = directory;
-            if (hasBackendIndexJs || hasBackendServerless) {
-                actualPath = path.join(directory, 'backend');
-            }
-
             return {
                 isFriggRepo: true,
                 repoInfo: {
                     name: packageJson.name || path.basename(directory),
-                    path: actualPath,
+                    path: directory,
                     version: packageJson.version,
                     framework: detectFramework(directory, existingFrontendDirs),
                     hasBackend: fs.existsSync(path.join(directory, 'backend')),
@@ -289,16 +245,12 @@ async function discoverFriggRepositories(options = {}) {
         searchPaths = [
             process.cwd(),
             path.join(os.homedir(), 'Documents'),
-            path.join(os.homedir(), 'Documents', 'GitHub'),  // Common GitHub Desktop location
             path.join(os.homedir(), 'Projects'),
             path.join(os.homedir(), 'Development'),
             path.join(os.homedir(), 'dev'),
-            path.join(os.homedir(), 'Code'),
-            path.join(os.homedir(), 'GitHub'),  // Alternative GitHub location
-            path.join(os.homedir(), 'repos'),   // Common repos folder
-            path.join(os.homedir(), 'src')      // Common source folder
+            path.join(os.homedir(), 'Code')
         ],
-        maxDepth = 4,  // Increased to handle deeper nested projects (e.g., org/apps/project)
+        maxDepth = 3,
         excludePatterns = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage']
     } = options;
 

package/infrastructure/docs/iam-policy-templates.md

@@ -160,7 +160,7 @@ Consider separate policies for different environments:
 ### Validation
 Test your policy by deploying a simple Frigg app:
 ```bash
-frigg init test-deployment
+npx create-frigg-app test-deployment
 cd test-deployment
 frigg deploy
 ```

package/infrastructure/domains/networking/vpc-builder.test.js

@@ -1500,9 +1500,10 @@ describe('VpcBuilder', () => {
                 }
             };
             
+            // Discovery results matching ACTUAL Frontify production stack
             const discoveredResources = {
                 fromCloudFormationStack: true,
-                stackName: 'frigg-app-production',
+                stackName: 'create-frigg-app-production',
                 existingLogicalIds: [
                     'FriggLambdaRouteTable',
                     'FriggNATRoute',  // OLD naming
@@ -1565,9 +1566,10 @@ describe('VpcBuilder', () => {
         });
 
         it('should convert OLD logical IDs to structured discovery stackManaged array', () => {
+            // TDD test: Verify that VPCEndpointS3 in existingLogicalIds gets added to stackManaged
             const flatDiscovery = {
                 fromCloudFormationStack: true,
-                stackName: 'frigg-app-production',
+                stackName: 'create-frigg-app-production',
                 existingLogicalIds: [
                     'VPCEndpointS3',        // OLD naming
                     'VPCEndpointDynamoDB',  // OLD naming

package/infrastructure/domains/networking/vpc-resolver.test.js

@@ -746,7 +746,7 @@ describe('VpcResourceResolver', () => {
                 ],
                 external: [],
                 fromCloudFormation: true,
-                stackName: 'frigg-app-production'
+                stackName: 'create-frigg-app-production'
             };
 
             const decisions = resolver.resolveAll(appDefinition, discovery);