@friggframework/devtools 2.0.0--canary.545.88cf983.0 → 2.0.0--canary.545.c870571.0

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

@@ -1,7 +1,15 @@
 const { spawnSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
 
 async function buildCommand(options) {
+    // Check if the app uses a non-AWS provider
+    const providerResult = loadProviderIfConfigured();
+    if (providerResult) {
+        return buildWithProvider(providerResult, options);
+    }
+
+    // Default: AWS build via serverless framework
     console.log('Building the serverless application...');
 
     // Suppress AWS SDK warning message about maintenance mode
@@ -10,13 +18,13 @@ async function buildCommand(options) {
     // Skip AWS discovery for local builds (unless --production flag is set)
     if (!options.production) {
         process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
-        console.log('🏠 Building in local mode (use --production flag for production builds with AWS discovery)');
+        console.log('Building in local mode (use --production flag for production builds with AWS discovery)');
     } else {
-        console.log('🚀 Building in production mode with AWS discovery enabled');
+        console.log('Building in production mode with AWS discovery enabled');
     }
 
     // AWS discovery is now handled directly in serverless-template.js
-    console.log('📦 Packaging serverless application...');
+    console.log('Packaging serverless application...');
     const backendPath = path.resolve(process.cwd());
     const infrastructurePath = 'infrastructure.js';
     const command = 'osls';  // OSS-Serverless (drop-in replacement for serverless v3)
@@ -51,16 +59,102 @@ async function buildCommand(options) {
         console.error(`Serverless build failed with code ${result.status}`);
         process.exit(1);
     }
+}
+
+/**
+ * Check if the appDefinition specifies a non-AWS provider and resolve it.
+ */
+function loadProviderIfConfigured() {
+    try {
+        const { loadProviderForCli } = require('../utils/provider-helper');
+        const result = loadProviderForCli();
+        if (result && result.provider) {
+            return result;
+        }
+    } catch {
+        // Provider helper not available or appDefinition not found — fall through
+    }
+    return null;
+}
+
+/**
+ * Build using a provider plugin.
+ * Provider build steps:
+ *   1. generateConfig() — generate platform-specific config (netlify.toml, etc.)
+ *   2. getFunctionEntryPoints() — copy function files to the project
+ */
+async function buildWithProvider({ provider, appDefinition, providerName }, options) {
+    console.log(`Building for ${providerName} provider...`);
+    const projectDir = path.resolve(process.cwd());
+
+    // 1. Validate
+    if (typeof provider.validate === 'function') {
+        const validation = provider.validate(appDefinition);
+        if (validation.errors?.length > 0) {
+            console.error(`\nValidation errors for ${providerName}:`);
+            for (const error of validation.errors) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+        if (validation.warnings?.length > 0) {
+            for (const warning of validation.warnings) {
+                console.warn(`  Warning: ${warning}`);
+            }
+        }
+    }
+
+    // 2. Generate platform config (e.g., netlify.toml)
+    if (typeof provider.generateConfig === 'function') {
+        console.log(`Generating ${providerName} configuration...`);
+        const config = provider.generateConfig(appDefinition);
 
-    // childProcess.on('error', (error) => {
-    //     console.error(`Error executing command: ${error.message}`);
-    // });
+        const configFileNames = {
+            netlify: 'netlify.toml',
+        };
+        const configFileName = configFileNames[providerName] || `${providerName}.config`;
+        const configPath = path.join(projectDir, configFileName);
+
+        fs.writeFileSync(configPath, config, 'utf-8');
+        console.log(`  Written ${configFileName}`);
+    }
+
+    // 3. Copy function entry points
+    if (typeof provider.getFunctionEntryPoints === 'function') {
+        console.log('Generating function entry points...');
+        const entryPoints = provider.getFunctionEntryPoints(appDefinition);
+        const functionsDir = path.join(projectDir, 'netlify', 'functions');
+
+        fs.mkdirSync(functionsDir, { recursive: true });
+
+        for (const [filename, content] of Object.entries(entryPoints)) {
+            const filePath = path.join(functionsDir, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+            if (options.verbose) {
+                console.log(`  Written ${path.relative(projectDir, filePath)}`);
+            }
+        }
+
+        console.log(`  Generated ${Object.keys(entryPoints).length} function entry points`);
+    }
+
+    // 4. Generate env template (informational)
+    if (typeof provider.generateEnvTemplate === 'function') {
+        const envTemplate = provider.generateEnvTemplate(appDefinition);
+        const missingEnvVars = Object.entries(envTemplate)
+            .filter(([key]) => !process.env[key])
+            .map(([key, desc]) => `${key}: ${desc}`);
+
+        if (missingEnvVars.length > 0) {
+            console.log(`\n  Required environment variables not set locally:`);
+            for (const entry of missingEnvVars) {
+                console.log(`    - ${entry}`);
+            }
+            console.log(`  Configure these in your ${providerName} dashboard.`);
+        }
+    }
 
-    // childProcess.on('close', (code) => {
-    //     if (code !== 0) {
-    //         console.log(`Child process exited with code ${code}`);
-    //     }
-    // });
+    console.log(`\nBuild complete for ${providerName}.`);
 }
 
 module.exports = { buildCommand };

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

@@ -268,9 +268,17 @@ async function runPostDeploymentHealthCheck(stackName, options) {
 }
 
 async function deployCommand(options) {
+    const appDefinition = loadAppDefinition();
+
+    // Check if the app uses a non-AWS provider
+    const providerResult = loadProviderIfConfigured(appDefinition);
+    if (providerResult) {
+        return deployWithProvider(providerResult, options);
+    }
+
+    // Default: AWS deployment via serverless framework
     console.log('Deploying the serverless application...');
 
-    const appDefinition = loadAppDefinition();
     const environment = validateAndBuildEnvironment(appDefinition, options);
 
     // Execute deployment
@@ -302,4 +310,78 @@ async function deployCommand(options) {
     }
 }
 
+/**
+ * Check if the appDefinition specifies a non-AWS provider and resolve it.
+ * Returns null for AWS (default) so the caller falls through to existing behavior.
+ *
+ * @param {Object|null} appDefinition
+ * @returns {{ provider: Object, appDefinition: Object, providerName: string } | null}
+ */
+function loadProviderIfConfigured(appDefinition) {
+    const providerName = appDefinition?.provider;
+    if (!providerName || providerName === 'aws') {
+        return null;
+    }
+
+    try {
+        const { resolveProvider } = require('@friggframework/core/providers/resolve-provider');
+        const provider = resolveProvider(appDefinition);
+        return { provider, appDefinition, providerName };
+    } catch (error) {
+        console.error(`Failed to load provider '${providerName}': ${error.message}`);
+        process.exit(1);
+    }
+}
+
+/**
+ * Deploy using a provider plugin (Netlify, etc.).
+ * Delegates entirely to the provider's deploy lifecycle:
+ *   1. validate() — check appDefinition for provider-specific issues
+ *   2. preflightCheck() — verify prerequisites (CLI tools, credentials)
+ *   3. deploy() — execute the deployment
+ */
+async function deployWithProvider({ provider, appDefinition, providerName }, options) {
+    console.log(`Deploying with ${providerName} provider...`);
+
+    // 1. Validate appDefinition for this provider
+    if (typeof provider.validate === 'function') {
+        const validation = provider.validate(appDefinition);
+        if (validation.errors?.length > 0) {
+            console.error(`\nValidation errors for ${providerName}:`);
+            for (const error of validation.errors) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+        if (validation.warnings?.length > 0) {
+            for (const warning of validation.warnings) {
+                console.warn(`  Warning: ${warning}`);
+            }
+        }
+    }
+
+    // 2. Deploy via provider
+    try {
+        const result = await provider.deploy(appDefinition, {
+            stage: options.stage,
+            prod: options.stage === 'production' || options.stage === 'prod',
+            dryRun: options.dryRun || false,
+        });
+
+        console.log(`\n✓ Deployment completed successfully!`);
+        if (result.url) {
+            console.log(`  URL: ${result.url}`);
+        }
+    } catch (error) {
+        console.error(`\n✗ Deployment failed: ${error.message}`);
+        if (error.missing) {
+            console.error('  Missing prerequisites:');
+            for (const item of error.missing) {
+                console.error(`    - ${item}`);
+            }
+        }
+        process.exit(1);
+    }
+}
+
 module.exports = { deployCommand };

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

@@ -247,6 +247,13 @@ async function promptForStackSelection(region) {
  */
 async function doctorCommand(stackName, options = {}) {
     try {
+        // Guard: doctor only works with AWS (CloudFormation stacks)
+        if (isNonAwsProvider()) {
+            output.error('The doctor command is only available for AWS deployments.');
+            output.log('Your appDefinition uses a non-AWS provider.');
+            process.exit(1);
+        }
+
         // Extract options with defaults
         const region = options.region || process.env.AWS_REGION || 'us-east-1';
         const format = options.format || 'console';
@@ -333,4 +340,17 @@ async function doctorCommand(stackName, options = {}) {
     }
 }
 
+/**
+ * Check if the current appDefinition uses a non-AWS provider.
+ */
+function isNonAwsProvider() {
+    try {
+        const { loadProviderForCli } = require('../utils/provider-helper');
+        const result = loadProviderForCli();
+        return result && result.providerName !== 'aws';
+    } catch {
+        return false;
+    }
+}
+
 module.exports = { doctorCommand };

package/frigg-cli/generate-iam-command.js

@@ -9,7 +9,14 @@ const { generateIAMCloudFormation, getFeatureSummary } = require('../infrastruct
  */
 async function generateIamCommand(options = {}) {
     try {
-        console.log('🔍 Finding Frigg application...');
+        // Guard: generate-iam only works with AWS (IAM / CloudFormation)
+        if (isNonAwsProvider()) {
+            console.error('The generate-iam command is only available for AWS deployments.');
+            console.log('Your appDefinition uses a non-AWS provider.');
+            process.exit(1);
+        }
+
+        console.log('Finding Frigg application...');
 
         // Find the backend package.json
         const backendPath = findNearestBackendPackageJson();
@@ -115,4 +122,17 @@ async function generateIamCommand(options = {}) {
     }
 }
 
+/**
+ * Check if the current appDefinition uses a non-AWS provider.
+ */
+function isNonAwsProvider() {
+    try {
+        const { loadProviderForCli } = require('./utils/provider-helper');
+        const result = loadProviderForCli();
+        return result && result.providerName !== 'aws';
+    } catch {
+        return false;
+    }
+}
+
 module.exports = { generateIamCommand };

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

@@ -426,6 +426,13 @@ async function handleReconcileRepair(stackIdentifier, report, options) {
  */
 async function repairCommand(stackName, options = {}) {
     try {
+        // Guard: repair only works with AWS (CloudFormation stacks)
+        if (isNonAwsProvider()) {
+            output.error('The repair command is only available for AWS deployments.');
+            output.log('Your appDefinition uses a non-AWS provider.');
+            process.exit(1);
+        }
+
         // Validate required parameter
         if (!stackName) {
             output.error('Error: Stack name is required');
@@ -534,4 +541,17 @@ async function repairCommand(stackName, options = {}) {
     }
 }
 
+/**
+ * Check if the current appDefinition uses a non-AWS provider.
+ */
+function isNonAwsProvider() {
+    try {
+        const { loadProviderForCli } = require('../utils/provider-helper');
+        const result = loadProviderForCli();
+        return result && result.providerName !== 'aws';
+    } catch {
+        return false;
+    }
+}
+
 module.exports = { repairCommand };

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

@@ -63,6 +63,13 @@ async function startCommand(options) {
     console.log(chalk.green('✓ Pre-flight checks passed\n'));
     console.log('Starting backend and optional frontend...');
 
+    // Check if the app uses a non-AWS provider
+    const providerResult = loadProviderIfConfigured();
+    if (providerResult) {
+        return startWithProvider(providerResult, options);
+    }
+
+    // Default: AWS local development via serverless-offline
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = '1';
     // Skip AWS discovery for local development
@@ -109,6 +116,76 @@ async function startCommand(options) {
     });
 }
 
+/**
+ * Check if the appDefinition specifies a non-AWS provider and resolve it.
+ * Returns null for AWS (default) so the caller falls through to existing behavior.
+ */
+function loadProviderIfConfigured() {
+    try {
+        const { loadProviderForCli } = require('../utils/provider-helper');
+        const result = loadProviderForCli();
+        if (result && result.provider) {
+            return result;
+        }
+    } catch {
+        // Provider helper not available or appDefinition not found — fall through
+    }
+    return null;
+}
+
+/**
+ * Start local dev server using the provider's recommended approach.
+ * Each provider has a different local dev story:
+ *   - Netlify: `netlify dev` (reads netlify.toml, serves functions locally)
+ *   - AWS: `osls offline` (serverless-offline, handled by default path above)
+ */
+function startWithProvider({ provider, providerName }, options) {
+    const backendPath = path.resolve(process.cwd());
+
+    // Provider-specific dev server commands
+    const DEV_COMMANDS = {
+        netlify: { command: 'netlify', args: ['dev'] },
+    };
+
+    const devCmd = DEV_COMMANDS[providerName];
+    if (!devCmd) {
+        console.error(chalk.red(
+            `Provider '${providerName}' does not have a local dev server configured.\n` +
+            `  Supported providers for local dev: ${Object.keys(DEV_COMMANDS).join(', ')}, aws`
+        ));
+        process.exit(1);
+    }
+
+    console.log(chalk.blue(`Starting local dev server (${providerName})...`));
+
+    const args = [...devCmd.args];
+    if (options.verbose) {
+        console.log(`Executing command: ${devCmd.command} ${args.join(' ')}`);
+        console.log(`Working directory: ${backendPath}`);
+    }
+
+    const childProcess = spawn(devCmd.command, args, {
+        cwd: backendPath,
+        stdio: 'inherit',
+        env: { ...process.env },
+    });
+
+    childProcess.on('error', (error) => {
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(
+                `'${devCmd.command}' not found. Install it with: npm install -g ${devCmd.command}-cli`
+            ));
+        } else {
+            console.error(`Error executing command: ${error.message}`);
+        }
+    });
+
+    childProcess.on('close', (code) => {
+        if (code !== 0) {
+            console.log(`Child process exited with code ${code}`);
+        }
+    });
+
 /**
  * Run interactive pre-flight checks with resolution prompts
  * @param {string} projectPath - Path to the Frigg project

package/frigg-cli/utils/__tests__/provider-helper.test.js

@@ -0,0 +1,55 @@
+const path = require('path');
+const { loadProviderForCli, loadCliAppDefinition } = require('../provider-helper');
+
+describe('provider-helper', () => {
+    describe('loadCliAppDefinition', () => {
+        it('returns null when no index.js exists', () => {
+            const result = loadCliAppDefinition('/nonexistent/path');
+            expect(result).toBeNull();
+        });
+
+        it('returns null when index.js has no Definition export', () => {
+            // Use a directory that has an index.js but no Definition
+            const result = loadCliAppDefinition(
+                path.join(__dirname, '..', '..')
+            );
+            // frigg-cli/index.js doesn't export Definition
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('loadProviderForCli', () => {
+        it('returns null when no appDefinition found', () => {
+            // Run from a directory with no Frigg app
+            const originalCwd = process.cwd();
+            try {
+                process.chdir('/tmp');
+                const result = loadProviderForCli();
+                expect(result).toBeNull();
+            } finally {
+                process.chdir(originalCwd);
+            }
+        });
+
+        it('returns null provider for aws (default)', () => {
+            // Mock: loadCliAppDefinition returns an appDef with provider: 'aws'
+            jest.mock('../provider-helper', () => {
+                const original = jest.requireActual('../provider-helper');
+                return {
+                    ...original,
+                    loadProviderForCli: (options) => {
+                        // Simulate AWS provider (no provider field defaults to aws)
+                        return { appDefinition: { provider: 'aws' }, provider: null, providerName: 'aws' };
+                    },
+                };
+            });
+
+            const { loadProviderForCli: mocked } = require('../provider-helper');
+            const result = mocked();
+            expect(result.providerName).toBe('aws');
+            expect(result.provider).toBeNull();
+
+            jest.restoreAllMocks();
+        });
+    });
+});

package/frigg-cli/utils/provider-helper.js

@@ -0,0 +1,75 @@
+/**
+ * CLI Provider Helper
+ *
+ * Loads the appDefinition from the user's project and resolves the
+ * corresponding provider plugin package. Used by CLI commands to
+ * delegate to the correct provider (AWS, Netlify, etc.).
+ */
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Load the appDefinition and resolve the provider plugin for CLI commands.
+ *
+ * This is a lightweight loader for the CLI context — it reads the backend
+ * index.js directly (no need for the full core app-definition-loader which
+ * searches for the nearest backend package.json at runtime).
+ *
+ * @param {Object} [options]
+ * @param {string} [options.cwd] - Working directory (default: process.cwd())
+ * @returns {{ appDefinition: Object, provider: Object, providerName: string } | null}
+ *   Returns null if no appDefinition is found (caller should fall back to default behavior).
+ */
+function loadProviderForCli(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const appDefinition = loadCliAppDefinition(cwd);
+
+    if (!appDefinition) {
+        return null;
+    }
+
+    const providerName = appDefinition.provider || 'aws';
+
+    // For 'aws', return null provider — CLI commands fall back to existing behavior
+    if (providerName === 'aws') {
+        return { appDefinition, provider: null, providerName: 'aws' };
+    }
+
+    // For other providers, resolve the package
+    const {
+        resolveProvider,
+    } = require('@friggframework/core/providers/resolve-provider');
+
+    const provider = resolveProvider(appDefinition);
+    return { appDefinition, provider, providerName };
+}
+
+/**
+ * Load the appDefinition from the backend directory.
+ * Tries backend/index.js then index.js in the current directory.
+ *
+ * @param {string} cwd
+ * @returns {Object|null}
+ */
+function loadCliAppDefinition(cwd) {
+    // Try backend/index.js first (standard Frigg app structure)
+    const backendIndexPath = path.join(cwd, 'backend', 'index.js');
+    const rootIndexPath = path.join(cwd, 'index.js');
+
+    for (const indexPath of [backendIndexPath, rootIndexPath]) {
+        if (fs.existsSync(indexPath)) {
+            try {
+                const exported = require(indexPath);
+                if (exported.Definition) {
+                    return exported.Definition;
+                }
+            } catch {
+                // Failed to load, try next
+            }
+        }
+    }
+
+    return null;
+}
+
+module.exports = { loadProviderForCli, loadCliAppDefinition };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.545.88cf983.0",
+  "version": "2.0.0--canary.545.c870571.0",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -25,9 +25,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0--canary.545.88cf983.0",
-    "@friggframework/schemas": "2.0.0--canary.545.88cf983.0",
-    "@friggframework/test": "2.0.0--canary.545.88cf983.0",
+    "@friggframework/core": "2.0.0--canary.545.c870571.0",
+    "@friggframework/schemas": "2.0.0--canary.545.c870571.0",
+    "@friggframework/test": "2.0.0--canary.545.c870571.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -55,8 +55,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.545.88cf983.0",
-    "@friggframework/prettier-config": "2.0.0--canary.545.88cf983.0",
+    "@friggframework/eslint-config": "2.0.0--canary.545.c870571.0",
+    "@friggframework/prettier-config": "2.0.0--canary.545.c870571.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "exit-x": "^0.2.2",
@@ -89,5 +89,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "88cf983e3f46da0d15dc926fcc0b2a18344bd5f6"
+  "gitHead": "c8705715da2a28da19d7543735088d87660d0655"
 }