@friggframework/devtools 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.21b69ac.0

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

@@ -1,306 +0,0 @@
-/**
- * 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

@@ -1,329 +0,0 @@
-/**
- * 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

@@ -1,62 +0,0 @@
-# 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

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