@simplens/onboard 1.0.8 → 1.0.10

package/src/plugins.ts

@@ -1,221 +0,0 @@
-import { execa } from 'execa';
-import yaml from 'js-yaml';
-import crypto from 'crypto';
-import { readFile, logInfo, logSuccess, logError, logWarning } from './utils.js';
-import { multiselect, text, password } from '@clack/prompts';
-import { handleCancel, spinner } from './ui.js';
-import path from 'path';
-import type { PluginInfo, SimplensConfig } from './types/domain.js';
-
-/**
- * Fetches available SimpleNS plugins using the config-gen CLI tool.
- * Falls back to default plugins if fetching fails.
- *
- * @returns Array of available plugin information
- */
-export async function fetchAvailablePlugins(): Promise<PluginInfo[]> {
-    const s = spinner();
-    s.start('Fetching available plugins...');
-
-    try {
-        // Execute config-gen list command
-        const { stdout } = await execa('npx', ['@simplens/config-gen', 'list', '--official'], {
-            stdio: 'pipe',
-        });
-
-        // Parse output to extract plugins
-        // Expected format: "  @simplens/package-name      Plugin Name"
-        const plugins: PluginInfo[] = [];
-        const lines = stdout.split('\n');
-
-        for (const line of lines) {
-            // Match plugin lines (starts with @simplens/)
-            const match = line.match(/^\s+(@simplens\/[\w-]+)\s+(.+)$/);
-            if (match) {
-                const [, packageName, rest] = match;
-                // Extract name and description
-                const parts = rest.split(/\s{2,}/); // Split by multiple spaces
-                plugins.push({
-                    package: packageName.trim(),
-                    name: parts[0]?.trim() || packageName,
-                    description: parts[1]?.trim() || '',
-                });
-            }
-        }
-
-        s.stop(`Found ${plugins.length} available plugins`);
-        return plugins;
-    } catch (error: unknown) {
-        s.stop('Could not fetch plugins list. Using defaults.');
-        logWarning('Falling back to default plugin list.');
-        // Return default plugins as fallback
-        return [
-            { package: '@simplens/mock', name: 'Mock Provider', description: 'Mock notification provider for testing' },
-            { package: '@simplens/nodemailer-gmail', name: 'Gmail', description: 'Send emails via Gmail' },
-            { package: '@simplens/resend', name: 'Resend', description: 'Send emails via Resend' },
-        ];
-    }
-}
-
-/**
- * Prompt user to select plugins
- */
-export async function promptPluginSelection(availablePlugins: PluginInfo[]): Promise<string[]> {
-    if (availablePlugins.length === 0) {
-        logWarning('No plugins available to select.');
-        return [];
-    }
-
-    const selected = await multiselect({
-        message: 'Select plugins to install (Space to select, Enter to confirm):',
-        options: availablePlugins.map(p => ({
-            value: p.package,
-            label: `${p.name} (${p.package})`,
-            hint: p.description,
-        })),
-        initialValues: availablePlugins
-            .filter(p => p.package === '@simplens/mock')
-            .map(p => p.package),
-        withGuide: true,
-    });
-
-    handleCancel(selected);
-    return selected as string[];
-}
-
-/**
- * Generate plugin configuration using config-gen
- */
-export async function generatePluginConfig(
-    targetDir: string,
-    selectedPlugins: string[]
-): Promise<void> {
-    if (selectedPlugins.length === 0) {
-        logInfo('No plugins selected, skipping config generation.');
-        return;
-    }
-
-    const s = spinner();
-    s.start(`Generating configuration for ${selectedPlugins.length} plugin(s)...`);
-
-    try {
-        // Execute config-gen for all selected plugins
-        // Use relative path to avoid WSL path issues when npx runs Windows binaries
-        await execa(
-            'npx',
-            ['@simplens/config-gen', 'gen', ...selectedPlugins, '-o', 'simplens.config.yaml'],
-            { cwd: targetDir, stdio: 'pipe' }
-        );
-
-        s.stop('Generated simplens.config.yaml');
-    } catch (error: unknown) {
-        s.error('Failed to generate plugin configuration');
-        throw error;
-    }
-}
-
-/**
- * Parse simplens.config.yaml to extract credential keys
- */
-export async function parseConfigCredentials(configPath: string): Promise<string[]> {
-    try {
-        const content = await readFile(configPath);
-        const config: any = yaml.load(content);
-
-        const credentialKeys = new Set<string>();
-
-        // Extract credential keys from providers (ONLY from credentials, not optionalConfig)
-        if (config.providers && Array.isArray(config.providers)) {
-            for (const provider of config.providers) {
-                if (provider.credentials && typeof provider.credentials === 'object') {
-                    for (const [key, value] of Object.entries(provider.credentials)) {
-                        // Extract env var name from ${ENV_VAR} format
-                        if (typeof value === 'string' && value.startsWith('${') && value.endsWith('}')) {
-                            const envVar = value.slice(2, -1);
-                            credentialKeys.add(envVar);
-                        }
-                    }
-                }
-                // NOTE: We intentionally skip optionalConfig - those are optional!
-            }
-        }
-
-        return Array.from(credentialKeys);
-    } catch (error) {
-        logWarning('Could not parse config file for credentials');
-        return [];
-    }
-}
-
-/**
- * Generate default placeholder values for plugin credentials
- * Used in --full mode for non-interactive setup
- */
-export function generateDefaultPluginCredentials(credentialKeys: string[]): Map<string, string> {
-    const result = new Map<string, string>();
-
-    for (const key of credentialKeys) {
-        // Generate placeholder values based on key name patterns
-        if (key.toLowerCase().includes('password') || key.toLowerCase().includes('secret')) {
-            result.set(key, crypto.randomBytes(16).toString('base64'));
-        } else if (key.toLowerCase().includes('apikey') || key.toLowerCase().includes('api_key')) {
-            result.set(key, `sk_${crypto.randomBytes(24).toString('base64').slice(0, 32)}`);
-        } else if (key.toLowerCase().includes('token')) {
-            result.set(key, crypto.randomBytes(32).toString('hex'));
-        } else if (key.toLowerCase().includes('email') || key.toLowerCase().includes('user')) {
-            result.set(key, 'CHANGE_ME@example.com');
-        } else {
-            // Generic placeholder
-            result.set(key, 'CHANGE_ME');
-        }
-    }
-
-    return result;
-}
-
-/**
- * Prompt for plugin-specific credentials
- */
-export async function promptPluginCredentials(credentialKeys: string[]): Promise<Map<string, string>> {
-    if (credentialKeys.length === 0) {
-        logInfo('No plugin credentials required.');
-        return new Map();
-    }
-
-    logInfo('Configuring plugin credentials...');
-
-    const result = new Map<string, string>();
-
-    for (const key of credentialKeys) {
-        const isSecret = key.toLowerCase().includes('password') || key.toLowerCase().includes('key');
-
-        let answer: string | symbol;
-        if (isSecret) {
-            answer = await password({
-                message: `${key}:`,
-                validate: (input: string | undefined) => {
-                    if (!input || input.trim().length === 0) {
-                        return `${key} is required`;
-                    }
-                    return undefined;
-                },
-            });
-        } else {
-            answer = await text({
-                message: `${key}:`,
-                validate: (input: string | undefined) => {
-                    if (!input || input.trim().length === 0) {
-                        return `${key} is required`;
-                    }
-                    return undefined;
-                },
-            });
-        }
-
-        handleCancel(answer);
-        result.set(key, answer as string);
-    }
-
-    logSuccess('Plugin credentials configured');
-    return result;
-}

package/src/services.ts

@@ -1,308 +0,0 @@
-import { execa } from 'execa';
-import chalk from 'chalk';
-import { logInfo, logWarning, divider, printSummaryCard, printCommandHints } from './utils.js';
-import { confirm } from '@clack/prompts';
-import { handleCancel, spinner } from './ui.js';
-import { HEALTH_CHECK, getServiceURL } from './config/constants.js';
-
-/**
- * Execute docker compose command with fallback to docker-compose.
- * Tries 'docker compose' first (newer), then falls back to 'docker-compose' (legacy).
- */
-async function execDockerCompose(args: string[], cwd: string): Promise<void> {
-    try {
-        // Try newer 'docker compose' first
-        await execa('docker', ['compose', ...args], { cwd });
-    } catch (error) {
-        // Fallback to legacy 'docker-compose'
-        await execa('docker-compose', args, { cwd });
-    }
-}
-
-async function waitForContainerRunning(
-    containerName: string,
-    timeoutMs: number = 60_000,
-    intervalMs: number = 1_500
-): Promise<void> {
-    const maxRetries = Math.ceil(timeoutMs / intervalMs);
-
-    for (let i = 0; i < maxRetries; i++) {
-        try {
-            const { stdout } = await execa('docker', [
-                'ps',
-                '--filter',
-                `name=^${containerName}$`,
-                '--filter',
-                'status=running',
-                '--format',
-                '{{.Names}}',
-            ]);
-
-            const running = stdout
-                .split('\n')
-                .map(line => line.trim())
-                .filter(Boolean)
-                .includes(containerName);
-
-            if (running) {
-                return;
-            }
-        } catch {
-            // continue polling
-        }
-
-        await sleep(intervalMs);
-    }
-
-    throw new Error(`Container '${containerName}' did not reach running state within ${timeoutMs}ms`);
-}
-
-type ComposeFile = 'docker-compose.yaml' | 'docker-compose.infra.yaml';
-
-function withComposeFile(args: string[], composeFile?: ComposeFile): string[] {
-    if (!composeFile) {
-        return args;
-    }
-    return ['-f', composeFile, ...args];
-}
-
-/**
- * Prompts user whether to start the services immediately after setup.
- *
- * @returns `true` if user wants to start services, `false` otherwise
- */
-export async function promptStartServices(): Promise<boolean> {
-    const shouldStart = await confirm({
-        message: 'Start services now after setup?',
-        initialValue: true,
-        withGuide: true,
-    });
-
-    handleCancel(shouldStart);
-    return shouldStart as boolean;
-}
-
-/**
- * Starts infrastructure services using docker compose.
- * Runs `docker compose -f docker-compose.infra.yaml up -d` first,
- * then falls back to `docker-compose -f docker-compose.infra.yaml up -d`.
- *
- * @param targetDir - Directory containing docker-compose.infra.yaml
- * @throws Error if both docker compose and docker-compose commands fail
- */
-export async function startInfraServices(targetDir: string): Promise<void> {
-    logInfo('Starting infrastructure services...');
-
-    const s = spinner();
-    s.start('Starting docker-compose.infra.yaml...');
-
-    try {
-        await execDockerCompose(
-            ['-f', 'docker-compose.infra.yaml', 'up', '-d'],
-            targetDir
-        );
-        s.stop('Infrastructure services started');
-    } catch (error: unknown) {
-        s.error('Failed to start infrastructure services');
-        throw error;
-    }
-}
-
-/**
- * Waits for infrastructure services to become healthy.
- * Polls Docker health checks for up to 60 seconds (30 retries x 2s).
- *
- * @param targetDir - Directory where services are running
- */
-export async function waitForInfraHealth(targetDir: string): Promise<void> {
-    logInfo('Waiting for infrastructure services to be healthy...');
-
-    const s = spinner();
-    s.start('Checking service health...');
-
-    // Wait for mongo, redis health checks
-    const maxRetries = HEALTH_CHECK.MAX_RETRIES;
-    const retryDelay = HEALTH_CHECK.RETRY_DELAY_MS;
-
-    for (let i = 0; i < maxRetries; i++) {
-        try {
-            // Check if containers are healthy
-            const { stdout } = await execa('docker', ['ps', '--filter', 'health=healthy', '--format', '{{.Names}}']);
-            const healthyContainers = stdout.split('\n').filter(Boolean);
-
-            // Check for critical services
-            const hasMongoOrRedis = healthyContainers.some(name =>
-                name.includes('mongo') || name.includes('redis')
-            );
-
-            if (hasMongoOrRedis) {
-                s.stop('Infrastructure services are healthy');
-                return;
-            }
-
-            s.message(`Waiting for services... (${i + 1}/${maxRetries})`);
-            await sleep(retryDelay);
-        } catch (error) {
-            s.message(`Checking health... (${i + 1}/${maxRetries})`);
-            await sleep(retryDelay);
-        }
-    }
-
-    s.stop('Health check timed out, but services may still be starting');
-    logWarning('You may need to wait a bit longer for all services to be ready.');
-}
-
-/**
- * Start application services
- */
-export async function startAppServices(targetDir: string): Promise<void> {
-    logInfo('Starting application services...');
-
-    const s = spinner();
-    s.start('Starting docker-compose.yaml...');
-
-    try {
-        await execDockerCompose(
-            ['up', '-d'],
-            targetDir
-        );
-        s.stop('Application services started');
-    } catch (error: unknown) {
-        s.error('Failed to start application services');
-        throw error;
-    }
-}
-
-export function getSslManualCommands(options: {
-    composeFile: ComposeFile;
-    domain: string;
-    email: string;
-}): string[] {
-    const composeFlag = options.composeFile === 'docker-compose.infra.yaml'
-        ? '-f docker-compose.infra.yaml '
-        : '';
-
-    return [
-        `docker compose ${composeFlag}up -d nginx certbot certbot-renew`,
-        `docker compose ${composeFlag}exec -T certbot certbot certonly --webroot -w /var/www/certbot --email ${options.email} --agree-tos --no-eff-email -d ${options.domain} --non-interactive`,
-        `docker compose ${composeFlag}exec -T nginx nginx -s reload`,
-        `docker compose ${composeFlag}up -d certbot-renew`,
-    ];
-}
-
-export async function setupSslCertificates(targetDir: string, options: {
-    composeFile: ComposeFile;
-    domain: string;
-    email: string;
-}): Promise<void> {
-    logInfo(`Setting up SSL certificate for ${options.domain}...`);
-
-    const s = spinner();
-    const composeArgs = (args: string[]) => withComposeFile(args, options.composeFile);
-
-    s.start('Ensuring nginx/certbot services are running...');
-    await execDockerCompose(composeArgs(['up', '-d', 'nginx', 'certbot']), targetDir);
-    await waitForContainerRunning('nginx');
-    await waitForContainerRunning('certbot');
-    s.stop('Nginx and certbot services are running');
-
-    s.start('Requesting initial certificate from Let\'s Encrypt...');
-    await execDockerCompose(
-        composeArgs([
-            'exec',
-            '-T',
-            'certbot',
-            'certbot',
-            'certonly',
-            '--webroot',
-            '-w',
-            '/var/www/certbot',
-            '--email',
-            options.email,
-            '--agree-tos',
-            '--no-eff-email',
-            '-d',
-            options.domain,
-            '--non-interactive',
-        ]),
-        targetDir
-    );
-    s.stop('Initial certificate issued');
-
-    s.start('Reloading nginx to apply certificates...');
-    await execDockerCompose(composeArgs(['exec', '-T', 'nginx', 'nginx', '-s', 'reload']), targetDir);
-    s.stop('Nginx reloaded');
-
-    s.start('Starting automatic certificate renewal service...');
-    await execDockerCompose(composeArgs(['up', '-d', 'certbot-renew']), targetDir);
-    s.stop('Certificate auto-renewal service started');
-}
-
-export async function reloadNginxConfiguration(targetDir: string, options: {
-    composeFile: ComposeFile;
-}): Promise<void> {
-    const composeArgs = (args: string[]) => withComposeFile(args, options.composeFile);
-    await execDockerCompose(composeArgs(['exec', '-T', 'nginx', 'nginx', '-t']), targetDir);
-    await execDockerCompose(composeArgs(['exec', '-T', 'nginx', 'nginx', '-s', 'reload']), targetDir);
-}
-
-/**
- * Display service status and URLs
- */
-export async function displayServiceStatus(): Promise<void> {
-    console.log(`\n${divider('green', '═')}`);
-    console.log(chalk.greenBright(chalk.bold('Services Started')));
-    console.log(divider('green', '═'));
-
-    try {
-        // Get running containers
-        const { stdout } = await execa('docker', ['ps', '--format', '{{.Names}}']);
-        const containers = stdout.split('\n').filter(Boolean).sort();
-
-        const accessRows: Array<{ label: string; value: string }> = [];
-
-        // Display URLs for known services
-        if (containers.some(c => c.includes('api'))) {
-            accessRows.push({ label: 'API Server', value: getServiceURL('API') });
-            accessRows.push({ label: 'API Health', value: `${getServiceURL('API')}/health` });
-        }
-
-        if (containers.some(c => c.includes('dashboard'))) {
-            accessRows.push({ label: 'Dashboard', value: getServiceURL('DASHBOARD') });
-        }
-
-        if (containers.some(c => c.includes('kafka-ui'))) {
-            accessRows.push({ label: 'Kafka UI', value: getServiceURL('KAFKA_UI') });
-        }
-
-        if (containers.some(c => c.includes('grafana'))) {
-            accessRows.push({ label: 'Grafana', value: `${getServiceURL('GRAFANA')} (admin/admin)` });
-        }
-
-        if (accessRows.length > 0) {
-            printSummaryCard('Access URLs', accessRows);
-        }
-
-        console.log(chalk.cyanBright('Running Containers'));
-        console.log(divider());
-        for (const container of containers) {
-            console.log(`  ${chalk.greenBright('•')} ${container}`);
-        }
-        console.log('');
-
-        printCommandHints('Helpful commands', [
-            'docker compose logs -f',
-            'docker compose down',
-        ]);
-        console.log(`${divider('green', '═')}\n`);
-    } catch (error) {
-        logWarning('Could not fetch container status');
-    }
-}
-
-/**
- * Helper: Sleep for specified milliseconds
- */
-function sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}