@friggframework/devtools 2.0.0--canary.546.74db90f.0 → 2.0.0--canary.545.e7becd9.0

package/frigg-cli/start-command/infrastructure/DockerAdapter.js

@@ -0,0 +1,306 @@
+/**
+ * DockerAdapter - Infrastructure adapter for Docker operations
+ *
+ * Provides methods to interact with Docker and Docker Compose
+ * Used by pre-flight checks to verify database infrastructure is ready
+ */
+
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class DockerAdapter {
+    /**
+     * Check if Docker CLI is installed
+     * @returns {Promise<boolean>} True if docker command is available
+     */
+    async isDockerInstalled() {
+        return new Promise((resolve) => {
+            exec('docker --version', (error) => {
+                resolve(!error);
+            });
+        });
+    }
+
+    /**
+     * Check if Docker daemon is running
+     * @returns {Promise<boolean>} True if docker daemon is responsive
+     */
+    async isDockerRunning() {
+        return new Promise((resolve) => {
+            exec('docker info', (error) => {
+                resolve(!error);
+            });
+        });
+    }
+
+    /**
+     * Find docker-compose file in project directory or parent
+     * @param {string} projectPath - Path to search in
+     * @returns {Promise<string|null>} Path to compose file or null if not found
+     */
+    async findDockerComposeFile(projectPath) {
+        const composeFileNames = [
+            'docker-compose.yml',
+            'docker-compose.yaml',
+            'compose.yml',
+            'compose.yaml'
+        ];
+
+        // Search in project path first
+        for (const fileName of composeFileNames) {
+            const filePath = path.join(projectPath, fileName);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        }
+
+        // Search in parent directory (for backend paths)
+        const parentPath = path.dirname(projectPath);
+        if (parentPath !== projectPath) {
+            for (const fileName of composeFileNames) {
+                const filePath = path.join(parentPath, fileName);
+                if (fs.existsSync(filePath)) {
+                    return filePath;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Start Docker Compose services
+     * @param {string} composePath - Path to docker-compose file
+     * @returns {Promise<{success: boolean, error?: string, output?: string}>}
+     */
+    async startDockerCompose(composePath) {
+        return new Promise((resolve) => {
+            const cmd = `docker compose -f ${composePath} up -d`;
+            const options = { cwd: path.dirname(composePath) };
+
+            exec(cmd, options, (error, stdout, stderr) => {
+                if (error) {
+                    resolve({
+                        success: false,
+                        error: stderr || error.message
+                    });
+                } else {
+                    resolve({
+                        success: true,
+                        output: stdout
+                    });
+                }
+            });
+        });
+    }
+
+    /**
+     * Stop Docker Compose services
+     * @param {string} composePath - Path to docker-compose file
+     * @returns {Promise<{success: boolean, error?: string, output?: string}>}
+     */
+    async stopDockerCompose(composePath) {
+        return new Promise((resolve) => {
+            const cmd = `docker compose -f ${composePath} down`;
+            const options = { cwd: path.dirname(composePath) };
+
+            exec(cmd, options, (error, stdout, stderr) => {
+                if (error) {
+                    resolve({
+                        success: false,
+                        error: stderr || error.message
+                    });
+                } else {
+                    resolve({
+                        success: true,
+                        output: stdout
+                    });
+                }
+            });
+        });
+    }
+
+    /**
+     * Start Docker Desktop application
+     * @returns {Promise<{success: boolean, error?: string}>}
+     */
+    async startDockerDesktop() {
+        return new Promise((resolve) => {
+            let cmd;
+            const platform = process.platform;
+
+            if (platform === 'darwin') {
+                cmd = 'open -a "Docker Desktop"';
+            } else if (platform === 'win32') {
+                cmd = 'start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"';
+            } else {
+                // Linux - try systemctl first, fall back to service
+                cmd = 'systemctl start docker || service docker start';
+            }
+
+            exec(cmd, (error) => {
+                if (error) {
+                    resolve({
+                        success: false,
+                        error: error.message
+                    });
+                } else {
+                    resolve({ success: true });
+                }
+            });
+        });
+    }
+
+    /**
+     * Get list of running Docker Compose services
+     * @param {string} composePath - Path to docker-compose file
+     * @returns {Promise<string[]>} List of running service names
+     */
+    async getDockerComposeServices(composePath) {
+        return new Promise((resolve) => {
+            const cmd = `docker compose -f ${composePath} ps --services --filter "status=running"`;
+            const options = { cwd: path.dirname(composePath) };
+
+            exec(cmd, options, (error, stdout) => {
+                if (error) {
+                    resolve([]);
+                } else {
+                    const services = stdout
+                        .split('\n')
+                        .map(s => s.trim())
+                        .filter(s => s.length > 0);
+                    resolve(services);
+                }
+            });
+        });
+    }
+
+    /**
+     * Check if a specific service is running
+     * @param {string} composePath - Path to docker-compose file
+     * @param {string} serviceName - Name of the service to check
+     * @returns {Promise<boolean>} True if service is running
+     */
+    async isServiceRunning(composePath, serviceName) {
+        const services = await this.getDockerComposeServices(composePath);
+        return services.includes(serviceName);
+    }
+
+    /**
+     * Wait for Docker to become ready after starting
+     * @param {object} options - Wait options
+     * @param {number} options.maxAttempts - Maximum number of attempts (default: 30)
+     * @param {number} options.intervalMs - Interval between attempts in ms (default: 1000)
+     * @returns {Promise<boolean>} True if Docker became ready, false if timed out
+     */
+    async waitForDockerReady(options = {}) {
+        const { maxAttempts = 30, intervalMs = 1000 } = options;
+
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const isRunning = await this.isDockerRunning();
+            if (isRunning) {
+                return true;
+            }
+            await this._sleep(intervalMs);
+        }
+
+        return false;
+    }
+
+    /**
+     * Wait for LocalStack to be ready by polling health endpoint
+     * @param {object} options - Wait options
+     * @param {number} options.maxAttempts - Maximum number of attempts (default: 30)
+     * @param {number} options.intervalMs - Interval between attempts in ms (default: 2000)
+     * @param {string} options.endpoint - LocalStack endpoint (default: http://localhost:4566)
+     * @returns {Promise<{ready: boolean, services?: object, error?: string}>}
+     */
+    async waitForLocalStack(options = {}) {
+        const {
+            maxAttempts = 30,
+            intervalMs = 2000,
+            endpoint = process.env.AWS_ENDPOINT || 'http://localhost:4566'
+        } = options;
+
+        const healthUrl = `${endpoint}/_localstack/health`;
+
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const result = await this._checkLocalStackHealth(healthUrl);
+                if (result.ready) {
+                    return result;
+                }
+                // Not ready yet, wait and retry
+                if (attempt < maxAttempts) {
+                    await this._sleep(intervalMs);
+                }
+            } catch (error) {
+                // Connection failed, wait and retry
+                if (attempt < maxAttempts) {
+                    await this._sleep(intervalMs);
+                }
+            }
+        }
+
+        return {
+            ready: false,
+            error: `LocalStack not ready after ${maxAttempts} attempts`
+        };
+    }
+
+    /**
+     * Check LocalStack health endpoint
+     * @param {string} healthUrl - URL to health endpoint
+     * @returns {Promise<{ready: boolean, services?: object}>}
+     */
+    async _checkLocalStackHealth(healthUrl) {
+        return new Promise((resolve, reject) => {
+            const http = require('http');
+            const url = new URL(healthUrl);
+
+            const req = http.get({
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                timeout: 5000
+            }, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        const health = JSON.parse(data);
+                        // Check if services are running
+                        // LocalStack returns: { "services": { "sqs": "running", ... } }
+                        const services = health.services || {};
+                        const sqsReady = services.sqs === 'running' || services.sqs === 'available';
+
+                        resolve({
+                            ready: sqsReady,
+                            services: services
+                        });
+                    } catch (e) {
+                        resolve({ ready: false });
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Timeout'));
+            });
+        });
+    }
+
+    /**
+     * Helper to sleep for specified milliseconds
+     * @param {number} ms - Milliseconds to sleep
+     * @returns {Promise<void>}
+     */
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = { DockerAdapter };

package/frigg-cli/start-command/presentation/InteractivePromptAdapter.js

@@ -0,0 +1,329 @@
+/**
+ * InteractivePromptAdapter - Handles prompts in terminal mode or IPC mode
+ *
+ * Presentation Layer - Adapts prompt interfaces for different contexts:
+ * - Terminal mode: Uses @inquirer/prompts for direct CLI interaction
+ * - IPC mode: Outputs JSON to stdout and reads responses from stdin
+ *   (used when Management UI spawns the CLI process)
+ */
+
+const { confirm, select, input } = require('@inquirer/prompts');
+const { randomUUID } = require('crypto');
+
+/**
+ * Factory for creating the appropriate prompt adapter
+ */
+class InteractivePromptAdapter {
+    /**
+     * Create a prompt adapter based on mode
+     * @param {object} options - Options
+     * @param {string} options.mode - 'terminal' or 'ipc'
+     * @returns {TerminalPromptAdapter|IpcPromptAdapter}
+     */
+    static create(options = {}) {
+        // Check for IPC mode via environment variable or explicit option
+        const isIpcMode = options.mode === 'ipc' || process.env.FRIGG_IPC === 'true';
+
+        if (isIpcMode) {
+            return new IpcPromptAdapter();
+        }
+
+        return new TerminalPromptAdapter();
+    }
+}
+
+/**
+ * Terminal-based prompt adapter using @inquirer/prompts
+ */
+class TerminalPromptAdapter {
+    /**
+     * Show a confirmation prompt
+     * @param {object} options - Prompt options
+     * @param {string} options.message - Prompt message
+     * @param {boolean} options.default - Default value
+     * @returns {Promise<boolean>}
+     */
+    async confirm(options) {
+        return confirm({
+            message: options.message,
+            default: options.default
+        });
+    }
+
+    /**
+     * Show a selection prompt
+     * @param {object} options - Prompt options
+     * @param {string} options.message - Prompt message
+     * @param {Array} options.choices - Array of {value, name} choices
+     * @returns {Promise<string>}
+     */
+    async select(options) {
+        return select({
+            message: options.message,
+            choices: options.choices
+        });
+    }
+
+    /**
+     * Show a text input prompt
+     * @param {object} options - Prompt options
+     * @param {string} options.message - Prompt message
+     * @param {string} options.default - Default value
+     * @returns {Promise<string>}
+     */
+    async input(options) {
+        return input({
+            message: options.message,
+            default: options.default
+        });
+    }
+
+    /**
+     * Prompt user to resolve a failed pre-flight check
+     * @param {object} check - Pre-flight check result
+     * @returns {Promise<{shouldResolve: boolean, composePath?: string}>}
+     */
+    async promptForResolution(check) {
+        if (!check.canResolve) {
+            return { shouldResolve: false };
+        }
+
+        const shouldResolve = await this.confirm({
+            message: check.resolution.prompt,
+            default: true
+        });
+
+        const result = { shouldResolve };
+
+        if (check.resolution.composePath) {
+            result.composePath = check.resolution.composePath;
+        }
+
+        return result;
+    }
+}
+
+/**
+ * IPC-based prompt adapter for Management UI integration
+ * Outputs JSON prompts to stdout, reads responses from stdin
+ */
+class IpcPromptAdapter {
+    constructor() {
+        this._pendingPrompts = new Map();
+        this._stdinBuffer = '';
+        this._stdinListenerSetup = false;
+    }
+
+    /**
+     * Setup stdin listener for IPC responses (lazy initialization)
+     */
+    _setupStdinListener() {
+        if (this._stdinListenerSetup) return;
+        this._stdinListenerSetup = true;
+
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            this._stdinBuffer += chunk;
+
+            // Process complete lines
+            const lines = this._stdinBuffer.split('\n');
+            this._stdinBuffer = lines.pop(); // Keep incomplete line in buffer
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+
+                const ipcMessage = this._parseIpcMessage(line);
+                if (ipcMessage && ipcMessage.type === 'prompt_response') {
+                    this._resolvePrompt(ipcMessage.requestId, ipcMessage.response);
+                }
+            }
+        });
+
+        process.stdin.on('end', () => {
+            // stdin closed - resolve any pending prompts with default/false
+            for (const [requestId, resolver] of this._pendingPrompts) {
+                resolver(false);
+            }
+            this._pendingPrompts.clear();
+        });
+
+        // Resume stdin to start receiving data
+        process.stdin.resume();
+    }
+
+    /**
+     * Generate a unique request ID
+     * @returns {string}
+     */
+    _generateRequestId() {
+        return `prompt-${randomUUID().split('-')[0]}`;
+    }
+
+    /**
+     * Format IPC output message
+     * @param {string} type - Message type
+     * @param {object} data - Message data
+     * @returns {string} JSON string with newline
+     */
+    _formatIpcOutput(type, data) {
+        const message = {
+            frigg_ipc: type,
+            ...data
+        };
+        return JSON.stringify(message) + '\n';
+    }
+
+    /**
+     * Parse an IPC message from stdin
+     * @param {string} message - Raw message string
+     * @returns {object|null} Parsed message or null if not IPC
+     */
+    _parseIpcMessage(message) {
+        try {
+            const parsed = JSON.parse(message);
+            if (!parsed.frigg_ipc) {
+                return null;
+            }
+            return {
+                type: parsed.frigg_ipc,
+                requestId: parsed.requestId,
+                response: parsed.response
+            };
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Resolve a pending prompt with a response
+     * @param {string} requestId - Request ID
+     * @param {any} response - Response value
+     */
+    _resolvePrompt(requestId, response) {
+        const resolver = this._pendingPrompts.get(requestId);
+        if (resolver) {
+            resolver(response);
+            this._pendingPrompts.delete(requestId);
+        }
+    }
+
+    /**
+     * Handle a response from the Management UI
+     * @param {string} requestId - Request ID
+     * @param {any} response - Response value
+     */
+    handleResponse(requestId, response) {
+        this._resolvePrompt(requestId, response);
+    }
+
+    /**
+     * Show a confirmation prompt via IPC
+     * @param {object} options - Prompt options
+     * @returns {Promise<boolean>}
+     */
+    async confirm(options) {
+        // Setup stdin listener before sending prompt
+        this._setupStdinListener();
+
+        const requestId = this._generateRequestId();
+
+        const output = this._formatIpcOutput('prompt_request', {
+            requestId,
+            prompt: {
+                type: 'confirm',
+                message: options.message,
+                default: options.default
+            }
+        });
+
+        process.stdout.write(output);
+
+        return new Promise((resolve) => {
+            this._pendingPrompts.set(requestId, resolve);
+        });
+    }
+
+    /**
+     * Show a selection prompt via IPC
+     * @param {object} options - Prompt options
+     * @returns {Promise<string>}
+     */
+    async select(options) {
+        // Setup stdin listener before sending prompt
+        this._setupStdinListener();
+
+        const requestId = this._generateRequestId();
+
+        const output = this._formatIpcOutput('prompt_request', {
+            requestId,
+            prompt: {
+                type: 'select',
+                message: options.message,
+                choices: options.choices
+            }
+        });
+
+        process.stdout.write(output);
+
+        return new Promise((resolve) => {
+            this._pendingPrompts.set(requestId, resolve);
+        });
+    }
+
+    /**
+     * Show a text input prompt via IPC
+     * @param {object} options - Prompt options
+     * @returns {Promise<string>}
+     */
+    async input(options) {
+        // Setup stdin listener before sending prompt
+        this._setupStdinListener();
+
+        const requestId = this._generateRequestId();
+
+        const output = this._formatIpcOutput('prompt_request', {
+            requestId,
+            prompt: {
+                type: 'input',
+                message: options.message,
+                default: options.default
+            }
+        });
+
+        process.stdout.write(output);
+
+        return new Promise((resolve) => {
+            this._pendingPrompts.set(requestId, resolve);
+        });
+    }
+
+    /**
+     * Prompt user to resolve a failed pre-flight check via IPC
+     * @param {object} check - Pre-flight check result
+     * @returns {Promise<{shouldResolve: boolean, composePath?: string}>}
+     */
+    async promptForResolution(check) {
+        if (!check.canResolve) {
+            return { shouldResolve: false };
+        }
+
+        const shouldResolve = await this.confirm({
+            message: check.resolution.prompt,
+            default: true
+        });
+
+        const result = { shouldResolve };
+
+        if (check.resolution.composePath) {
+            result.composePath = check.resolution.composePath;
+        }
+
+        return result;
+    }
+}
+
+module.exports = {
+    InteractivePromptAdapter,
+    TerminalPromptAdapter,
+    IpcPromptAdapter
+};

package/frigg-cli/templates/backend/.env.example

@@ -0,0 +1,62 @@
+# Frigg Backend Environment Variables
+# Copy this file to .env and fill in your values
+# Or use the default .env file included with the project
+
+# ============================================================================
+# Core Configuration
+# ============================================================================
+FRIGG_BASE_URL=http://localhost:3001
+REDIRECT_URI=http://localhost:3000/redirect
+
+# Stage (local, dev, test, staging, production)
+STAGE=local
+
+# ============================================================================
+# Database Configuration
+# ============================================================================
+# PostgreSQL (default for new projects - used with Docker)
+DATABASE_URL=postgresql://frigg:frigg@localhost:5432/frigg
+DATABASE_USER=frigg
+DATABASE_PASSWORD=frigg
+
+# MongoDB (alternative - uncomment if using MongoDB)
+# MONGO_URI=mongodb://127.0.0.1:27017/frigg
+
+# ============================================================================
+# Security Keys
+# ============================================================================
+# Admin API key for management UI auto-connect (REQUIRED for admin features)
+# Generate a secure random string for production
+FRIGG_ADMIN_API_KEY=dev-admin-key-change-in-production
+
+# Shared secret API key for header-based authentication (optional)
+# Used when userManagementMode.sharedSecretEnabled is true
+FRIGG_API_KEY=dev-shared-secret-change-in-production
+
+# Health check API key (optional - for protected health endpoints)
+HEALTH_API_KEY=dev-health-key
+
+# ============================================================================
+# Encryption Configuration
+# ============================================================================
+# AES encryption (for local development - simpler setup)
+AES_KEY_ID=local-dev-key
+AES_KEY=32-character-secret-key-here-!!
+
+# AWS KMS encryption (for production - comment out AES and use these)
+# KMS_KEY_ARN=arn:aws:kms:us-east-1:123456789012:key/your-key-id
+
+# ============================================================================
+# AWS Configuration (for deployment)
+# ============================================================================
+AWS_REGION=us-east-1
+# S3_BUCKET_NAME=your-s3-bucket
+
+# ============================================================================
+# Integration Credentials
+# ============================================================================
+# Add your integration-specific credentials below
+# HUBSPOT_CLIENT_ID=
+# HUBSPOT_CLIENT_SECRET=
+# SALESFORCE_CLIENT_ID=
+# SALESFORCE_CLIENT_SECRET=

package/frigg-cli/templates/backend/.eslintrc.json

@@ -0,0 +1,12 @@
+{
+    "extends": ["@friggframework/eslint-config"],
+    "env": {
+        "node": true,
+        "jest": true,
+        "es2021": true
+    },
+    "parserOptions": {
+        "ecmaVersion": 2021
+    },
+    "rules": {}
+}