hostfn 0.1.0

package/packages/cli/src/commands/logs.ts

@@ -0,0 +1,106 @@
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { Logger } from '../utils/logger.js';
+import { ConfigLoader } from '../config/loader.js';
+import { createSSHConnection } from '../core/ssh.js';
+import { RuntimeRegistry } from '../runtimes/registry.js';
+import { Runtime } from '../config/schema.js';
+
+interface LogsOptions {
+  lines: string;
+  errors: boolean;
+  follow?: boolean;
+  output?: string;
+  service?: string;
+}
+
+export async function logsCommand(
+  environment: string,
+  options: LogsOptions
+): Promise<void> {
+  Logger.header(`Logs - ${environment}`);
+
+  // Load configuration
+  const config = ConfigLoader.load();
+  const envConfig = config.environments[environment];
+
+  if (!envConfig) {
+    throw new Error(`Environment '${environment}' not found`);
+  }
+
+  // Handle multi-service logs
+  if (config.services && Object.keys(config.services).length > 0) {
+    if (!options.service) {
+      throw new Error(
+        'Multi-service deployment detected. Please specify --service <name>\n' +
+        `Available services: ${Object.keys(config.services).join(', ')}`
+      );
+    }
+    
+    if (!config.services[options.service]) {
+      throw new Error(
+        `Service '${options.service}' not found\n` +
+        `Available: ${Object.keys(config.services).join(', ')}`
+      );
+    }
+    
+    const serviceConfig = config.services[options.service];
+    const serviceServer = serviceConfig.server || envConfig.server;
+    const serviceName = `${config.name}-${options.service}-${environment}`;
+    await fetchLogs(serviceName, serviceServer, config.runtime, options);
+    return;
+  }
+
+  const serviceName = `${config.name}-${environment}`;
+  await fetchLogs(serviceName, envConfig.server, config.runtime, options);
+}
+
+async function fetchLogs(
+  serviceName: string,
+  server: string,
+  runtime: Runtime,
+  options: LogsOptions
+): Promise<void> {
+  const adapter = RuntimeRegistry.get(runtime);
+  const pm2 = adapter.getProcessManager();
+
+  const spinner = ora('Connecting to server...').start();
+
+  try {
+    const ssh = await createSSHConnection(server);
+    spinner.succeed('Connected');
+
+    Logger.br();
+
+    // Generate logs command
+    let logsCmd = pm2.generateLogsCommand(serviceName, parseInt(options.lines));
+    
+    // Add error filtering if requested
+    if (options.errors) {
+      logsCmd = `${logsCmd} 2>&1 | grep -E "(error|Error|ERROR|fail|Fail|FAIL|exception|Exception)"`;
+    }
+    
+    // Execute logs command
+    const result = await ssh.exec(logsCmd, { streaming: !options.output });
+
+    if (result.exitCode !== 0) {
+      Logger.error('Failed to fetch logs');
+    }
+
+    // Save to file if requested
+    if (options.output) {
+      const outputPath = path.resolve(process.cwd(), options.output);
+      fs.writeFileSync(outputPath, result.stdout);
+      Logger.success(`Logs saved to: ${outputPath}`);
+      Logger.kv('Lines', result.stdout.split('\n').length.toString());
+      Logger.kv('Size', `${(result.stdout.length / 1024).toFixed(2)} KB`);
+    }
+
+    ssh.disconnect();
+  } catch (error) {
+    spinner.fail('Failed to get logs');
+    Logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/rollback.ts

@@ -0,0 +1,142 @@
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { Logger } from '../utils/logger.js';
+import { ConfigLoader } from '../config/loader.js';
+import { createSSHConnection } from '../core/ssh.js';
+import { BackupManager } from '../core/backup.js';
+import { RuntimeRegistry } from '../runtimes/registry.js';
+
+interface RollbackOptions {
+  to?: string;
+}
+
+export async function rollbackCommand(
+  environment: string,
+  options: RollbackOptions
+): Promise<void> {
+  Logger.header(`Rollback - ${environment}`);
+
+  // Load configuration
+  const config = ConfigLoader.load();
+  const envConfig = config.environments[environment];
+
+  if (!envConfig) {
+    throw new Error(`Environment '${environment}' not found`);
+  }
+
+  const remoteDir = `/var/www/${config.name}-${environment}`;
+  const serviceName = `${config.name}-${environment}`;
+
+  const spinner = ora('Connecting to server...').start();
+
+  try {
+    const ssh = await createSSHConnection(envConfig.server);
+    spinner.succeed('Connected');
+
+    Logger.br();
+
+    const backupManager = new BackupManager(ssh, remoteDir);
+
+    // List available backups
+    const listSpinner = ora('Fetching available backups...').start();
+    const backups = await backupManager.list();
+    listSpinner.succeed(`Found ${backups.length} backup(s)`);
+
+    if (backups.length === 0) {
+      Logger.warn('No backups available');
+      ssh.disconnect();
+      return;
+    }
+
+    Logger.br();
+
+    let backupToRestore: string;
+
+    if (options.to) {
+      // Use specified backup
+      if (!backups.includes(options.to)) {
+        throw new Error(`Backup not found: ${options.to}`);
+      }
+      backupToRestore = options.to;
+    } else {
+      // Interactive selection
+      Logger.section('Available Backups');
+      backups.slice(0, 10).forEach((backup, idx) => {
+        Logger.log(`  ${idx + 1}. ${backup}`);
+      });
+      Logger.br();
+
+      const { selectedBackup } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selectedBackup',
+          message: 'Select backup to restore:',
+          choices: backups.slice(0, 10).map((b, idx) => ({
+            name: `${idx + 1}. ${b}${idx === 0 ? ' (latest)' : ''}`,
+            value: b,
+          })),
+        },
+      ]);
+
+      backupToRestore = selectedBackup;
+    }
+
+    // Confirm rollback
+    Logger.br();
+    Logger.warn(`This will rollback to: ${backupToRestore}`);
+    
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Are you sure you want to rollback?',
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      Logger.info('Rollback cancelled');
+      ssh.disconnect();
+      return;
+    }
+
+    Logger.br();
+
+    // Perform rollback
+    const rollbackSpinner = ora('Restoring backup...').start();
+    await backupManager.restore(backupToRestore);
+    rollbackSpinner.succeed('Backup restored');
+
+    // Reload PM2
+    const adapter = RuntimeRegistry.get(config.runtime);
+    const pm2 = adapter.getProcessManager();
+    
+    const reloadSpinner = ora('Reloading service...').start();
+    const reloadResult = await ssh.exec(
+      pm2.generateReloadCommand(serviceName),
+      { cwd: remoteDir }
+    );
+
+    if (reloadResult.exitCode !== 0) {
+      reloadSpinner.fail('Service reload failed');
+      throw new Error(`PM2 reload failed: ${reloadResult.stderr}`);
+    }
+    reloadSpinner.succeed('Service reloaded');
+
+    Logger.br();
+    Logger.success('Rollback completed successfully!');
+    Logger.br();
+    Logger.kv('Restored backup', backupToRestore);
+    Logger.kv('Service', serviceName);
+    Logger.br();
+    Logger.info('Check status:');
+    Logger.command(`hostfn status ${environment}`);
+    Logger.br();
+
+    ssh.disconnect();
+  } catch (error) {
+    spinner.fail('Rollback failed');
+    Logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/server/info.ts

@@ -0,0 +1,131 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { Logger } from '../../utils/logger.js';
+import { createSSHConnection } from '../../core/ssh.js';
+
+export async function serverInfoCommand(host: string): Promise<void> {
+  Logger.header('Server Information');
+  
+  Logger.kv('Host', host);
+  Logger.br();
+
+  const spinner = ora('Connecting to server...').start();
+
+  try {
+    const ssh = await createSSHConnection(host);
+    spinner.succeed('Connected');
+
+    Logger.br();
+
+    // Get system information
+    const infoSpinner = ora('Gathering system information...').start();
+
+    const [
+      osInfo,
+      nodeVersion,
+      pm2Version,
+      nginxStatus,
+      diskSpace,
+      memoryInfo,
+      pm2List,
+    ] = await Promise.all([
+      ssh.exec('cat /etc/os-release | grep PRETTY_NAME | cut -d= -f2 | tr -d \'"\''),
+      ssh.exec('source ~/.nvm/nvm.sh && node --version 2>/dev/null || echo "not installed"'),
+      ssh.exec('pm2 --version 2>/dev/null || echo "not installed"'),
+      ssh.exec('systemctl is-active nginx 2>/dev/null || echo "not running"'),
+      ssh.exec('df -h / | tail -1'),
+      ssh.exec('free -h'),
+      ssh.exec('pm2 jlist 2>/dev/null || echo "[]"'),
+    ]);
+
+    infoSpinner.succeed('Information gathered');
+
+    Logger.br();
+
+    // Display OS information
+    Logger.section('System');
+    Logger.kv('OS', osInfo.stdout.trim() || 'Unknown');
+    
+    // Display disk space
+    const diskParts = diskSpace.stdout.trim().split(/\s+/);
+    if (diskParts.length >= 5) {
+      Logger.kv('Disk', `${diskParts[2]} used / ${diskParts[1]} total (${diskParts[4]} used)`);
+    }
+
+    // Display memory
+    const memLines = memoryInfo.stdout.trim().split('\n');
+    if (memLines.length >= 2) {
+      const memParts = memLines[1].split(/\s+/);
+      if (memParts.length >= 3) {
+        Logger.kv('Memory', `${memParts[2]} used / ${memParts[1]} total`);
+      }
+    }
+
+    Logger.br();
+
+    // Display runtime information
+    Logger.section('Runtime');
+    const node = nodeVersion.stdout.trim();
+    Logger.kv('Node.js', node === 'not installed' ? chalk.red(node) : chalk.green(node));
+    
+    const pm2 = pm2Version.stdout.trim();
+    Logger.kv('PM2', pm2 === 'not installed' ? chalk.red(pm2) : chalk.green(pm2));
+    
+    const nginx = nginxStatus.stdout.trim();
+    Logger.kv('Nginx', nginx === 'active' ? chalk.green(nginx) : chalk.yellow(nginx));
+
+    Logger.br();
+
+    // Display running services
+    Logger.section('Services');
+    
+    try {
+      const services = JSON.parse(pm2List.stdout || '[]');
+      
+      if (services.length === 0) {
+        Logger.info('No PM2 services running');
+      } else {
+        for (const service of services) {
+          const status = service.pm2_env?.status || 'unknown';
+          const memory = service.monit?.memory 
+            ? `${Math.round(service.monit.memory / 1024 / 1024)}MB`
+            : 'N/A';
+          const cpu = service.monit?.cpu !== undefined
+            ? `${service.monit.cpu}%`
+            : 'N/A';
+          const uptime = service.pm2_env?.pm_uptime
+            ? formatUptime(Date.now() - service.pm2_env.pm_uptime)
+            : 'N/A';
+
+          const statusColor = status === 'online' ? chalk.green : chalk.red;
+          
+          Logger.log(`  ${chalk.bold(service.name)}`);
+          Logger.log(`    Status: ${statusColor(status)}`);
+          Logger.log(`    Memory: ${memory}  CPU: ${cpu}  Uptime: ${uptime}`);
+          Logger.br();
+        }
+      }
+    } catch {
+      Logger.warn('Could not parse PM2 service list');
+    }
+
+    ssh.disconnect();
+
+  } catch (error) {
+    spinner.fail('Failed to get server information');
+    Logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function formatUptime(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}

package/packages/cli/src/commands/server/setup.ts

@@ -0,0 +1,200 @@
+import { writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { Logger } from '../../utils/logger.js';
+import { ConfigLoader } from '../../config/loader.js';
+import { RuntimeRegistry } from '../../runtimes/registry.js';
+import { createSSHConnection } from '../../core/ssh.js';
+import { validateSSHConnection, validatePort, validateNodeVersion } from '../../utils/validation.js';
+
+interface SetupOptions {
+  env: string;
+  nodeVersion: string;
+  port: string;
+  redis: boolean;
+  password?: string;
+  execute?: boolean;
+}
+
+export async function serverSetupCommand(
+  host: string,
+  options: SetupOptions
+): Promise<void> {
+  Logger.header('Server Setup');
+
+  // Validate inputs
+  if (!validateSSHConnection(host)) {
+    process.exit(1);
+  }
+
+  if (!validatePort(parseInt(options.port))) {
+    process.exit(1);
+  }
+
+  if (!validateNodeVersion(options.nodeVersion)) {
+    process.exit(1);
+  }
+
+  Logger.kv('Host', host);
+  Logger.kv('Environment', options.env);
+  Logger.kv('Port', options.port);
+  Logger.kv('Redis', options.redis ? 'Yes' : 'No');
+  Logger.br();
+
+  // Load config to detect runtime (or use default Node.js)
+  let runtime = 'nodejs';
+  try {
+    if (ConfigLoader.exists()) {
+      const config = ConfigLoader.load();
+      runtime = config.runtime;
+    }
+  } catch {
+    // If no config, assume Node.js
+    Logger.warn('No config found, assuming Node.js runtime');
+  }
+
+  // Get runtime adapter
+  const adapter = RuntimeRegistry.get(runtime as any);
+
+  // Generate setup script
+  const spinner = ora('Generating setup script...').start();
+  
+  const setupScript = adapter.generateSetupScript(options.nodeVersion, {
+    port: parseInt(options.port),
+    environment: options.env,
+    installRedis: options.redis,
+  });
+
+  // Write script to temp file
+  const scriptPath = join(tmpdir(), 'hostfn-setup.sh');
+  writeFileSync(scriptPath, setupScript, { mode: 0o755 });
+  
+  spinner.succeed('Setup script generated');
+
+  Logger.br();
+  
+  // Ask if user wants to execute now
+  const { executeNow } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'executeNow',
+      message: 'Execute setup on server now?',
+      default: true,
+    },
+  ]);
+
+  if (!executeNow) {
+    Logger.br();
+    Logger.info('Setup script saved at: ' + scriptPath);
+    Logger.br();
+    Logger.info('Run manually with:');
+    Logger.command(`scp ${scriptPath} ${host}:~/hostfn-setup.sh`);
+    Logger.command(`ssh ${host} 'bash ~/hostfn-setup.sh'`);
+    return;
+  }
+
+  Logger.br();
+  Logger.section('Executing Setup on Server');
+  Logger.br();
+
+  const connectSpinner = ora('Connecting to server...').start();
+
+  try {
+    // Connect to server
+    const ssh = await createSSHConnection(host, {
+      password: options.password,
+    });
+
+    connectSpinner.succeed('Connected to server');
+
+    // Upload setup script
+    const uploadSpinner = ora('Uploading setup script...').start();
+    await ssh.uploadFile(scriptPath, '/tmp/hostfn-setup.sh');
+    uploadSpinner.succeed('Setup script uploaded');
+
+    // Make script executable
+    await ssh.exec('chmod +x /tmp/hostfn-setup.sh');
+
+    // Execute setup script with streaming output
+    Logger.br();
+    Logger.info('Executing setup (this may take several minutes)...');
+    Logger.br();
+
+    const result = await ssh.exec('bash /tmp/hostfn-setup.sh', {
+      streaming: true,
+      skipNvmSetup: true, // Setup script installs nvm, so skip the nvm check
+    });
+
+    Logger.br();
+
+    if (result.exitCode === 0) {
+      Logger.success('Server setup completed successfully!');
+      Logger.br();
+      Logger.info('Your server is ready for deployments.');
+      Logger.br();
+      Logger.info('Next steps:');
+      Logger.br();
+      Logger.info('1. Set environment variables (if needed):');
+      Logger.command(`hostfn env push ${options.env} .env`);
+      Logger.info('   Or set individual variables:');
+      Logger.command(`hostfn env set ${options.env} KEY value`);
+      Logger.br();
+      Logger.info('2. Deploy your application:');
+      Logger.command(`hostfn deploy ${options.env}`);
+    } else {
+      Logger.error('Setup failed with exit code: ' + result.exitCode);
+      Logger.br();
+      
+      // Try to download the log file from the server
+      try {
+        const localLogPath = join(tmpdir(), `hostfn-setup-error-${Date.now()}.log`);
+        await ssh.downloadFile('/tmp/hostfn-setup.log', localLogPath);
+        Logger.info('Setup log downloaded to: ' + localLogPath);
+        Logger.br();
+        
+        // Read and display the last 50 lines of the log
+        const logContent = require('fs').readFileSync(localLogPath, 'utf-8');
+        const lines = logContent.split('\n');
+        const relevantLines = lines.slice(-50).join('\n');
+        
+        Logger.error('Last 50 lines of setup log:');
+        Logger.log(relevantLines);
+      } catch (logError) {
+        Logger.warn('Could not download setup log from server');
+        
+        if (result.stderr) {
+          Logger.br();
+          Logger.error('Stderr output:');
+          Logger.log(result.stderr);
+        }
+        if (result.stdout) {
+          Logger.br();
+          Logger.error('Stdout output (last 1000 chars):');
+          Logger.log(result.stdout.slice(-1000));
+        }
+      }
+      
+      Logger.br();
+      Logger.info('To inspect the full log on the server, run:');
+      Logger.command(`ssh ${host} 'cat /tmp/hostfn-setup.log'`);
+      
+      process.exit(1);
+    }
+
+    // Cleanup
+    await ssh.exec('rm /tmp/hostfn-setup.sh').catch(() => {});
+    ssh.disconnect();
+
+  } catch (error) {
+    connectSpinner.fail('Setup failed');
+    Logger.error(error instanceof Error ? error.message : String(error));
+    Logger.br();
+    Logger.info('Setup script saved at: ' + scriptPath);
+    Logger.info('You can try running it manually:');
+    Logger.command(`scp ${scriptPath} ${host}:~/hostfn-setup.sh`);
+    Logger.command(`ssh ${host} 'bash ~/hostfn-setup.sh'`);
+    process.exit(1);
+  }
+}