@friggframework/devtools 2.0.0--canary.398.7664c46.0 → 2.0.0--canary.400.bed3308.0

package/frigg-cli/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@friggframework/cli",
+  "version": "1.0.0",
+  "description": "Frigg Framework CLI for serverless application development",
+  "main": "index.js",
+  "bin": {
+    "frigg": "./index.js"
+  },
+  "scripts": {
+    "test": "jest --config __tests__/jest.config.js",
+    "test:watch": "jest --config __tests__/jest.config.js --watch",
+    "test:coverage": "jest --config __tests__/jest.config.js --coverage",
+    "test:unit": "jest --config __tests__/jest.config.js --testPathPattern=unit",
+    "test:integration": "jest --config __tests__/jest.config.js --testPathPattern=integration",
+    "test:e2e": "jest --config __tests__/jest.config.js --testPathPattern=e2e",
+    "test:ci": "jest --config __tests__/jest.config.js --coverage --ci --watchAll=false",
+    "lint": "eslint *.js **/*.js --ignore-pattern node_modules --ignore-pattern __tests__",
+    "lint:fix": "eslint *.js **/*.js --ignore-pattern node_modules --ignore-pattern __tests__ --fix",
+    "typecheck": "echo 'No TypeScript files to check'",
+    "pretest": "npm run lint",
+    "posttest": "npm run test:coverage"
+  },
+  "keywords": [
+    "frigg",
+    "framework",
+    "cli",
+    "serverless",
+    "aws",
+    "lambda",
+    "api",
+    "integration"
+  ],
+  "author": "Frigg Framework Team",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.0.0",
+    "@friggframework/core": "workspace:*"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "jest-sonar-reporter": "^2.0.0",
+    "eslint": "^8.57.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/friggframework/frigg.git",
+    "directory": "packages/devtools/frigg-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/friggframework/frigg/issues"
+  },
+  "homepage": "https://github.com/friggframework/frigg#readme",
+  "files": [
+    "*.js",
+    "install-command/",
+    "build-command/",
+    "deploy-command/",
+    "generate-command/",
+    "ui-command/",
+    "utils/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

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

@@ -1,15 +1,30 @@
 const { spawn } = require('node:child_process');
 const path = require('node:path');
+const { AppResolver } = require('../utils/app-resolver');
 
-function startCommand(options) {
+async function startCommand(options) {
     if (options.verbose) {
         console.log('Verbose mode enabled');
         console.log('Options:', options);
     }
     console.log('Starting backend and optional frontend...');
+    
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = 1;
-    const backendPath = path.resolve(process.cwd());
+    
+    // Resolve app path using AppResolver
+    const appResolver = new AppResolver();
+    let backendPath;
+    
+    try {
+        backendPath = await appResolver.resolveAppPath(options);
+        if (options.verbose) {
+            console.log('Resolved app path:', backendPath);
+        }
+    } catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
     console.log(`Starting backend in ${backendPath}...`);
     const infrastructurePath = 'infrastructure.js';
     const command = 'serverless';

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

@@ -0,0 +1,167 @@
+const open = require('open');
+const chalk = require('chalk');
+const path = require('path');
+const ProcessManager = require('../utils/process-manager');
+const { AppResolver } = require('../utils/app-resolver');
+const { 
+    getCurrentRepositoryInfo, 
+    discoverFriggRepositories, 
+    promptRepositorySelection,
+    formatRepositoryInfo 
+} = require('../utils/repo-detection');
+
+async function uiCommand(options) {
+    const { port = 3001, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
+    
+    let targetRepo = null;
+    let workingDirectory = process.cwd();
+
+    // Check if new app path options are provided
+    if (options.appPath || options.config || options.app || process.env.FRIGG_APP_PATH) {
+        // Use AppResolver for new path resolution
+        const appResolver = new AppResolver();
+        try {
+            workingDirectory = await appResolver.resolveAppPath(options);
+            targetRepo = { path: workingDirectory, name: path.basename(workingDirectory) };
+            console.log(chalk.green(`✓ Resolved Frigg application: ${workingDirectory}`));
+        } catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    } else if (specifiedRepo) {
+        // Legacy repo option support
+        const repoPath = path.resolve(specifiedRepo);
+        console.log(chalk.blue(`Using specified repository: ${repoPath}`));
+        workingDirectory = repoPath;
+        targetRepo = { path: repoPath, name: path.basename(repoPath) };
+    } else {
+        // 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) {
+                console.log(chalk.gray(`  Currently in subdirectory: ${currentRepo.currentSubPath}`));
+            }
+            targetRepo = currentRepo;
+            workingDirectory = currentRepo.path;
+        } else {
+            // 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', 
+                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,
+                VITE_API_URL: `http://localhost:${port}`,
+                PORT: port,
+                PROJECT_ROOT: workingDirectory,
+                REPOSITORY_INFO: JSON.stringify(targetRepo),
+                AVAILABLE_REPOSITORIES: targetRepo.isMultiRepo ? JSON.stringify(targetRepo.availableRepos) : null
+            };
+            
+            // Start backend server
+            processManager.spawnProcess(
+                'backend',
+                'npm',
+                ['run', 'server'],
+                { cwd: managementUiPath, env }
+            );
+            
+            // Start frontend dev server
+            processManager.spawnProcess(
+                'frontend',
+                'npm',
+                ['run', 'dev'],
+                { cwd: managementUiPath, env }
+            );
+            
+            // 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 (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, 
+                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 (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') {
+            console.log(chalk.yellow(`Port ${port} is already in use. Try using a different port with --port <number>`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { uiCommand };

package/frigg-cli/utils/app-resolver.js

@@ -0,0 +1,319 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+class AppResolver {
+    constructor() {
+        this.cache = new Map();
+    }
+
+    async resolveAppPath(options = {}) {
+        const cacheKey = JSON.stringify(options);
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+
+        let resolvedPath;
+
+        // Priority 1: Explicit flags (--app-path, --config, --app)
+        if (options.appPath || options.config || options.app) {
+            const explicitPath = options.appPath || options.config || options.app;
+            resolvedPath = await this.validateAndResolvePath(explicitPath);
+            if (resolvedPath) {
+                this.cache.set(cacheKey, resolvedPath);
+                return resolvedPath;
+            }
+            throw new Error(`Invalid app path specified: ${explicitPath}`);
+        }
+
+        // Priority 2: Environment variable
+        if (process.env.FRIGG_APP_PATH) {
+            resolvedPath = await this.validateAndResolvePath(process.env.FRIGG_APP_PATH);
+            if (resolvedPath) {
+                this.cache.set(cacheKey, resolvedPath);
+                return resolvedPath;
+            }
+            console.warn(`Warning: FRIGG_APP_PATH environment variable points to invalid path: ${process.env.FRIGG_APP_PATH}`);
+        }
+
+        // Priority 3: Current directory auto-detection (backward compatibility)
+        resolvedPath = await this.autoDetectFriggApp();
+        if (resolvedPath) {
+            this.cache.set(cacheKey, resolvedPath);
+            return resolvedPath;
+        }
+
+        // Priority 4: Search common development directories
+        resolvedPath = await this.searchCommonDirectories();
+        if (resolvedPath) {
+            this.cache.set(cacheKey, resolvedPath);
+            return resolvedPath;
+        }
+
+        throw new Error('No Frigg application found. Use --app-path to specify the application directory.');
+    }
+
+    async validateAndResolvePath(inputPath) {
+        if (!inputPath) return null;
+
+        // Handle different path formats
+        let resolvedPath;
+        if (inputPath.startsWith('~/')) {
+            resolvedPath = path.join(os.homedir(), inputPath.slice(2));
+        } else if (path.isAbsolute(inputPath)) {
+            resolvedPath = inputPath;
+        } else {
+            resolvedPath = path.resolve(process.cwd(), inputPath);
+        }
+
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                // If it's a file, check if it's a config file and use its directory
+                if (await this.isConfigFile(resolvedPath)) {
+                    resolvedPath = path.dirname(resolvedPath);
+                } else {
+                    return null;
+                }
+            }
+
+            // Validate that this is a Frigg application
+            if (await this.isFriggApplication(resolvedPath)) {
+                return resolvedPath;
+            }
+        } catch (error) {
+            // Path doesn't exist or is not accessible
+            return null;
+        }
+
+        return null;
+    }
+
+    async isConfigFile(filePath) {
+        const basename = path.basename(filePath);
+        const configFiles = [
+            'frigg.config.js',
+            'frigg.config.json',
+            '.friggrc',
+            '.friggrc.js',
+            '.friggrc.json',
+            'package.json'
+        ];
+        
+        return configFiles.includes(basename);
+    }
+
+    async isFriggApplication(dirPath) {
+        try {
+            // Check for package.json with Frigg dependencies
+            const packageJsonPath = path.join(dirPath, 'package.json');
+            try {
+                const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+                const packageJson = JSON.parse(packageJsonContent);
+                
+                // Check for @friggframework dependencies
+                const deps = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies,
+                    ...packageJson.peerDependencies
+                };
+                
+                if (Object.keys(deps).some(dep => dep.startsWith('@friggframework/'))) {
+                    return true;
+                }
+
+                // Check for frigg scripts
+                if (packageJson.scripts) {
+                    const scriptNames = Object.keys(packageJson.scripts);
+                    if (scriptNames.some(script => script.includes('frigg'))) {
+                        return true;
+                    }
+                }
+            } catch (error) {
+                // package.json doesn't exist or is invalid, continue checking other indicators
+            }
+
+            // Check for Frigg configuration files
+            const configFiles = [
+                'frigg.config.js',
+                'frigg.config.json',
+                '.friggrc',
+                '.friggrc.js',
+                '.friggrc.json'
+            ];
+
+            for (const configFile of configFiles) {
+                try {
+                    await fs.access(path.join(dirPath, configFile));
+                    return true;
+                } catch (error) {
+                    // File doesn't exist, continue
+                }
+            }
+
+            // Check for Frigg-specific directories
+            const friggDirectories = [
+                '.frigg',
+                'frigg-modules',
+                'api-modules'
+            ];
+
+            for (const friggDir of friggDirectories) {
+                try {
+                    const dirStat = await fs.stat(path.join(dirPath, friggDir));
+                    if (dirStat.isDirectory()) {
+                        return true;
+                    }
+                } catch (error) {
+                    // Directory doesn't exist, continue
+                }
+            }
+
+            // Check for serverless.yml with Frigg references
+            try {
+                const serverlessPath = path.join(dirPath, 'serverless.yml');
+                const serverlessContent = await fs.readFile(serverlessPath, 'utf8');
+                if (serverlessContent.includes('frigg') || serverlessContent.includes('Frigg')) {
+                    return true;
+                }
+            } catch (error) {
+                // serverless.yml doesn't exist or can't be read
+            }
+
+            // Check for infrastructure.js (common in Frigg apps)
+            try {
+                await fs.access(path.join(dirPath, 'infrastructure.js'));
+                return true;
+            } catch (error) {
+                // infrastructure.js doesn't exist
+            }
+
+            return false;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async autoDetectFriggApp() {
+        // Start from current directory and search up to 3 levels
+        let currentDir = process.cwd();
+        
+        for (let i = 0; i < 3; i++) {
+            if (await this.isFriggApplication(currentDir)) {
+                return currentDir;
+            }
+            
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                // Reached filesystem root
+                break;
+            }
+            currentDir = parentDir;
+        }
+
+        return null;
+    }
+
+    async searchCommonDirectories() {
+        const commonDirs = [
+            path.join(os.homedir(), 'Documents'),
+            path.join(os.homedir(), 'Projects'),
+            path.join(os.homedir(), 'Development'),
+            path.join(os.homedir(), 'dev'),
+            path.join(os.homedir(), 'workspace')
+        ];
+
+        for (const baseDir of commonDirs) {
+            try {
+                const friggApp = await this.searchDirectoryRecursively(baseDir, 3);
+                if (friggApp) {
+                    return friggApp;
+                }
+            } catch (error) {
+                // Directory doesn't exist or can't be accessed, continue
+            }
+        }
+
+        return null;
+    }
+
+    async searchDirectoryRecursively(dirPath, maxDepth) {
+        if (maxDepth <= 0) return null;
+
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            
+            // First check if current directory is a Frigg app
+            if (await this.isFriggApplication(dirPath)) {
+                return dirPath;
+            }
+
+            // Then search subdirectories
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                
+                // Skip common directories that shouldn't contain Frigg apps
+                const skipDirs = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];
+                if (skipDirs.includes(entry.name)) continue;
+
+                const subDirPath = path.join(dirPath, entry.name);
+                const result = await this.searchDirectoryRecursively(subDirPath, maxDepth - 1);
+                if (result) {
+                    return result;
+                }
+            }
+        } catch (error) {
+            // Directory can't be read, skip
+        }
+
+        return null;
+    }
+
+    async loadAppConfig(appPath) {
+        const configPaths = [
+            path.join(appPath, 'frigg.config.js'),
+            path.join(appPath, 'frigg.config.json'),
+            path.join(appPath, '.friggrc.js'),
+            path.join(appPath, '.friggrc.json'),
+            path.join(appPath, '.friggrc')
+        ];
+
+        for (const configPath of configPaths) {
+            try {
+                const stats = await fs.stat(configPath);
+                if (stats.isFile()) {
+                    if (configPath.endsWith('.js')) {
+                        delete require.cache[require.resolve(configPath)];
+                        return require(configPath);
+                    } else {
+                        const content = await fs.readFile(configPath, 'utf8');
+                        return JSON.parse(content);
+                    }
+                }
+            } catch (error) {
+                // Config file doesn't exist or can't be read, continue
+            }
+        }
+
+        // Fallback to package.json frigg configuration
+        try {
+            const packageJsonPath = path.join(appPath, 'package.json');
+            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonContent);
+            
+            if (packageJson.frigg) {
+                return packageJson.frigg;
+            }
+        } catch (error) {
+            // package.json doesn't exist or doesn't have frigg config
+        }
+
+        return {};
+    }
+
+    clearCache() {
+        this.cache.clear();
+    }
+}
+
+module.exports = { AppResolver };

package/frigg-cli/utils/backend-path.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+const PACKAGE_JSON = 'package.json';
+
+function findNearestBackendPackageJson() {
+    let currentDir = process.cwd();
+    
+    // First check if we're in production by looking for package.json in the current directory
+    const rootPackageJson = path.join(currentDir, PACKAGE_JSON);
+    if (fs.existsSync(rootPackageJson)) {
+        // In production environment, check for index.js in the same directory
+        const indexJs = path.join(currentDir, 'index.js');
+        if (fs.existsSync(indexJs)) {
+            return rootPackageJson;
+        }
+    }
+
+    // If not found at root or not in production, look for it in the backend directory
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
+        if (fs.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+
+function validateBackendPath(backendPath) {
+    if (!backendPath) {
+        throw new Error('Could not find a backend package.json file.');
+    }
+}
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+};