deploy-stack 0.13.0 → 0.14.0

package/README.md

@@ -30,7 +30,7 @@ You retain complete ownership of your infrastructure code without relying on bla
 **🚀 Zero-Config Deployments**
 * **Framework Agnostic:** Tailored container presets for Next.js, Express.js, FastAPI, Go, Django, Rails, Nuxt 3, and Static Sites (React, Vue, SvelteKit, Astro).
 * **Smart Discovery:** Automatically detects build output directories and generates highly optimized, multi-stage Dockerfiles.
-* **PaaS Migration Engine:** Natively parses Heroku `Procfile` configurations to automatically translate web and background worker processes (like Celery or Sidekiq) into multi-container AWS Fargate architectures.
+* **PaaS Migration Engine:** Natively parses Heroku `Procfile` configurations and `vercel.json` files to automatically translate proprietary edge routing (redirects/rewrites) and background workers into standard AWS Fargate and Application Load Balancer architectures.
 * **Database Scaffolding:** Automatically provisions fully isolated, zero-trust AWS RDS PostgreSQL databases for backend monoliths.
 
 **🛡️ DevSecOps & Security**
@@ -158,7 +158,7 @@ npx deploy-stack --no-telemetry
 
 ### Phase 6: Migration & Trust Engine (Current)
 - [x] **Dry-Run Visualization:** Interactive pre-flight terminal UI with ASCII topology maps and precise, dynamic AWS cost estimation.
-- [ ] **PaaS Importers:** Auto-parse `vercel.json` or Heroku `Procfile` configurations to map build commands and environment variables automatically.
+- [x] **PaaS Importers:** Auto-parse `vercel.json` and Heroku `Procfile` configurations to map routing rules, web commands, and background workers automatically.
 - [ ] **Docker Compose to ECS Translator:** Automatically converting a familiar local `docker-compose.yml` into production ECS task definitions.
 - [ ] **AI Agent Rulesets:** Publishing `.cursorrules` and Copilot instructions that teach AI assistants exactly how to utilize the CLI on the user's behalf.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deploy-stack",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Provision production-ready AWS infrastructure and CI/CD pipelines in seconds.",
   "engines": {
     "node": ">=18.0.0"

package/release-notes.md

@@ -0,0 +1,14 @@
+# 🚀 Vercel Escape Hatch, Orchestrator Refactor & Advanced Telemetry
+
+This release introduces the second half of our PaaS Migration Engine, focusing on seamlessly escaping Vercel's proprietary edge network, alongside an internal architectural cleanup.
+
+### ✨ What's New
+* **Vercel Edge Routing Migration:** `deploy-stack` now automatically parses `vercel.json` files. It natively translates Vercel edge redirects (301/302) and regex path matching directly into standard AWS Application Load Balancer Listener Rules.
+* **Vendor Lock-In Detection:** The CLI now proactively analyzes framework configuration files (`next.config.mjs`, `svelte.config.js`, `astro.config.mjs`) during the pre-flight checks. It warns users if they are locked into Vercel-specific adapters and provides exact instructions on how to switch to standard Node/Standalone outputs for AWS containerization.
+
+### 🛠️ Architecture & Telemetry
+* **Core Orchestrator Refactor:** Stripped over 250 lines of business logic and UI prompting out of `init.js`, establishing a clean, strictly isolated `src/utils/` toolbox pattern for future PaaS parsers.
+* **Wide Telemetry Payloads:** Upgraded the analytics engine to capture detailed execution context (CLI version, headless status, desired task counts, and specific migration vectors like Heroku/Vercel) to better map the user deployment funnel.
+
+### 🐛 Bug Fixes
+* **Next.js Standalone Enforcement:** Explicit warnings are now surfaced if a Next.js project is missing the critical `output: 'standalone'` directive before attempting to provision cloud resources.

package/src/commands/apply.js

@@ -5,6 +5,7 @@ import { intro, outro, spinner, log, cancel } from '@clack/prompts';
 import color from 'picocolors';
 import { renderDryRunPreview, parseTerraformConfig } from '../utils/visualizer.js';
 import { detectFramework } from '../utils/detector.js';
+import { trackEvent, flushTelemetry } from '../core/telemetry.js';
 
 // Helper to run a command while piping the latest stdout line into a @clack spinner
 function runTerraformCommand(args, cwd, spin, loadingPrefix) {
@@ -125,6 +126,14 @@ export async function applyStack(options = {}) {
 
         outro(`${finalMessage}\n\n  ${color.yellow('Push code to deploy your app and clear the 503 error:')}\n  ${color.cyan('git add . && git commit -m "ci: infra" && git push origin main')}`);
 
+        const actualProjectName = path.basename(process.cwd());
+        trackEvent('infrastructure_applied', {
+            projectName: actualProjectName,
+            framework: detectedConfig.framework,
+            success: true
+        });
+        await flushTelemetry();
+
         process.exit(0);
 
     } catch (error) {
@@ -146,6 +155,15 @@ export async function applyStack(options = {}) {
             log.message(`${color.bold('To debug manually, navigate to your terraform folder:')}`);
             log.message(color.cyan('cd terraform && terraform apply'));
         }
+
+        const actualProjectName = path.basename(process.cwd());
+        trackEvent('infrastructure_applied', {
+            projectName: actualProjectName,
+            success: false,
+            error_code: error.code || 'UNKNOWN'
+        });
+        await flushTelemetry();
+
         process.exit(1);
     }
 }

package/src/commands/destroy.js

@@ -87,6 +87,15 @@ export async function destroyStack() {
     } catch (error) {
         s.stop(color.red('❌ Terraform destroy failed.'));
         console.error(color.red(error.message));
+
+        const actualProjectName = path.basename(process.cwd());
+        trackEvent('infrastructure_destroyed', {
+            projectName: actualProjectName,
+            success: false,
+            error_code: error.code || 'UNKNOWN'
+        });
+        await flushTelemetry();
+
         process.exit(1);
     }
 
@@ -111,9 +120,11 @@ export async function destroyStack() {
         }
     }
 
-    trackEvent('project_destroyed', {
+    const actualProjectName = path.basename(process.cwd());
+    trackEvent('infrastructure_destroyed', {
+        projectName: actualProjectName,
         region,
-        bucket: bucketName,
+        retained_state_bucket: !(deleteS3Bucket && typeof deleteS3Bucket !== 'symbol'),
         success: true
     });
     await flushTelemetry();

package/src/commands/doctor.js

@@ -1,6 +1,7 @@
 import { intro, outro, spinner } from '@clack/prompts';
 import color from 'picocolors';
 import { checkDependency } from '../utils/system.js';
+import { trackEvent, flushTelemetry } from '../core/telemetry.js';
 
 export async function runDoctor() {
     intro(color.bgCyan(color.black(' deploy-stack ☁️  ')));
@@ -36,4 +37,9 @@ export async function runDoctor() {
     } else {
         outro(color.yellow('Please install the missing dependencies before running the provisioning tool.'));
     }
+
+    trackEvent('doctor_run', {
+        success: hasTerraform && hasAws && hasDocker && hasGit
+    });
+    await flushTelemetry();
 }

package/src/commands/eject.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { intro, outro, confirm, spinner, cancel } from '@clack/prompts';
 import color from 'picocolors';
+import { trackEvent, flushTelemetry } from '../core/telemetry.js';
 
 export async function ejectStack() {
     intro(color.bgRed(color.white(' deploy-stack eject ⏏️  ')));
@@ -68,6 +69,12 @@ export async function ejectStack() {
 
     s.stop('Ejection complete.');
 
+    const actualProjectName = path.basename(process.cwd());
+    trackEvent('project_ejected', {
+        projectName: actualProjectName
+    });
+    await flushTelemetry();
+
     outro(`
     ${color.green('✅ Successfully ejected from deploy-stack!')}
     

package/src/commands/init.js

@@ -1,23 +1,33 @@
 import fsSync from 'fs';
-import fs from 'fs/promises';
 import path from 'path';
-import { intro, outro, group, text, select, spinner, cancel, confirm, log } from '@clack/prompts';
+import { intro, outro, spinner, log } from '@clack/prompts';
 import color from 'picocolors';
-import { execSync } from 'child_process';
 
 import { checkDependency } from '../utils/system.js';
-import { detectFramework, parseProcfile } from '../utils/detector.js';
+import {
+    detectFramework,
+    parseProcfile,
+    parseVercelConfig,
+    analyzeNextConfig,
+    analyzeSvelteConfig,
+    analyzeAstroConfig
+} from '../utils/detector.js';
 import { trackEvent, flushTelemetry } from '../core/telemetry.js';
 import { getFrameworkWarning } from '../utils/warnings.js';
 import { provisionStateBucket } from '../utils/aws.js';
 import { generateTemplates } from '../utils/generator.js';
 import { handleExistingFiles } from '../utils/backup.js';
 import { estimateMonthlyCost } from '../utils/visualizer.js';
+import { getTargetDirectory, getProjectConfig } from '../utils/prompts.js';
+import { resolveDjangoWsgi, handleRailsCI } from '../utils/frameworks.js';
+
+const pkg = JSON.parse(fsSync.readFileSync(new URL('../../package.json', import.meta.url)));
+const CLI_VERSION = pkg.version;
 
 export async function mainStack({ isHeadless = false, headlessOptions = {} } = {}) {
     const startTime = Date.now();
 
-    // 0. Silent Pre-flight check
+    // 1. Silent Pre-flight check
     const hasTerraform = await checkDependency('terraform');
     if (!hasTerraform) {
         console.error(color.red('✖ Terraform is not installed.'));
@@ -25,285 +35,65 @@ export async function mainStack({ isHeadless = false, headlessOptions = {} } = {
         process.exit(1);
     }
 
-    const getFlag = (key, defaultValue) => headlessOptions[key] !== undefined ? headlessOptions[key] : defaultValue;
-
-    let projectName, actualProjectName, targetDir;
-    let finalFramework, detectedFramework;
-    let djangoWsgi = 'core.wsgi';
-    let setupType = 'quick';
-    let needsDatabase = false;
-    let disableDefaultCI = false;
-    let project = {};
-    let currentGitBranch = 'main';
-    let procfile = null;
-
-    if (isHeadless) {
-        // --- HEADLESS MODE ---
-        projectName = getFlag('dir', '.');
-        actualProjectName = projectName === '.' ? path.basename(process.cwd()) : projectName;
-        targetDir = projectName === '.' ? process.cwd() : path.join(process.cwd(), projectName);
-
-        detectedFramework = detectFramework(targetDir);
-        procfile = parseProcfile(targetDir);
-        finalFramework = getFlag('framework', detectedFramework ? detectedFramework.id : 'static');
-
-        project = {
-            region: getFlag('region', 'us-east-2'),
-            port: getFlag('port', finalFramework === 'static' ? '8080' : '3000'),
-            size: getFlag('size', 'micro'),
-            healthCheckPath: getFlag('healthCheckPath', '/'),
-            desiredCount: getFlag('desiredCount', '1'),
-            branch: getFlag('branch', 'main')
-        };
-
-        console.log(color.cyan(`🤖 Running deploy-stack in headless mode [${finalFramework} -> ${project.region}]`));
-    } else {
-        // --- INTERACTIVE MODE ---
-        // 1. Start the CLI
-        intro(color.bgCyan(color.black(' deploy-stack ☁️  ')));
+    if (!isHeadless) intro(color.bgCyan(color.black(' deploy-stack ☁️  ')));
 
-        // 2. Ask for the target directory FIRST
-        projectName = await text({
-            message: 'Where should we generate the infrastructure? (Type "." for current directory)',
-            placeholder: '.',
-            initialValue: '.',
-            validate: (value) => {
-                if (!value) return 'Please enter a name or directory.';
-                if (value !== '.' && value.includes(' ')) return 'Name cannot contain spaces.';
-            },
-        });
-
-        if (typeof projectName === 'symbol') {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-
-        actualProjectName = projectName === '.' ? path.basename(process.cwd()) : projectName;
-        targetDir = projectName === '.' ? process.cwd() : path.join(process.cwd(), projectName);
-
-        // 2.5 Run the scanner
-        const detectedFramework = detectFramework(targetDir);
-        if (detectedFramework) {
-            log.success(`Auto-detected framework: ${detectedFramework.name}`);
-        }
+    // 2. Resolve Target & Scan Codebase
+    const dirConfig = await getTargetDirectory(isHeadless, headlessOptions);
+    const detectedFramework = detectFramework(dirConfig.targetDir);
+    const procfile = parseProcfile(dirConfig.targetDir);
+    const vercelRules = parseVercelConfig(dirConfig.targetDir);
 
-        // 2.6 Run the Procfile Parser
-        procfile = parseProcfile(targetDir);
-        if (procfile && procfile.web) {
-            log.success(`Auto-detected Procfile (web command: ${procfile.web.join(' ')})`);
-        }
+    if (!isHeadless) {
+        if (detectedFramework) log.success(`Auto-detected framework: ${detectedFramework.name}`);
+        if (procfile && procfile.web) log.success(`Auto-detected Procfile (web command: ${procfile.web.join(' ')})`);
+        if (vercelRules) log.success(`Auto-detected vercel.json (Migrating edge network rules)`);
+    }
 
-        // 2.7 Resolve the framework
-        finalFramework = detectedFramework ? detectedFramework.id : null;
+    if (isHeadless) console.log(color.cyan(`🤖 Running deploy-stack in headless mode`));
 
-        if (!finalFramework) {
-            finalFramework = await select({
-                message: 'Which framework preset should we configure?',
-                options: [
-                    { value: 'node', label: 'Node.js / Express' },
-                    { value: 'nextjs', label: 'Next.js (Standalone)' },
-                    { value: 'nuxt', label: 'Nuxt 3 (SSR)' },
-                    { value: 'python', label: 'Python FastAPI' },
-                    { value: 'django', label: 'Django (Python)' },
-                    { value: 'rails', label: 'Ruby on Rails' },
-                    { value: 'go', label: 'Go (Golang)' },
-                    { value: 'static', label: 'Static Site (Gatsby, React, plain HTML via Nginx)' },
-                ],
-            });
+    // 3. Gather Configuration & Framework Quirks
+    const config = await getProjectConfig(isHeadless, headlessOptions, dirConfig.targetDir, detectedFramework);
+    const djangoWsgi = await resolveDjangoWsgi(dirConfig.targetDir, procfile, config.framework, isHeadless);
+    const disableDefaultCI = await handleRailsCI(dirConfig.targetDir, config.framework, isHeadless);
 
-            if (typeof finalFramework === 'symbol') {
-                cancel('Operation cancelled.');
-                process.exit(0);
+    // 4. Framework Migration Checks (Vercel Escape Hatch)
+    if (!isHeadless) {
+        if (config.framework === 'nextjs') {
+            const nextConfig = analyzeNextConfig(dirConfig.targetDir);
+            if (nextConfig.hasConfig && !nextConfig.isStandalone) {
+                log.warn(color.yellow('⚠️ Next.js config is missing "output: \'standalone\'". Your CI/CD Docker build will crash until you add it!'));
             }
-        }
-
-        // 2.8 Check if framework is Django and resolve wsgi.py path
-        djangoWsgi = 'core.wsgi';
-        if (finalFramework === 'django') {
-            let extractedWsgi = null;
-
-            // Check if Procfile already specifies the WSGI module
-            if (procfile && procfile.web) {
-                const webCommand = procfile.web.join(' ');
-                // Matches patterns like "gunicorn my_app.wsgi" or "my_app.wsgi:application"
-                const wsgiMatch = webCommand.match(/([a-zA-Z0-9_]+)\.wsgi/);
-                if (wsgiMatch) {
-                    extractedWsgi = `${wsgiMatch[1]}.wsgi`;
-                }
+        } else if (detectedFramework?.name === 'SvelteKit') {
+            const svelteConfig = analyzeSvelteConfig(dirConfig.targetDir);
+            if (svelteConfig.adapter === 'vercel' || svelteConfig.adapter === 'auto') {
+                log.warn(color.yellow('⚠️ SvelteKit is locked into the Vercel/Auto adapter. Switch to @sveltejs/adapter-node (for SSR) to deploy on AWS.'));
             }
-
-            if (extractedWsgi) {
-                djangoWsgi = extractedWsgi;
-                log.success(`Auto-detected Django WSGI from Procfile: ${color.cyan(djangoWsgi)}`);
-            } else {
-                djangoWsgi = await text({
-                    message: 'What is the Python module path to your Django wsgi.py?',
-                    placeholder: 'core.wsgi',
-                    initialValue: 'core.wsgi',
-                });
-                if (typeof djangoWsgi === 'symbol') process.exit(0);
+        } else if (detectedFramework?.name === 'Astro') {
+            const astroConfig = analyzeAstroConfig(dirConfig.targetDir);
+            if (astroConfig.adapter === 'vercel') {
+                log.warn(color.yellow('⚠️ Astro is locked into the Vercel adapter. Switch to @astrojs/node (for SSR) to deploy on AWS.'));
             }
         }
-
-        // 3. Prompt for Setup Mode
-        setupType = await select({
-            message: 'Choose your setup mode:',
-            options: [
-                { value: 'quick', label: '⚡ Quickstart (Recommended)', hint: 'Production defaults, minimal prompts' },
-                { value: 'advanced', label: '🛠️  Advanced Configuration', hint: 'Customize health checks, task count, branch, etc.' },
-            ],
-        });
-
-        if (typeof setupType === 'symbol') {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-
-        // 4. Set intelligent defaults & check current Git branch
-        let defaultPort = '3000';
-
-        if (finalFramework === 'static') defaultPort = '8080';
-        if (finalFramework === 'python' || finalFramework === 'django') defaultPort = '8000';
-        if (finalFramework === 'rails') defaultPort = '3000';
-        if (finalFramework === 'go') defaultPort = '8080';
-
-        currentGitBranch = 'main';
-        try {
-            currentGitBranch = execSync('git symbolic-ref --short HEAD', { cwd: targetDir, stdio: 'pipe' }).toString().trim();
-        } catch (e) {
-            // Not a git repo yet, fallback to 'main'
-        }
-
-        // 5. Ask for Managed Database (Only for Backend/Fullstack Frameworks)
-        needsDatabase = false;
-        const isBackendFramework = ['node', 'nextjs', 'nuxt', 'python', 'django', 'rails', 'go'].includes(finalFramework);
-
-        if (isBackendFramework) {
-            const dbChoice = await confirm({
-                message: 'Do you need a managed AWS RDS PostgreSQL database? (Adds ~$14/month or uses AWS Free Tier)',
-                initialValue: false,
-            });
-
-            if (typeof dbChoice === 'symbol') {
-                cancel('Provisioning cancelled.')
-                process.exit(0);
-            }
-            needsDatabase = dbChoice;
-        }
-
-        // 6. Prompt Configuration Group
-        project = await group(
-            {
-                region: () =>
-                    select({
-                        message: 'Which AWS region do you want to deploy to?',
-                        options: [
-                            { value: 'us-east-1', label: 'us-east-1 (N. Virginia)' },
-                            { value: 'us-east-2', label: 'us-east-2 (Ohio)' },
-                            { value: 'eu-west-1', label: 'eu-west-1 (Ireland)' },
-                            { value: 'eu-central-1', label: 'EU (Frankfurt)' },
-                            { value: 'ap-southeast-2', label: 'Asia Pacific (Sydney)' },
-                        ],
-                    }),
-                port: () =>
-                    text({
-                        message: 'What port does your container expose?',
-                        placeholder: defaultPort,
-                        defaultValue: defaultPort,
-                    }),
-                size: () =>
-                    select({
-                        message: 'Select your Fargate compute size:',
-                        options: [
-                            { value: 'micro', label: 'Micro (0.25 vCPU, 512MB RAM) - Best for POCs' },
-                            { value: 'small', label: 'Small (0.5 vCPU, 1GB RAM) - Best for small Projects' },
-                        ],
-                    }),
-                // --- Advanced-Only Prompts (Skipped if setupType === 'quick') ---
-                healthCheckPath: () => {
-                    if (setupType === 'quick') return undefined;
-                    return text({
-                        message: 'ALB Health Check Path:',
-                        placeholder: '/',
-                        defaultValue: '/',
-                    });
-                },
-                desiredCount: () => {
-                    if (setupType === 'quick') return undefined;
-                    return select({
-                        message: 'How many container replicas (tasks) should run?',
-                        options: [
-                            { value: '1', label: '1 Task (Single instance - lowest cost)' },
-                            { value: '2', label: '2 Tasks (High Availability across AZs)' },
-                        ],
-                        defaultValue: '1',
-                    });
-                },
-                branch: () => {
-                    if (setupType === 'quick') return undefined;
-                    return text({
-                        message: 'Primary Git deployment branch for CI/CD:',
-                        placeholder: currentGitBranch,
-                        defaultValue: currentGitBranch,
-                    });
-                },
-            },
-            {
-                onCancel: () => {
-                    cancel('Provisioning cancelled.');
-                    process.exit(0);
-                },
-            }
-        );
     }
 
-    // 7. Map the user's choices and update the variables
-    const cpu = project.size === 'small' ? '512' : '256';
-    const memory = project.size === 'small' ? '1024' : '512';
-    const computeTier = project.size === 'small' ? 'Small (0.5 vCPU, 1GB RAM)' : 'Micro (0.25 vCPU, 512MB RAM)';
+    // 5. Calculate Derived Values
+    const cpu = config.size === 'small' ? '512' : '256';
+    const memory = config.size === 'small' ? '1024' : '512';
+    const computeTier = config.size === 'small' ? 'Small (0.5 vCPU, 1GB RAM)' : 'Micro (0.25 vCPU, 512MB RAM)';
 
-    const costs = estimateMonthlyCost({ cpu: parseInt(cpu), memory: parseInt(memory), hasDb: needsDatabase });
-    const estimatedCost = `~$${costs.totalMonthly} / month${needsDatabase ? ' (Includes Fargate + RDS PostgreSQL)' : ''}`;
-
-    const healthCheckPath = project.healthCheckPath || '/';
-    const desiredCount = project.desiredCount || '1';
-    const deployBranch = project.branch || currentGitBranch;
+    const costs = estimateMonthlyCost({ cpu: parseInt(cpu), memory: parseInt(memory), hasDb: config.needsDatabase });
+    const estimatedCost = `~$${costs.totalMonthly} / month${config.needsDatabase ? ' (Includes Fargate + RDS PostgreSQL)' : ''}`;
     const buildDir = detectedFramework?.buildDir || 'dist';
 
-    // 7.1 Check for conflicting CI boilerplate (Rails)
-    if (finalFramework === 'rails') {
-        const ciPath = path.join(targetDir, '.github', 'workflows', 'ci.yml');
-        const dependabotPath = path.join(targetDir, '.github', 'dependabot.yml');
-
-        if (fsSync.existsSync(ciPath) || fsSync.existsSync(dependabotPath)) {
-            if (!isHeadless) {
-                console.log('');
-                const ciContent = await confirm({
-                    message: color.yellow('We detected default Rails GitHub Actions (ci.yml, dependabot.yml) that usually crash in isolated CI environments without a database. Would you like deploy-stack to safely disable them by renaming them to .bak?'),
-                    initialValue: true,
-                });
-                if (typeof ciContent === 'symbol') {
-                    cancel('Provisioning cancelled.');
-                    process.exit(0);
-                }
-                disableDefaultCI = ciContent;
-            } else {
-                // Headless: automatically disable conflicting CI
-                disableDefaultCI = true;
-            }
-        }
-    }
-
-    // 8. Safely handle existing files (Backup and auto-prune)
-    await handleExistingFiles(targetDir, isHeadless);
+    // 6. Handle Backups & Provision Remote State
+    await handleExistingFiles(dirConfig.targetDir, isHeadless);
 
     const s = spinner();
     s.start('Provisioning infrastructure...');
 
-    // 9. Provision S3 bucket for Terraform state & enable versioning
     let awsAccountId, stateBucketName;
     try {
-        const bucketData = await provisionStateBucket(project.region, actualProjectName);
+        const bucketData = await provisionStateBucket(config.region, dirConfig.actualProjectName);
         awsAccountId = bucketData.awsAccountId;
         stateBucketName = bucketData.stateBucketName;
     } catch (error) {
@@ -314,70 +104,75 @@ export async function mainStack({ isHeadless = false, headlessOptions = {} } = {
         process.exit(1);
     }
 
+    // 7. Synthesize Templates
     s.message('Synthesizing Terraform templates...');
-
-    // 10. Generate all templates and directories
-    await generateTemplates(targetDir, {
-        PROJECT_NAME: actualProjectName,
-        REGION: project.region,
-        PORT: project.port,
+    await generateTemplates(dirConfig.targetDir, {
+        PROJECT_NAME: dirConfig.actualProjectName,
+        REGION: config.region,
+        PORT: config.port,
         CPU: cpu,
         MEMORY: memory,
         COMPUTE_TIER: computeTier,
         ESTIMATED_COST: estimatedCost,
         STATE_BUCKET: stateBucketName,
         AWS_ACCOUNT_ID: awsAccountId,
-        HEALTH_CHECK_PATH: healthCheckPath,
-        DESIRED_COUNT: desiredCount,
-        DEPLOY_BRANCH: deployBranch,
+        HEALTH_CHECK_PATH: config.healthCheckPath,
+        DESIRED_COUNT: config.desiredCount,
+        DEPLOY_BRANCH: config.branch,
         BUILD_DIR: buildDir,
-        finalFramework: finalFramework,
-        NEEDS_DATABASE: needsDatabase,
+        finalFramework: config.framework,
+        NEEDS_DATABASE: config.needsDatabase,
         DJANGO_WSGI: djangoWsgi,
         DISABLE_DEFAULT_CI: disableDefaultCI,
-        PROCFILE: procfile
+        PROCFILE: procfile,
+        VERCEL_RULES: vercelRules
     });
 
-    // 11. Track the event in telemetry
+    // 8. Telemetry
     trackEvent('project_provisioned', {
-        projectName: actualProjectName,
-        framework: finalFramework,
-        specific_framework: detectedFramework?.name || finalFramework,
-        region: project.region,
-        size: project.size,
-        setup_mode: setupType,
-        desiredCount: desiredCount,
-        duration_ms: Date.now() - startTime
+        // 1. Core & Context
+        projectName: dirConfig.actualProjectName,
+        cli_version: CLI_VERSION,
+        is_headless: isHeadless,
+        setup_mode: config.setupType,
+        duration_ms: Date.now() - startTime,
+
+        // 2. Infrastructure Shape
+        framework: config.framework,
+        specific_framework: detectedFramework?.name || config.framework,
+        region: config.region,
+        size: config.size,
+        desired_count: parseInt(config.desiredCount),
+        has_database: config.needsDatabase,
+        has_custom_health_check: config.healthCheckPath !== '/',
+
+        // 3. Advanced Features & PaaS Context
+        has_worker: !!(procfile && procfile.worker),
+        is_heroku_migration: !!procfile,
+        is_vercel_migration: !!vercelRules,
     });
 
     s.stop('Infrastructure provisioned successfully!');
 
-    // 12. Provide the Outro, Framework Warnings and Next Steps
+    // 9. Output
     let frameworkWarnings = '';
-    if (!(finalFramework === 'static' && detectedFramework?.buildDir)) {
-        frameworkWarnings = getFrameworkWarning(finalFramework);
+    if (!(config.framework === 'static' && detectedFramework?.buildDir)) {
+        frameworkWarnings = getFrameworkWarning(config.framework);
     }
 
-    const isGitInitialized = fsSync.existsSync(path.join(targetDir, '.git'));
-
-    const needsCd = projectName && projectName !== '.';
-    const applyStep = needsCd
-        ? `cd ${projectName} && npx --yes deploy-stack apply`
-        : 'npx --yes deploy-stack apply';
-
+    const isGitInitialized = fsSync.existsSync(path.join(dirConfig.targetDir, '.git'));
+    const needsCd = dirConfig.projectName && dirConfig.projectName !== '.';
+    const applyStep = needsCd ? `cd ${dirConfig.projectName} && npx --yes deploy-stack apply` : 'npx --yes deploy-stack apply';
     const gitInstructions = isGitInitialized
         ? `git add . && git commit -m "chore: add AWS infrastructure and CI/CD" && git push`
-        : `git init && git add . && git commit -m "chore: add AWS infrastructure and CI/CD" && git branch -M ${deployBranch} && git remote add origin https://github.com/your-username/your-repo.git && git push -u origin ${deployBranch}`;
+        : `git init && git add . && git commit -m "chore: add AWS infrastructure and CI/CD" && git branch -M ${config.branch} && git remote add origin https://github.com/your-username/your-repo.git && git push -u origin ${config.branch}`;
 
-    const outroMessage = `${color.green('✅ Templates generated!')} ${color.blue('🛡️ DevSecOps scanning enabled.')}
+    outro(`${color.green('✅ Templates generated!')} ${color.blue('🛡️ DevSecOps scanning enabled.')}
     ${frameworkWarnings ? `\n  ${frameworkWarnings}` : ''}
     ${color.yellow('Next steps:')}
     1. ${color.cyan(applyStep)}
     2. ${color.cyan(gitInstructions)}
-    ${color.magenta('🚀 Need help?')} ${color.underline('https://calendly.com/anton-codes-iac/15min')}`;
-
-    outro(outroMessage);
+    ${color.magenta('🚀 Need help?')} ${color.underline('https://calendly.com/anton-codes-iac/15min')}`);
 
-    // 13.Ensure all analytics are sent before the CLI terminates
     await flushTelemetry();
 }

package/src/commands/secrets.js

@@ -4,6 +4,7 @@ import fs from 'fs/promises';
 import { spinner } from '@clack/prompts';
 import color from 'picocolors';
 import path from 'path';
+import { trackEvent, flushTelemetry } from '../core/telemetry.js';
 
 export async function pushSecrets(envFilePath, projectName) {
     const s = spinner();
@@ -42,7 +43,21 @@ export async function pushSecrets(envFilePath, projectName) {
         console.log(color.cyan(`\nUpdated ${keysFilePath}`));
         console.log(color.green('Commit this file and push to GitHub to trigger a deployment with your new variables.'));
 
+        trackEvent('secrets_pushed', {
+            projectName,
+            secret_count: Object.keys(parsedSecrets).length,
+            success: true
+        });
+        await flushTelemetry();
+
     } catch (error) {
         s.stop(`❌ Failed to push secrets: ${error.message}`);
+
+        trackEvent('secrets_pushed', {
+            projectName,
+            success: false,
+            error_code: error.name || 'UNKNOWN'
+        });
+        await flushTelemetry();
     }
 }

package/src/core/telemetry.js

@@ -26,6 +26,7 @@ export function trackEvent(eventName, properties) {
         properties: {
             os: process.platform,
             node_version: process.version,
+            is_ci: Boolean(process.env.CI || process.env.CONTINUOUS_INTEGRATION),
             ...properties
         }
     };

package/src/utils/detector.js

@@ -94,4 +94,99 @@ export function parseProcfile(targetDir) {
     }
 
     return Object.keys(processes).length > 0 ? processes : null;
+}
+
+// Parses a vercel.json file to extract routing and edge rules
+export function parseVercelConfig(targetDir) {
+    const vercelConfigPath = path.join(targetDir, 'vercel.json');
+    if (!fsSync.existsSync(vercelConfigPath)) return null;
+
+    try {
+        const content = fsSync.readFileSync(vercelConfigPath, 'utf-8');
+        const vercelJson = JSON.parse(content);
+
+        // We only care about network-level edge rules that AWS needs to handle
+        const rules = {
+            redirects: vercelJson.redirects || null,
+            headers: vercelJson.headers || null,
+            rewrites: vercelJson.rewrites || null
+        };
+
+        // If it's just an empty vercel.json, return null
+        if (!rules.redirects && !rules.headers && !rules.rewrites) {
+            return null;
+        }
+
+        return rules;
+    } catch (e) {
+        // Silently fail on malformed JSON
+        return null;
+    }
+}
+
+// Checks if Next.js is configured for 'standalone' output
+export function analyzeNextConfig(targetDir) {
+    const extensions = ['js', 'mjs', 'cjs', 'ts'];
+    let configPath = null;
+    let configContent = '';
+
+    for (const ext of extensions) {
+        const tempPath = path.join(targetDir, `next.config.${ext}`);
+        if (fsSync.existsSync(tempPath)) {
+            configPath = tempPath;
+            configContent = fsSync.readFileSync(tempPath, 'utf-8');
+            break;
+        }
+    }
+
+    if (!configPath) return { hasConfig: false, isStandalone: false };
+
+    // Regex looks for output: 'standalone' or output: "standalone" (handling spacing)
+    const isStandalone = /output\s*:\s*['"`]standalone['"`]/.test(configContent);
+
+    return {
+        hasConfig: true,
+        isStandalone: isStandalone,
+        configPath: configPath
+    };
+}
+
+// Checks if SvelteKit is locked into Vercel
+export function analyzeSvelteConfig(targetDir) {
+    const configPath = path.join(targetDir, 'svelte.config.js');
+    if (!fsSync.existsSync(configPath)) return { hasConfig: false, adapter: 'unknown' };
+
+    const content = fsSync.readFileSync(configPath, 'utf-8');
+
+    let adapter = 'unknown';
+    if (content.includes('@sveltejs/adapter-vercel')) adapter = 'vercel';
+    else if (content.includes('@sveltejs/adapter-node')) adapter = 'node';
+    else if (content.includes('@sveltejs/adapter-static')) adapter = 'static';
+    else if (content.includes('@sveltejs/adapter-auto')) adapter = 'auto'; // Vercel's default
+
+    return { hasConfig: true, adapter };
+}
+
+// Checks if Astro is locked into Vercel
+export function analyzeAstroConfig(targetDir) {
+    const extensions = ['mjs', 'js', 'ts', 'cjs'];
+    let configPath = null;
+    let content = '';
+
+    for (const ext of extensions) {
+        const tempPath = path.join(targetDir, `astro.config.${ext}`);
+        if (fsSync.existsSync(tempPath)) {
+            configPath = tempPath;
+            content = fsSync.readFileSync(tempPath, 'utf-8');
+            break;
+        }
+    }
+
+    if (!configPath) return { hasConfig: false, adapter: 'unknown' };
+
+    let adapter = 'unknown';
+    if (content.includes('@astrojs/vercel')) adapter = 'vercel';
+    else if (content.includes('@astrojs/node')) adapter = 'node';
+
+    return { hasConfig: true, adapter };
 }

package/src/utils/frameworks.js

@@ -0,0 +1,55 @@
+import fsSync from 'fs';
+import path from 'path';
+import { text, confirm, cancel, log } from '@clack/prompts';
+import color from 'picocolors';
+
+export async function resolveDjangoWsgi(targetDir, procfile, framework, isHeadless) {
+    if (framework !== 'django') return 'core.wsgi';
+
+    let extractedWsgi = null;
+    if (procfile && procfile.web) {
+        const webCommand = procfile.web.join(' ');
+        const wsgiMatch = webCommand.match(/([a-zA-Z0-9_]+)\.wsgi/);
+        if (wsgiMatch) extractedWsgi = `${wsgiMatch[1]}.wsgi`;
+    }
+
+    if (extractedWsgi) {
+        if (!isHeadless) log.success(`Auto-detected Django WSGI from Procfile: ${color.cyan(extractedWsgi)}`);
+        return extractedWsgi;
+    }
+
+    if (isHeadless) return 'core.wsgi';
+
+    const djangoWsgi = await text({
+        message: 'What is the Python module path to your Django wsgi.py?',
+        placeholder: 'core.wsgi',
+        initialValue: 'core.wsgi',
+    });
+
+    if (typeof djangoWsgi === 'symbol') process.exit(0);
+    return djangoWsgi;
+}
+
+export async function handleRailsCI(targetDir, framework, isHeadless) {
+    if (framework !== 'rails') return false;
+
+    const ciPath = path.join(targetDir, '.github', 'workflows', 'ci.yml');
+    const dependabotPath = path.join(targetDir, '.github', 'dependabot.yml');
+
+    if (fsSync.existsSync(ciPath) || fsSync.existsSync(dependabotPath)) {
+        if (isHeadless) return true;
+
+        console.log('');
+        const disable = await confirm({
+            message: color.yellow('We detected default Rails GitHub Actions (ci.yml, dependabot.yml) that usually crash in isolated CI environments without a database. Would you like deploy-stack to safely disable them by renaming them to .bak?'),
+            initialValue: true,
+        });
+
+        if (typeof disable === 'symbol') {
+            cancel('Provisioning cancelled.');
+            process.exit(0);
+        }
+        return disable;
+    }
+    return false;
+}

package/src/utils/generator.js

@@ -89,6 +89,46 @@ export async function generateTemplates(targetDir, config) {
         ? config.PROJECT_NAME.substring(0, 27).replace(/-$/, '') // Remove trailing hyphens
         : config.PROJECT_NAME;
 
+    // 4.5. Translate Vercel Rules to AWS ALB Listener Rules
+    let vercelTerraformRules = '';
+
+    if (config.VERCEL_RULES && config.VERCEL_RULES.redirects) {
+        config.VERCEL_RULES.redirects.forEach((rule, index) => {
+            // Vercel uses 'permanent: true' for 301, false for 302
+            const statusCode = rule.permanent === false ? "HTTP_302" : "HTTP_301";
+
+            // Map Vercel's source path to AWS ALB Path Pattern
+            let sourcePath = rule.source;
+            // Vercel sometimes uses regex syntax like '/blog/(.*)'. ALB uses '/blog/*'
+            sourcePath = sourcePath.replace(/\(\.\*\)/g, '*');
+
+            vercelTerraformRules += `
+# Auto-generated from vercel.json redirect
+resource "aws_lb_listener_rule" "vercel_redirect_${index}" {
+  listener_arn = aws_lb_listener.http.arn
+  priority     = ${100 + index} # Start at 100 to avoid conflicts
+
+  action {
+    type = "redirect"
+    redirect {
+      status_code = "${statusCode}"
+      path        = "${rule.destination}"
+    }
+  }
+
+  condition {
+    path_pattern {
+      values = ["${sourcePath}"]
+    }
+  }
+}
+`;
+        });
+    }
+
+    // Assign the compiled HCL to the config object so the template engine can inject it
+    config.VERCEL_EDGE_ROUTING = vercelTerraformRules;
+
     // 5. Process standard files
     for (const file of filesToProcess) {
         let content = await fs.readFile(path.join(templatesDir, file.src), 'utf-8');

package/src/utils/prompts.js

@@ -0,0 +1,156 @@
+import path from 'path';
+import { text, select, confirm, group, cancel, log } from '@clack/prompts';
+import color from 'picocolors';
+import { execSync } from 'child_process';
+
+export async function getTargetDirectory(isHeadless, headlessOptions) {
+    if (isHeadless) {
+        const projectName = headlessOptions.dir || '.';
+        return {
+            projectName,
+            actualProjectName: projectName === '.' ? path.basename(process.cwd()) : projectName,
+            targetDir: projectName === '.' ? process.cwd() : path.join(process.cwd(), projectName)
+        };
+    }
+
+    const projectName = await text({
+        message: 'Where should we generate the infrastructure? (Type "." for current directory)',
+        placeholder: '.',
+        initialValue: '.',
+        validate: (value) => {
+            if (!value) return 'Please enter a name or directory.';
+            if (value !== '.' && value.includes(' ')) return 'Name cannot contain spaces.';
+        },
+    });
+
+    if (typeof projectName === 'symbol') {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+
+    return {
+        projectName,
+        actualProjectName: projectName === '.' ? path.basename(process.cwd()) : projectName,
+        targetDir: projectName === '.' ? process.cwd() : path.join(process.cwd(), projectName)
+    };
+}
+
+export async function getProjectConfig(isHeadless, headlessOptions, targetDir, detectedFramework) {
+    if (isHeadless) {
+        return {
+            framework: headlessOptions.framework || (detectedFramework ? detectedFramework.id : 'static'),
+            region: headlessOptions.region || 'us-east-2',
+            port: headlessOptions.port || (headlessOptions.framework === 'static' ? '8080' : '3000'),
+            size: headlessOptions.size || 'micro',
+            healthCheckPath: headlessOptions.healthCheckPath || '/',
+            desiredCount: headlessOptions.desiredCount || '1',
+            branch: headlessOptions.branch || 'main',
+            needsDatabase: false,
+            setupType: 'headless'
+        };
+    }
+
+    let finalFramework = detectedFramework ? detectedFramework.id : null;
+
+    if (!finalFramework) {
+        finalFramework = await select({
+            message: 'Which framework preset should we configure?',
+            options: [
+                { value: 'node', label: 'Node.js / Express' },
+                { value: 'nextjs', label: 'Next.js (Standalone)' },
+                { value: 'nuxt', label: 'Nuxt 3 (SSR)' },
+                { value: 'python', label: 'Python FastAPI' },
+                { value: 'django', label: 'Django (Python)' },
+                { value: 'rails', label: 'Ruby on Rails' },
+                { value: 'go', label: 'Go (Golang)' },
+                { value: 'static', label: 'Static Site (Gatsby, React, plain HTML via Nginx)' },
+            ],
+        });
+        if (typeof finalFramework === 'symbol') process.exit(0);
+    }
+
+    const setupType = await select({
+        message: 'Choose your setup mode:',
+        options: [
+            { value: 'quick', label: '⚡ Quickstart (Recommended)', hint: 'Production defaults, minimal prompts' },
+            { value: 'advanced', label: '🛠️  Advanced Configuration', hint: 'Customize health checks, task count, branch, etc.' },
+        ],
+    });
+    if (typeof setupType === 'symbol') process.exit(0);
+
+    let defaultPort = '3000';
+    if (finalFramework === 'static' || finalFramework === 'go') defaultPort = '8080';
+    if (finalFramework === 'python' || finalFramework === 'django') defaultPort = '8000';
+
+    let currentGitBranch = 'main';
+    try {
+        currentGitBranch = execSync('git symbolic-ref --short HEAD', { cwd: targetDir, stdio: 'pipe' }).toString().trim();
+    } catch (e) { }
+
+    let needsDatabase = false;
+    const isBackendFramework = ['node', 'nextjs', 'nuxt', 'python', 'django', 'rails', 'go'].includes(finalFramework);
+
+    if (isBackendFramework) {
+        const dbChoice = await confirm({
+            message: 'Do you need a managed AWS RDS PostgreSQL database? (Adds ~$14/month or uses AWS Free Tier)',
+            initialValue: false,
+        });
+        if (typeof dbChoice === 'symbol') process.exit(0);
+        needsDatabase = dbChoice;
+    }
+
+    const project = await group({
+        region: () => select({
+            message: 'Which AWS region do you want to deploy to?',
+            options: [
+                { value: 'us-east-1', label: 'us-east-1 (N. Virginia)' },
+                { value: 'us-east-2', label: 'us-east-2 (Ohio)' },
+                { value: 'eu-west-1', label: 'eu-west-1 (Ireland)' },
+                { value: 'eu-central-1', label: 'EU (Frankfurt)' },
+                { value: 'ap-southeast-2', label: 'Asia Pacific (Sydney)' },
+            ],
+        }),
+        port: () => text({
+            message: 'What port does your container expose?',
+            placeholder: defaultPort,
+            defaultValue: defaultPort,
+        }),
+        size: () => select({
+            message: 'Select your Fargate compute size:',
+            options: [
+                { value: 'micro', label: 'Micro (0.25 vCPU, 512MB RAM) - Best for POCs' },
+                { value: 'small', label: 'Small (0.5 vCPU, 1GB RAM) - Best for small Projects' },
+            ],
+        }),
+        healthCheckPath: () => setupType === 'quick' ? undefined : text({
+            message: 'ALB Health Check Path:',
+            placeholder: '/',
+            defaultValue: '/',
+        }),
+        desiredCount: () => setupType === 'quick' ? undefined : select({
+            message: 'How many container replicas (tasks) should run?',
+            options: [
+                { value: '1', label: '1 Task (Single instance - lowest cost)' },
+                { value: '2', label: '2 Tasks (High Availability across AZs)' },
+            ],
+            defaultValue: '1',
+        }),
+        branch: () => setupType === 'quick' ? undefined : text({
+            message: 'Primary Git deployment branch for CI/CD:',
+            placeholder: currentGitBranch,
+            defaultValue: currentGitBranch,
+        }),
+    }, { onCancel: () => process.exit(0) });
+
+    return {
+        framework: finalFramework,
+        region: project.region,
+        port: project.port,
+        size: project.size,
+        healthCheckPath: project.healthCheckPath || '/',
+        desiredCount: project.desiredCount || '1',
+        branch: project.branch || currentGitBranch,
+        needsDatabase,
+        setupType
+    };
+}

package/templates/terraform/network.tf

@@ -90,4 +90,6 @@ resource "aws_security_group" "ecs_tasks" {
     # trivy:ignore:AVD-AWS-0104 - Allow containers to pull images and hit external APIs
     cidr_blocks = ["0.0.0.0/0"]
   }
-}
+}
+
+{{VERCEL_EDGE_ROUTING}}