@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.61

package/frigg-cli/utils/error-messages.js

@@ -0,0 +1,329 @@
+const chalk = require('chalk');
+
+/**
+ * Error Messages Module
+ * Provides helpful, context-aware error messages for database setup issues
+ */
+
+/**
+ * Normalizes MongoDB-compatible database types to 'mongodb'
+ * DocumentDB uses the same Prisma client as MongoDB
+ * @param {'mongodb'|'postgresql'|'documentdb'} dbType - Database type
+ * @returns {'mongodb'|'postgresql'} Normalized database type
+ */
+function normalizeMongoCompatible(dbType) {
+    return dbType === 'documentdb' ? 'mongodb' : dbType;
+}
+
+/**
+ * Database URL examples for supported database types
+ */
+const DATABASE_URL_EXAMPLES = {
+  mongodb: 'mongodb://localhost:27017/frigg?replicaSet=rs0',
+  documentdb: 'mongodb://frigg-user:yourPassword@docdb-cluster.cluster-xyz123.us-east-1.docdb.amazonaws.com:27017/frigg?tls=true&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false',
+  postgresql: 'postgresql://postgres:postgres@localhost:5432/frigg?schema=public'
+};
+
+function getDatabaseDisplayName(dbType) {
+  switch (dbType) {
+    case 'mongodb':
+      return 'MongoDB';
+    case 'documentdb':
+      return 'AWS DocumentDB (MongoDB-compatible)';
+    case 'postgresql':
+      return 'PostgreSQL';
+    default:
+      return dbType;
+  }
+}
+
+/**
+ * Gets helpful error message for missing DATABASE_URL
+ * @returns {string} Formatted error message
+ */
+function getDatabaseUrlMissingError() {
+    return `
+${chalk.red('❌ DATABASE_URL environment variable not found')}
+
+${chalk.bold('Add DATABASE_URL to your .env file:')}
+
+${chalk.cyan('For MongoDB:')}
+  ${chalk.gray('DATABASE_URL')}=${chalk.green(`"${DATABASE_URL_EXAMPLES.mongodb}"`)}
+
+${chalk.cyan('For AWS DocumentDB (MongoDB-compatible):')}
+  ${chalk.gray('DATABASE_URL')}=${chalk.green(`"${DATABASE_URL_EXAMPLES.documentdb}"`)}
+
+${chalk.cyan('For PostgreSQL:')}
+  ${chalk.gray('DATABASE_URL')}=${chalk.green(`"${DATABASE_URL_EXAMPLES.postgresql}"`)}
+
+${chalk.yellow('Then run:')} ${chalk.cyan('frigg db:setup')}
+`;
+}
+
+/**
+ * Gets helpful error message for missing database type configuration
+ * @returns {string} Formatted error message
+ */
+function getDatabaseTypeNotConfiguredError() {
+    return `
+${chalk.red('❌ Database type not configured in app definition')}
+
+${chalk.bold('Add database configuration to your app definition file:')}
+${chalk.gray('(backend/index.js or index.js)')}
+
+${chalk.cyan('For PostgreSQL:')}
+${chalk.gray(`
+const appDefinition = {
+  // ... other configuration
+  database: {
+    postgres: { enable: true }
+  }
+};
+`)}
+
+${chalk.cyan('For MongoDB:')}
+${chalk.gray(`
+const appDefinition = {
+  // ... other configuration
+  database: {
+    mongoDB: { enable: true }
+  }
+};
+`)}
+
+${chalk.cyan('For AWS DocumentDB (MongoDB-compatible):')}
+${chalk.gray(`
+const appDefinition = {
+  // ... other configuration
+  database: {
+    documentDB: { enable: true }
+  }
+};
+`)}
+
+${chalk.gray('DocumentDB uses the MongoDB Prisma client. Make sure TLS is enabled and replica set compatibility is configured on your cluster.')}
+`;
+}
+
+/**
+ * Gets helpful error message for database connection failure
+ * @param {string} error - Connection error message
+ * @param {'mongodb'|'postgresql'|'documentdb'} dbType - Database type
+ * @returns {string} Formatted error message
+ */
+function getDatabaseConnectionError(error, dbType) {
+    let troubleshootingSteps;
+    if (dbType === 'documentdb') {
+        troubleshootingSteps = getDocumentDbTroubleshooting();
+    } else if (dbType === 'mongodb') {
+        troubleshootingSteps = getMongoDatabaseTroubleshooting();
+    } else {
+        troubleshootingSteps = getPostgresTroubleshooting();
+    }
+
+    return `
+${chalk.red('❌ Failed to connect to database')}
+
+${chalk.bold('Connection error:')}
+${chalk.gray(error)}
+
+${chalk.bold('Database:')} ${chalk.cyan(getDatabaseDisplayName(dbType))}
+
+${chalk.bold('Troubleshooting steps:')}
+${troubleshootingSteps}
+
+${chalk.yellow('Verify your DATABASE_URL:')} ${chalk.cyan(process.env.DATABASE_URL || 'not set')}
+`;
+}
+
+/**
+ * Gets MongoDB-specific troubleshooting steps
+ * @returns {string} Formatted troubleshooting steps
+ */
+function getMongoDatabaseTroubleshooting() {
+    return `
+${chalk.gray('1.')} Verify MongoDB is running
+   ${chalk.cyan('docker ps')} ${chalk.gray('(if using Docker)')}
+   ${chalk.cyan('mongosh --eval "db.version()"')} ${chalk.gray('(test connection)')}
+
+${chalk.gray('2.')} Check if replica set is initialized
+   ${chalk.gray('MongoDB requires a replica set for Prisma')}
+   ${chalk.cyan('mongosh')}
+   ${chalk.cyan('rs.status()')} ${chalk.gray('(should show replica set info)')}
+
+${chalk.gray('3.')} Initialize replica set if needed
+   ${chalk.cyan('docker exec -it <mongodb-container> mongosh')}
+   ${chalk.cyan('rs.initiate()')}
+
+${chalk.gray('4.')} Verify connection string format
+   ${chalk.gray('mongodb://[username:password@]host[:port]/database[?options]')}
+   ${chalk.green('Example: mongodb://localhost:27017/frigg?replicaSet=rs0')}
+
+${chalk.gray('5.')} Check network/firewall settings
+   ${chalk.gray('Ensure port 27017 (default) is accessible')}
+`;
+}
+
+function getDocumentDbTroubleshooting() {
+    return `
+${chalk.gray('1.')} Verify DocumentDB cluster is available
+   ${chalk.cyan('aws docdb describe-db-clusters --db-cluster-identifier <name>')}
+
+${chalk.gray('2.')} Use TLS with the AWS CA bundle
+   ${chalk.gray('Download: https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem')}
+   ${chalk.gray('Add ?tls=true&tlsCAFile=/path/to/global-bundle.pem to DATABASE_URL')}
+
+${chalk.gray('3.')} Disable retryable writes (DocumentDB limitation)
+   ${chalk.gray('Add retryWrites=false to DATABASE_URL query string')}
+
+${chalk.gray('4.')} Include replicaSet parameter
+   ${chalk.gray('DocumentDB requires replicaSet=rs0 even for single-node clusters')}
+
+${chalk.gray('5.')} Allow inbound access from your Lambda or local IP
+   ${chalk.gray('Update security groups / VPC rules for port 27017')}
+`;
+}
+
+/**
+ * Gets PostgreSQL-specific troubleshooting steps
+ * @returns {string} Formatted troubleshooting steps
+ */
+function getPostgresTroubleshooting() {
+    return `
+${chalk.gray('1.')} Verify PostgreSQL is running
+   ${chalk.cyan('docker ps')} ${chalk.gray('(if using Docker)')}
+   ${chalk.cyan('pg_isready')} ${chalk.gray('(test if server is ready)')}
+
+${chalk.gray('2.')} Check connection string format
+   ${chalk.gray('postgresql://[username:password@]host[:port]/database[?options]')}
+   ${chalk.green('Example: postgresql://postgres:postgres@localhost:5432/frigg?schema=public')}
+
+${chalk.gray('3.')} Verify database exists
+   ${chalk.cyan('psql -U postgres -l')} ${chalk.gray('(list databases)')}
+   ${chalk.cyan('CREATE DATABASE frigg;')} ${chalk.gray('(if needed)')}
+
+${chalk.gray('4.')} Check pg_hba.conf allows connections
+   ${chalk.gray('Location: /var/lib/postgresql/data/pg_hba.conf (Docker)')}
+   ${chalk.gray('Ensure trust/md5 authentication is enabled for your host')}
+
+${chalk.gray('5.')} Verify network/firewall settings
+   ${chalk.gray('Ensure port 5432 (default) is accessible')}
+`;
+}
+
+/**
+ * Gets helpful error message for missing Prisma client
+ * @param {'mongodb'|'postgresql'|'documentdb'} dbType - Database type
+ * @returns {string} Formatted error message
+ */
+function getPrismaClientNotGeneratedError(dbType) {
+  // Normalize DocumentDB to MongoDB (they use the same Prisma client)
+  const normalizedType = normalizeMongoCompatible(dbType);
+  const clientName = `@prisma-${normalizedType}/client`;
+  const documentDbNote = dbType === 'documentdb'
+    ? [
+      chalk.gray('  • DocumentDB reuses the MongoDB Prisma client (prisma-mongodb)'),
+      chalk.gray('  • Confirm your connection string includes tls=true and retryWrites=false')
+    ].join('\n')
+    : '';
+
+    return `
+${chalk.red(`❌ Prisma client not generated for ${dbType}`)}
+
+${chalk.bold('The Prisma client needs to be generated before starting the application.')}
+
+${chalk.yellow('Run:')} ${chalk.cyan('frigg db:setup')}
+
+${chalk.gray('This will:')}
+${chalk.gray('  • Generate the Prisma client')} ${chalk.gray(`(${clientName})`)}
+${chalk.gray('  • Set up database schema')}
+${chalk.gray('  • Run migrations (PostgreSQL) or db push (MongoDB)')}
+${documentDbNote ? `${documentDbNote}\n` : ''}
+`;
+}
+
+/**
+ * Gets helpful error message for Prisma command failures
+ * @param {string} command - Command that failed (generate, migrate, push)
+ * @param {string} error - Error message
+ * @returns {string} Formatted error message
+ */
+function getPrismaCommandError(command, error) {
+    return `
+${chalk.red(`❌ Prisma ${command} failed`)}
+
+${chalk.bold('Error:')}
+${chalk.gray(error)}
+
+${chalk.bold('Common causes:')}
+${chalk.gray('  • Database schema has conflicts')}
+${chalk.gray('  • Database connection lost during operation')}
+${chalk.gray('  • Insufficient permissions')}
+${chalk.gray('  • Schema file is invalid')}
+
+${chalk.yellow('Try:')}
+${chalk.cyan('  frigg db:setup')} ${chalk.gray('(re-run setup)')}
+${chalk.cyan('  Check your DATABASE_URL')} ${chalk.gray('(verify connection string)')}
+${chalk.cyan('  Review Prisma schema')} ${chalk.gray('(node_modules/@friggframework/core/prisma-*/schema.prisma)')}
+`;
+}
+
+/**
+ * Gets success message for database setup completion
+ * @param {'mongodb'|'postgresql'|'documentdb'} dbType - Database type
+ * @param {string} stage - Deployment stage
+ * @returns {string} Formatted success message
+ */
+function getDatabaseSetupSuccess(dbType, stage) {
+    const databaseDisplayName = getDatabaseDisplayName(dbType);
+    const schemaAction = dbType === 'postgresql'
+        ? 'Migrations applied'
+        : dbType === 'documentdb'
+            ? 'Schema pushed to DocumentDB'
+            : 'Schema pushed to database';
+
+    return `
+${chalk.green('✅ Database setup completed successfully!')}
+
+${chalk.bold('Configuration:')}
+${chalk.gray('  Database type:')} ${chalk.cyan(databaseDisplayName)}
+${chalk.gray('  Stage:')} ${chalk.cyan(stage)}
+${chalk.gray('  Connection:')} ${chalk.green('verified')}
+
+${chalk.bold('What happened:')}
+${chalk.gray('  ✓')} Prisma client generated
+${chalk.gray('  ✓')} Database connection verified
+${chalk.gray('  ✓')} ${schemaAction}
+
+${chalk.yellow('Next steps:')}
+${chalk.cyan('  frigg start')} ${chalk.gray('(start your application)')}
+`;
+}
+
+/**
+ * Gets warning message for database already up-to-date
+ * @returns {string} Formatted warning message
+ */
+function getDatabaseAlreadyUpToDate() {
+    return `
+${chalk.yellow('⚠️  Database is already up-to-date')}
+
+${chalk.gray('No migrations or schema changes detected.')}
+
+${chalk.yellow('If you expected changes:')}
+${chalk.gray('  • Check if schema was modified in node_modules/@friggframework/core/prisma-*/')}
+${chalk.gray('  • Verify DATABASE_URL points to the correct database')}
+${chalk.gray('  • Check if you\'re in the correct project directory')}
+`;
+}
+
+module.exports = {
+    DATABASE_URL_EXAMPLES,
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getDatabaseConnectionError,
+    getPrismaClientNotGeneratedError,
+    getPrismaCommandError,
+    getDatabaseSetupSuccess,
+    getDatabaseAlreadyUpToDate
+};

package/frigg-cli/utils/npm-registry.js

@@ -0,0 +1,167 @@
+/**
+ * NPM Registry Service for CLI
+ * CommonJS version of the npm-registry service
+ */
+
+'use strict';
+
+const axios = require('axios');
+const NodeCache = require('node-cache');
+const semver = require('semver');
+
+class NPMRegistryService {
+    constructor() {
+        // Cache with 1 hour TTL by default
+        this.cache = new NodeCache({ 
+            stdTTL: 3600,
+            checkperiod: 600,
+            useClones: false
+        });
+        
+        this.npmRegistryUrl = 'https://registry.npmjs.org';
+        this.searchUrl = `${this.npmRegistryUrl}/-/v1/search`;
+        this.packageScope = '@friggframework';
+        this.modulePrefix = 'api-module-';
+    }
+
+    /**
+     * Search for all @friggframework/api-module-* packages
+     * @param {Object} options - Search options
+     * @param {boolean} options.includePrerelease - Include prerelease versions
+     * @param {boolean} options.forceRefresh - Force cache refresh
+     * @returns {Promise<Array>} Array of package information
+     */
+    async searchApiModules(options = {}) {
+        const cacheKey = `api-modules-${JSON.stringify(options)}`;
+        
+        // Check cache first unless force refresh is requested
+        if (!options.forceRefresh) {
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+
+        try {
+            // Search for packages matching our pattern
+            const searchQuery = `${this.packageScope}/${this.modulePrefix}`;
+            const response = await axios.get(this.searchUrl, {
+                params: {
+                    text: searchQuery,
+                    size: 250, // Get up to 250 results
+                    quality: 0.65,
+                    popularity: 0.98,
+                    maintenance: 0.5
+                },
+                timeout: 10000
+            });
+
+            const packages = response.data.objects
+                .filter(obj => obj.package.name.startsWith(`${this.packageScope}/${this.modulePrefix}`))
+                .map(obj => this.formatPackageInfo(obj.package));
+
+            // Filter out prereleases if requested
+            const filtered = options.includePrerelease 
+                ? packages 
+                : packages.filter(pkg => !semver.prerelease(pkg.version));
+
+            // Cache the results
+            this.cache.set(cacheKey, filtered);
+            
+            return filtered;
+        } catch (error) {
+            console.error('Error searching NPM registry:', error.message);
+            // Return empty array on error to allow offline usage
+            return [];
+        }
+    }
+
+    /**
+     * Extract integration name from package name
+     * @private
+     */
+    extractIntegrationName(packageName) {
+        return packageName
+            .replace(`${this.packageScope}/${this.modulePrefix}`, '')
+            .replace(/-/g, ' ')
+            .replace(/\b\w/g, l => l.toUpperCase());
+    }
+
+    /**
+     * Format package information for API response
+     * @private
+     */
+    formatPackageInfo(pkg) {
+        return {
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description,
+            keywords: pkg.keywords || [],
+            author: pkg.author,
+            publisher: pkg.publisher,
+            date: pkg.date,
+            links: pkg.links,
+            integrationName: this.extractIntegrationName(pkg.name),
+            category: this.categorizeModule(pkg)
+        };
+    }
+
+    /**
+     * Categorize module based on keywords and name
+     * @private
+     */
+    categorizeModule(module) {
+        const name = module.name?.toLowerCase() || '';
+        const keywords = module.keywords?.map(k => k.toLowerCase()) || [];
+        const allTerms = [...keywords, name];
+
+        // Categories based on common integration types - ordered by specificity
+        const categories = {
+            'Marketing': ['marketing', 'mailchimp', 'campaign', 'automation', 'klaviyo', 'activecampaign'],
+            'CRM': ['crm', 'customer', 'salesforce', 'hubspot', 'pipedrive', 'zoho'],
+            'E-commerce': ['ecommerce', 'shop', 'store', 'payment', 'stripe', 'paypal', 'shopify', 'woocommerce'],
+            'Analytics': ['analytics', 'tracking', 'google-analytics', 'mixpanel', 'segment', 'amplitude'],
+            'Social Media': ['social', 'facebook', 'twitter', 'instagram', 'linkedin', 'youtube'],
+            'Project Management': ['project', 'task', 'jira', 'trello', 'asana', 'monday', 'notion'],
+            'Storage': ['storage', 'file', 'dropbox', 'google-drive', 's3', 'box', 'onedrive'],
+            'Productivity': ['spreadsheet', 'google-sheets', 'airtable', 'calendar', 'todo'],
+            'Development': ['github', 'gitlab', 'bitbucket', 'git', 'ci', 'cd', 'jenkins'],
+            'Support': ['support', 'zendesk', 'freshdesk', 'intercom', 'helpdesk'],
+            'Finance': ['accounting', 'quickbooks', 'xero', 'sage', 'invoice', 'billing'],
+            'Communication': ['email', 'sms', 'chat', 'messaging', 'slack', 'discord', 'twilio', 'sendgrid'],
+            'Other': []
+        };
+
+        for (const [category, terms] of Object.entries(categories)) {
+            if (category === 'Other') continue;
+            
+            if (terms.some(term => allTerms.some(t => t.includes(term)))) {
+                return category;
+            }
+        }
+
+        return 'Other';
+    }
+
+    /**
+     * Get grouped modules by integration type
+     * @returns {Promise<Object>} Modules grouped by type
+     */
+    async getModulesByType() {
+        const modules = await this.searchApiModules();
+        
+        const grouped = modules.reduce((acc, module) => {
+            const type = module.category;
+            if (!acc[type]) {
+                acc[type] = [];
+            }
+            acc[type].push(module);
+            return acc;
+        }, {});
+
+        return grouped;
+    }
+}
+
+// Export singleton instance
+module.exports = new NPMRegistryService();

package/frigg-cli/utils/process-manager.js

@@ -0,0 +1,199 @@
+const chalk = require('chalk');
+const { spawn } = require('child_process');
+const readline = require('readline');
+
+class ProcessManager {
+    constructor() {
+        this.processes = new Map();
+        this.isShuttingDown = false;
+        this.outputBuffer = new Map();
+        this.setupShutdownHandlers();
+    }
+
+    setupShutdownHandlers() {
+        const shutdown = async () => {
+            if (this.isShuttingDown) return;
+            this.isShuttingDown = true;
+
+            console.log('\n' + chalk.yellow('⏹  Shutting down...'));
+            
+            const shutdownPromises = [];
+            for (const [name, proc] of this.processes) {
+                shutdownPromises.push(this.killProcess(name, proc));
+            }
+
+            await Promise.all(shutdownPromises);
+            
+            console.log(chalk.green('✓ All processes stopped cleanly'));
+            process.exit(0);
+        };
+
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        process.on('exit', () => {
+            for (const [, proc] of this.processes) {
+                try {
+                    proc.kill('SIGKILL');
+                } catch (e) {
+                    // Process already dead
+                }
+            }
+        });
+    }
+
+    async killProcess(name, proc) {
+        return new Promise((resolve) => {
+            if (!proc || proc.killed) {
+                resolve();
+                return;
+            }
+
+            const timeout = setTimeout(() => {
+                try {
+                    proc.kill('SIGKILL');
+                } catch (e) {
+                    // Process already dead
+                }
+                resolve();
+            }, 5000);
+
+            proc.once('exit', () => {
+                clearTimeout(timeout);
+                this.processes.delete(name);
+                resolve();
+            });
+
+            try {
+                proc.kill('SIGTERM');
+            } catch (e) {
+                clearTimeout(timeout);
+                resolve();
+            }
+        });
+    }
+
+    spawnProcess(name, command, args, options = {}) {
+        const proc = spawn(command, args, {
+            ...options,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true
+        });
+
+        this.processes.set(name, proc);
+        this.outputBuffer.set(name, []);
+
+        // Create readline interfaces for better line handling
+        const stdoutReader = readline.createInterface({
+            input: proc.stdout,
+            crlfDelay: Infinity
+        });
+
+        const stderrReader = readline.createInterface({
+            input: proc.stderr,
+            crlfDelay: Infinity
+        });
+
+        stdoutReader.on('line', (line) => {
+            if (!this.isShuttingDown) {
+                this.handleOutput(name, line, 'stdout');
+            }
+        });
+
+        stderrReader.on('line', (line) => {
+            if (!this.isShuttingDown) {
+                this.handleOutput(name, line, 'stderr');
+            }
+        });
+
+        proc.on('error', (error) => {
+            if (!this.isShuttingDown) {
+                console.error(chalk.red(`[${name}] Process error:`), error.message);
+            }
+        });
+
+        proc.on('exit', (code, signal) => {
+            this.processes.delete(name);
+            if (!this.isShuttingDown && code !== 0 && code !== null) {
+                console.error(chalk.red(`[${name}] Process exited with code ${code}`));
+            }
+        });
+
+        return proc;
+    }
+
+    handleOutput(processName, line, stream) {
+        // Filter out noisy/redundant messages
+        const filters = [
+            /VITE v\d+\.\d+\.\d+/,
+            /ready in \d+ ms/,
+            /Local:/,
+            /Network:/,
+            /press h \+ enter to show help/,
+            /\[nodemon\]/,
+            /watching for file changes/,
+            /restarting due to changes/,
+            /starting/,
+            /clean exit/,
+            /waiting for changes before restart/,
+            /^$/  // empty lines
+        ];
+
+        if (filters.some(filter => filter.test(line))) {
+            return;
+        }
+
+        // Format output based on process
+        const prefix = this.getProcessPrefix(processName);
+        const coloredLine = this.colorizeOutput(line, stream);
+        
+        console.log(`${prefix} ${coloredLine}`);
+    }
+
+    getProcessPrefix(processName) {
+        const prefixes = {
+            'frontend': chalk.blue('[Frontend]'),
+            'backend': chalk.green('[Backend]'),
+            'vite': chalk.blue('[Vite]'),
+            'server': chalk.green('[Server]')
+        };
+
+        return prefixes[processName.toLowerCase()] || chalk.gray(`[${processName}]`);
+    }
+
+    colorizeOutput(line, stream) {
+        // Error detection
+        if (stream === 'stderr' || /error|fail|exception/i.test(line)) {
+            return chalk.red(line);
+        }
+
+        // Warning detection
+        if (/warn|warning/i.test(line)) {
+            return chalk.yellow(line);
+        }
+
+        // Success detection
+        if (/success|ready|started|listening|compiled/i.test(line)) {
+            return chalk.green(line);
+        }
+
+        // Info detection
+        if (/info|starting/i.test(line)) {
+            return chalk.blue(line);
+        }
+
+        return chalk.gray(line);
+    }
+
+    printStatus(frontendUrl, backendUrl, repoName) {
+        console.log('\n' + chalk.bold.green('✨ Frigg Management UI is ready!'));
+        console.log('');
+        console.log(chalk.cyan('  Frontend:  ') + chalk.white(frontendUrl));
+        console.log(chalk.cyan('  Backend:   ') + chalk.white(backendUrl));
+        console.log(chalk.cyan('  Repository:') + chalk.white(` ${repoName}`));
+        console.log('');
+        console.log(chalk.gray('  Press ' + chalk.bold('Ctrl+C') + ' to stop all servers'));
+        console.log('');
+    }
+}
+
+module.exports = ProcessManager;