hostfn 0.1.0

package/packages/cli/src/runtimes/nodejs/detector.ts

@@ -0,0 +1,157 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { RuntimeDetectionResult } from '../base.js';
+
+interface PackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+  engines?: {
+    node?: string;
+  };
+}
+
+export class NodeJSDetector {
+  /**
+   * Detect Node.js project
+   */
+  static async detect(cwd: string): Promise<RuntimeDetectionResult> {
+    const packageJsonPath = resolve(cwd, 'package.json');
+
+    if (!existsSync(packageJsonPath)) {
+      return {
+        detected: false,
+        confidence: 0,
+      };
+    }
+
+    try {
+      const content = readFileSync(packageJsonPath, 'utf-8');
+      const pkg: PackageJson = JSON.parse(content);
+
+      // Determine framework
+      const framework = this.detectFramework(pkg);
+      const packageManager = this.detectPackageManager(cwd);
+      const version = this.detectNodeVersion(pkg);
+
+      return {
+        detected: true,
+        confidence: 100, // package.json exists = 100% Node.js
+        version,
+        framework,
+        packageManager,
+        metadata: {
+          hasTypeScript: this.hasTypeScript(pkg),
+          hasScripts: Object.keys(pkg.scripts || {}).length > 0,
+          dependencies: Object.keys(pkg.dependencies || {}).length,
+        },
+      };
+    } catch (error) {
+      return {
+        detected: false,
+        confidence: 0,
+      };
+    }
+  }
+
+  /**
+   * Detect framework from dependencies
+   */
+  private static detectFramework(pkg: PackageJson): string | undefined {
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+
+    // Check for common frameworks (order matters - more specific first)
+    if (allDeps['next']) return 'next';
+    if (allDeps['@nestjs/core']) return 'nestjs';
+    if (allDeps['hono']) return 'hono';
+    if (allDeps['fastify']) return 'fastify';
+    if (allDeps['express']) return 'express';
+    if (allDeps['koa']) return 'koa';
+    if (allDeps['@hapi/hapi']) return 'hapi';
+
+    return 'generic';
+  }
+
+  /**
+   * Detect package manager
+   */
+  private static detectPackageManager(cwd: string): string {
+    if (existsSync(resolve(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (existsSync(resolve(cwd, 'yarn.lock'))) return 'yarn';
+    if (existsSync(resolve(cwd, 'package-lock.json'))) return 'npm';
+    return 'npm'; // default
+  }
+
+  /**
+   * Detect Node.js version from engines
+   */
+  private static detectNodeVersion(pkg: PackageJson): string | undefined {
+    if (!pkg.engines?.node) return undefined;
+
+    // Parse version constraint (>=18.0.0 -> 18)
+    const match = pkg.engines.node.match(/(\d+)/);
+    return match ? match[1] : undefined;
+  }
+
+  /**
+   * Check if project uses TypeScript
+   */
+  private static hasTypeScript(pkg: PackageJson): boolean {
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+    return 'typescript' in allDeps;
+  }
+
+  /**
+   * Extract build command from package.json
+   */
+  static getBuildCommand(pkg: PackageJson): string | undefined {
+    const scripts = pkg.scripts || {};
+    
+    // Common build script names
+    if (scripts.build) return 'npm run build';
+    if (scripts.compile) return 'npm run compile';
+    if (scripts['build:prod']) return 'npm run build:prod';
+    
+    return undefined;
+  }
+
+  /**
+   * Extract start command from package.json
+   */
+  static getStartCommand(pkg: PackageJson): string {
+    const scripts = pkg.scripts || {};
+    
+    // Common start script names
+    if (scripts.start) return 'npm start';
+    if (scripts['start:prod']) return 'npm run start:prod';
+    
+    // Fallback: node entry point
+    return 'node dist/index.js';
+  }
+
+  /**
+   * Read package.json
+   */
+  static readPackageJson(cwd: string): PackageJson | null {
+    const packageJsonPath = resolve(cwd, 'package.json');
+    
+    if (!existsSync(packageJsonPath)) {
+      return null;
+    }
+
+    try {
+      const content = readFileSync(packageJsonPath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+}

package/packages/cli/src/runtimes/nodejs/index.ts

@@ -0,0 +1,228 @@
+import {
+  BaseRuntimeAdapter,
+  RuntimeDetectionResult,
+  RuntimeConfig,
+  SetupOptions,
+  ProcessManager,
+} from '../base.js';
+import { Runtime } from '../../config/schema.js';
+import { NodeJSDetector } from './detector.js';
+import { PM2Manager } from './pm2.js';
+
+/**
+ * Node.js runtime adapter
+ */
+export class NodeJSAdapter extends BaseRuntimeAdapter {
+  readonly name: Runtime = 'nodejs';
+  private pm2Manager = new PM2Manager();
+
+  async detect(cwd: string): Promise<RuntimeDetectionResult> {
+    return NodeJSDetector.detect(cwd);
+  }
+
+  async getDefaultConfig(cwd: string): Promise<Partial<RuntimeConfig>> {
+    const pkg = NodeJSDetector.readPackageJson(cwd);
+    
+    if (!pkg) {
+      throw new Error('package.json not found');
+    }
+
+    const buildCommand = NodeJSDetector.getBuildCommand(pkg);
+    const startCommand = NodeJSDetector.getStartCommand(pkg);
+
+    return {
+      name: pkg.name || 'my-app',
+      runtime: 'nodejs',
+      version: pkg.engines?.node?.match(/\d+/)?.[0] || '18',
+      build: buildCommand ? {
+        command: buildCommand,
+        directory: 'dist',
+      } : undefined,
+      start: {
+        command: startCommand,
+        entry: 'dist/index.js',
+      },
+    };
+  }
+
+  generateSetupScript(version: string, options: SetupOptions = {}): string {
+    const port = options.port || 3000;
+    const env = options.environment || 'production';
+    const installRedis = options.installRedis ?? false;
+
+    return `#!/bin/bash
+set -e
+
+# Log everything to file
+LOG_FILE="/tmp/hostfn-setup.log"
+exec > >(tee -a "$LOG_FILE") 2>&1
+echo "[$(date)] Starting hostfn setup..."
+
+echo "=========================================="
+echo "Node.js Server Setup (hostfn)"
+echo "Environment: ${env}"
+echo "=========================================="
+
+# Detect OS
+if [ -f /etc/os-release ]; then
+    . /etc/os-release
+    OS=$NAME
+    VER=$VERSION_ID
+    echo "Detected OS: $OS $VER"
+fi
+
+# 1. Install Node.js via nvm
+echo ""
+echo "[1/7] Installing Node.js v${version} via nvm..."
+if [ ! -d "$HOME/.nvm" ]; then
+    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
+    export NVM_DIR="$HOME/.nvm"
+    [ -s "$NVM_DIR/nvm.sh" ] && \\. "$NVM_DIR/nvm.sh"
+    
+    nvm install ${version}
+    nvm use ${version}
+    nvm alias default ${version}
+    echo "Node.js $(node --version) installed"
+else
+    echo "nvm already installed"
+    source "$HOME/.nvm/nvm.sh"
+    nvm install ${version}
+    nvm use ${version}
+fi
+
+# 2. Install PM2
+echo ""
+echo "[2/7] Installing PM2 process manager..."
+npm install -g pm2
+pm2 --version
+
+# 3. Install system dependencies
+echo ""
+echo "[3/7] Installing system dependencies..."
+if command -v apt-get &> /dev/null; then
+    sudo apt-get update
+    sudo apt-get install -y nginx certbot python3-certbot-nginx rsync curl git build-essential
+elif command -v yum &> /dev/null; then
+    sudo yum install -y nginx certbot python3-certbot-nginx rsync git gcc-c++ make
+elif command -v dnf &> /dev/null; then
+    sudo dnf install -y nginx certbot python3-certbot-nginx rsync curl git gcc-c++ make
+fi
+
+# 4. Configure Nginx
+echo ""
+echo "[4/7] Configuring Nginx..."
+if [ -d "/etc/nginx/sites-available" ]; then
+    NGINX_CONFIG="/etc/nginx/sites-available/hostfn-${env}"
+    sudo tee $NGINX_CONFIG > /dev/null <<'EOF'
+server {
+    listen 80;
+    server_name _;
+
+    location / {
+        proxy_pass http://localhost:${port};
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+        proxy_read_timeout 60s;
+        proxy_connect_timeout 60s;
+    }
+}
+EOF
+    sudo ln -sf $NGINX_CONFIG /etc/nginx/sites-enabled/hostfn-${env}
+elif [ -d "/etc/nginx/conf.d" ]; then
+    NGINX_CONFIG="/etc/nginx/conf.d/hostfn-${env}.conf"
+    sudo tee $NGINX_CONFIG > /dev/null <<'EOF'
+server {
+    listen 80 default_server;
+    server_name _;
+
+    location / {
+        proxy_pass http://localhost:${port};
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+}
+EOF
+fi
+
+sudo nginx -t
+sudo systemctl restart nginx
+sudo systemctl enable nginx
+
+${installRedis ? `
+# 5. Install Redis (optional)
+echo ""
+echo "[5/7] Installing Redis..."
+if command -v apt-get &> /dev/null; then
+    sudo apt-get install -y redis-server
+    sudo systemctl enable redis-server
+    sudo systemctl start redis-server
+elif command -v yum &> /dev/null; then
+    sudo yum install -y redis
+    sudo systemctl enable redis
+    sudo systemctl start redis
+fi
+` : `
+# 5. Skip Redis installation
+echo ""
+echo "[5/7] Skipping Redis installation..."
+`}
+
+# 6. Create deployment directories
+echo ""
+echo "[6/7] Creating deployment directories..."
+sudo mkdir -p /var/www
+sudo chown -R $USER:$USER /var/www
+mkdir -p /var/log/pm2
+
+# 7. Configure PM2 startup
+echo ""
+echo "[7/7] Configuring PM2 startup..."
+PM2_STARTUP_CMD=$(pm2 startup | grep 'sudo' | tail -n 1)
+if [ -n "$PM2_STARTUP_CMD" ]; then
+    eval "$PM2_STARTUP_CMD" || echo "PM2 startup configured"
+else
+    echo "PM2 startup already configured or not needed"
+fi
+pm2 save
+
+# 8. Firewall setup
+echo ""
+echo "[8/7] Configuring firewall..."
+if command -v ufw &> /dev/null; then
+    sudo ufw allow 22/tcp
+    sudo ufw allow 80/tcp
+    sudo ufw allow 443/tcp
+    sudo ufw --force enable
+fi
+
+echo ""
+echo "=========================================="
+echo "✅ Server setup complete!"
+echo "=========================================="
+echo "Node.js: $(node --version)"
+echo "npm: $(npm --version)"
+echo "PM2: $(pm2 --version)"
+echo "Nginx: Running"
+echo "Port: ${port}"
+echo "=========================================="
+echo "[$(date)] Setup completed successfully"
+echo "Log saved to: $LOG_FILE"
+`;
+  }
+
+  getProcessManager(): ProcessManager {
+    return this.pm2Manager;
+  }
+}

package/packages/cli/src/runtimes/nodejs/pm2.ts

@@ -0,0 +1,71 @@
+import { ProcessManager, RuntimeConfig } from '../base.js';
+
+/**
+ * PM2 process manager for Node.js
+ */
+export class PM2Manager implements ProcessManager {
+  readonly name = 'pm2';
+
+  generateStartCommand(config: RuntimeConfig, environment: string): string {
+    const serviceName = `${config.name}-${environment}`;
+    const entry = config.start.entry || 'dist/index.js';
+    
+    return `pm2 start ${entry} --name ${serviceName} -i max --env ${environment}`;
+  }
+
+  generateReloadCommand(serviceName: string): string {
+    return `pm2 reload ${serviceName} --update-env`;
+  }
+
+  generateStopCommand(serviceName: string): string {
+    return `pm2 stop ${serviceName}`;
+  }
+
+  generateStatusCommand(serviceName: string): string {
+    return `pm2 list | grep ${serviceName}`;
+  }
+
+  generateLogsCommand(serviceName: string, lines: number = 100): string {
+    return `pm2 logs ${serviceName} --lines ${lines}`;
+  }
+
+  /**
+   * Generate PM2 ecosystem config file content
+   */
+  generateEcosystemConfig(config: RuntimeConfig, environment: string, envVars: Record<string, string> = {}): string {
+    const serviceName = `${config.name}-${environment}`;
+    const entry = config.start.entry || 'dist/index.js';
+    
+    // Merge base env with provided env vars
+    const allEnv = {
+      NODE_ENV: environment,
+      PORT: config.port || 3000,
+      ...envVars
+    };
+    
+    // Generate env object string
+    const envString = Object.entries(allEnv)
+      .map(([key, value]) => `      ${key}: ${JSON.stringify(value)}`)
+      .join(',\n');
+    
+    return `module.exports = {
+  apps: [{
+    name: '${serviceName}',
+    script: '${entry}',
+    instances: 'max',
+    exec_mode: 'cluster',
+    env: {
+${envString}
+    },
+    error_file: './logs/err.log',
+    out_file: './logs/out.log',
+    time: true,
+    autorestart: true,
+    max_restarts: 10,
+    min_uptime: '10s',
+    max_memory_restart: '1G'
+  }]
+};
+`;
+  }
+}

package/packages/cli/src/runtimes/registry.ts

@@ -0,0 +1,76 @@
+import { Runtime } from '../config/schema.js';
+import { RuntimeAdapter } from './base.js';
+
+/**
+ * Runtime adapter registry
+ * Manages all available runtime adapters
+ */
+export class RuntimeRegistry {
+  private static adapters = new Map<Runtime, RuntimeAdapter>();
+
+  /**
+   * Register a runtime adapter
+   */
+  static register(adapter: RuntimeAdapter): void {
+    this.adapters.set(adapter.name, adapter);
+  }
+
+  /**
+   * Get runtime adapter by name
+   */
+  static get(runtime: Runtime): RuntimeAdapter {
+    const adapter = this.adapters.get(runtime);
+    if (!adapter) {
+      throw new Error(
+        `Runtime adapter not found: ${runtime}\n` +
+        `Available runtimes: ${Array.from(this.adapters.keys()).join(', ')}`
+      );
+    }
+    return adapter;
+  }
+
+  /**
+   * Get all registered adapters
+   */
+  static getAll(): RuntimeAdapter[] {
+    return Array.from(this.adapters.values());
+  }
+
+  /**
+   * Check if runtime is supported
+   */
+  static has(runtime: Runtime): boolean {
+    return this.adapters.has(runtime);
+  }
+
+  /**
+   * Auto-detect runtime in project directory
+   */
+  static async detect(cwd: string): Promise<{
+    runtime: Runtime;
+    adapter: RuntimeAdapter;
+    confidence: number;
+  } | null> {
+    const results = await Promise.all(
+      Array.from(this.adapters.values()).map(async (adapter) => {
+        const result = await adapter.detect(cwd);
+        return {
+          runtime: adapter.name,
+          adapter,
+          ...result,
+        };
+      })
+    );
+
+    // Sort by confidence and get the best match
+    const sorted = results
+      .filter(r => r.detected)
+      .sort((a, b) => b.confidence - a.confidence);
+
+    if (sorted.length === 0) {
+      return null;
+    }
+
+    return sorted[0];
+  }
+}

package/packages/cli/src/utils/logger.ts

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+
+export class Logger {
+  /**
+   * Log info message
+   */
+  static info(message: string): void {
+    console.log(chalk.blue('ℹ'), message);
+  }
+
+  /**
+   * Log success message
+   */
+  static success(message: string): void {
+    console.log(chalk.green('✓'), message);
+  }
+
+  /**
+   * Log warning message
+   */
+  static warn(message: string): void {
+    console.log(chalk.yellow('⚠'), message);
+  }
+
+  /**
+   * Log error message
+   */
+  static error(message: string): void {
+    console.log(chalk.red('✗'), message);
+  }
+
+  /**
+   * Log step message (with emoji)
+   */
+  static step(emoji: string, message: string): void {
+    console.log(emoji, chalk.bold(message));
+  }
+
+  /**
+   * Log header/title
+   */
+  static header(message: string): void {
+    console.log();
+    console.log(chalk.bold.cyan('='.repeat(50)));
+    console.log(chalk.bold.cyan(message));
+    console.log(chalk.bold.cyan('='.repeat(50)));
+    console.log();
+  }
+
+  /**
+   * Log section
+   */
+  static section(message: string): void {
+    console.log();
+    console.log(chalk.bold(message));
+    console.log(chalk.gray('-'.repeat(message.length)));
+  }
+
+  /**
+   * Log plain message
+   */
+  static log(message: string): void {
+    console.log(message);
+  }
+
+  /**
+   * Log empty line
+   */
+  static br(): void {
+    console.log();
+  }
+
+  /**
+   * Log key-value pair
+   */
+  static kv(key: string, value: string): void {
+    console.log(`  ${chalk.gray(key + ':')} ${value}`);
+  }
+
+  /**
+   * Log command to run
+   */
+  static command(cmd: string): void {
+    console.log(chalk.gray('  $ ') + chalk.cyan(cmd));
+  }
+}