hostfn 0.1.0

package/packages/cli/src/core/sync.ts

@@ -0,0 +1,138 @@
+import { execa } from 'execa';
+import { Logger } from '../utils/logger.js';
+
+export interface SyncOptions {
+  exclude?: string[];
+  include?: string[];
+  dryRun?: boolean;
+  verbose?: boolean;
+}
+
+/**
+ * Sync files to remote server using rsync
+ */
+export class FileSync {
+  /**
+   * Sync local directory to remote server
+   */
+  static async sync(
+    localPath: string,
+    remotePath: string,
+    sshConnection: string, // user@host
+    options: SyncOptions = {}
+  ): Promise<void> {
+    const args = [
+      '-avz', // archive, verbose, compress
+      '--delete', // delete files on remote that don't exist locally
+    ];
+
+    // Handle SSH authentication for CI/CD mode
+    let tempKeyPath: string | undefined;
+    if (process.env.HOSTFN_SSH_KEY) {
+      // CI/CD mode: create temporary key file from base64-encoded env var
+      const { writeFileSync, mkdtempSync } = await import('fs');
+      const { join } = await import('path');
+      const { tmpdir } = await import('os');
+      
+      const tempDir = mkdtempSync(join(tmpdir(), 'hostfn-ssh-'));
+      tempKeyPath = join(tempDir, 'id_rsa');
+      
+      // Decode and write the SSH key
+      const keyBuffer = Buffer.from(process.env.HOSTFN_SSH_KEY, 'base64');
+      writeFileSync(tempKeyPath, keyBuffer, { mode: 0o600 });
+      
+      // Build SSH command with the temporary key
+      const sshCmd = `ssh -i ${tempKeyPath} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o BatchMode=yes`;
+      args.push('-e', sshCmd);
+    } else {
+      // Local mode: use default SSH config (respects ~/.ssh/config and ssh-agent)
+      args.push('-e', 'ssh -o StrictHostKeyChecking=no -o BatchMode=yes');
+    }
+
+    // Add dry-run flag
+    if (options.dryRun) {
+      args.push('--dry-run');
+    }
+
+    // Add exclude patterns
+    if (options.exclude && options.exclude.length > 0) {
+      for (const pattern of options.exclude) {
+        args.push('--exclude', pattern);
+      }
+    }
+
+    // Add include patterns
+    if (options.include && options.include.length > 0) {
+      for (const pattern of options.include) {
+        args.push('--include', pattern);
+      }
+    }
+
+    // Ensure trailing slash on source (rsync behavior)
+    const source = localPath.endsWith('/') ? localPath : `${localPath}/`;
+    const destination = `${sshConnection}:${remotePath}`;
+
+    args.push(source, destination);
+
+    try {
+      const result = await execa('rsync', args, {
+        stdio: options.verbose ? 'inherit' : 'pipe',
+      });
+
+      if (result.exitCode !== 0) {
+        throw new Error(`rsync failed with exit code ${result.exitCode}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        // Check if rsync is not installed
+        if (error.message.includes('ENOENT') || error.message.includes('not found')) {
+          throw new Error(
+            'rsync is not installed on your system.\n' +
+            'Please install it:\n' +
+            '  - macOS: brew install rsync\n' +
+            '  - Ubuntu/Debian: apt-get install rsync\n' +
+            '  - Windows: Install via WSL or use Git Bash'
+          );
+        }
+      }
+      throw error;
+    } finally {
+      // Cleanup temporary key file if it was created
+      if (tempKeyPath) {
+        try {
+          const { unlinkSync, rmdirSync } = await import('fs');
+          const { dirname } = await import('path');
+          unlinkSync(tempKeyPath);
+          rmdirSync(dirname(tempKeyPath));
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if rsync is available
+   */
+  static async isRsyncAvailable(): Promise<boolean> {
+    try {
+      await execa('rsync', ['--version']);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get rsync version
+   */
+  static async getRsyncVersion(): Promise<string> {
+    try {
+      const result = await execa('rsync', ['--version']);
+      const match = result.stdout.match(/rsync\s+version\s+([\d.]+)/);
+      return match ? match[1] : 'unknown';
+    } catch {
+      return 'not installed';
+    }
+  }
+}

package/packages/cli/src/core/workspace.ts

@@ -0,0 +1,180 @@
+import { readFileSync, writeFileSync, existsSync, cpSync, mkdirSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { Logger } from '../utils/logger.js';
+
+interface PackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  workspaces?: string[] | { packages: string[] };
+  scripts?: Record<string, string>;
+}
+
+export class WorkspaceManager {
+  private workspaceRoot: string | null = null;
+  private workspacePackages: Map<string, string> = new Map();
+
+  async detectWorkspace(cwd: string): Promise<boolean> {
+    let currentDir = cwd;
+    const root = resolve('/');
+
+    while (currentDir !== root) {
+      const pkgPath = join(currentDir, 'package.json');
+      
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as PackageJson;
+        
+        if (pkg.workspaces) {
+          this.workspaceRoot = currentDir;
+          await this.indexWorkspacePackages();
+          return true;
+        }
+      }
+      
+      currentDir = dirname(currentDir);
+    }
+
+    return false;
+  }
+
+  private async indexWorkspacePackages(): Promise<void> {
+    if (!this.workspaceRoot) return;
+
+    const rootPkg = this.readPackageJson(this.workspaceRoot);
+    if (!rootPkg?.workspaces) return;
+
+    const workspaces = Array.isArray(rootPkg.workspaces)
+      ? rootPkg.workspaces
+      : rootPkg.workspaces.packages;
+
+    const glob = await import('fast-glob');
+    
+    for (const pattern of workspaces) {
+      const matches = await glob.default(join(this.workspaceRoot, pattern, 'package.json'), {
+        absolute: true,
+      });
+
+      for (const pkgPath of matches) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as PackageJson;
+        if (pkg.name) {
+          this.workspacePackages.set(pkg.name, dirname(pkgPath));
+        }
+      }
+    }
+  }
+
+  getWorkspaceDependencies(servicePath: string): string[] {
+    const pkg = this.readPackageJson(servicePath);
+    if (!pkg) return [];
+
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+
+    const workspaceDeps: string[] = [];
+
+    for (const [depName, depVersion] of Object.entries(allDeps)) {
+      if (depVersion === '*' || depVersion === 'workspace:*' || depVersion.startsWith('workspace:')) {
+        if (this.workspacePackages.has(depName)) {
+          workspaceDeps.push(depName);
+        }
+      }
+    }
+
+    return workspaceDeps;
+  }
+
+  async bundleWorkspaceDependencies(servicePath: string, targetDir: string): Promise<void> {
+    const workspaceDeps = this.getWorkspaceDependencies(servicePath);
+    
+    if (workspaceDeps.length === 0) {
+      return;
+    }
+
+    Logger.info(`Bundling ${workspaceDeps.length} workspace dependencies...`);
+
+    const nodeModulesDir = join(targetDir, 'node_modules');
+    mkdirSync(nodeModulesDir, { recursive: true });
+    
+    for (const depName of workspaceDeps) {
+      const depPath = this.workspacePackages.get(depName);
+      if (!depPath) continue;
+
+      const depPkg = this.readPackageJson(depPath);
+      if (depPkg?.scripts?.build) {
+        Logger.log(`  → Building ${depName}...`);
+        try {
+          const { execSync } = await import('child_process');
+          execSync('npm run build', { cwd: depPath, stdio: 'ignore' });
+        } catch (error) {
+          Logger.warn(`  ⚠ Failed to build ${depName}, bundling as-is`);
+        }
+      }
+
+      const targetDepDir = join(nodeModulesDir, depName);
+      
+      mkdirSync(dirname(targetDepDir), { recursive: true });
+
+      cpSync(depPath, targetDepDir, {
+        recursive: true,
+        filter: (src) => {
+          const relativePath = src.replace(depPath, '');
+          return !relativePath.includes('node_modules') &&
+                 !relativePath.includes('.git');
+        },
+      });
+
+      Logger.log(`  ✓ Bundled ${depName}`);
+    }
+  }
+
+  rewritePackageJson(servicePath: string, targetDir: string): void {
+    const workspaceDeps = this.getWorkspaceDependencies(servicePath);
+    
+    if (workspaceDeps.length === 0) {
+      return;
+    }
+
+    const pkgPath = join(targetDir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as PackageJson;
+
+    if (pkg.dependencies) {
+      for (const depName of workspaceDeps) {
+        if (pkg.dependencies[depName]) {
+          pkg.dependencies[depName] = `file:./node_modules/${depName}`;
+        }
+      }
+    }
+
+    if (pkg.devDependencies) {
+      for (const depName of workspaceDeps) {
+        if (pkg.devDependencies[depName]) {
+          delete pkg.devDependencies[depName];
+        }
+      }
+    }
+
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+  }
+
+  private readPackageJson(dir: string): PackageJson | null {
+    const pkgPath = join(dir, 'package.json');
+    if (!existsSync(pkgPath)) return null;
+    
+    try {
+      return JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  getWorkspaceRoot(): string | null {
+    return this.workspaceRoot;
+  }
+
+  isInWorkspace(): boolean {
+    return this.workspaceRoot !== null;
+  }
+}

package/packages/cli/src/index.ts

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { Logger } from './utils/logger.js';
+import { RuntimeRegistry } from './runtimes/registry.js';
+import { NodeJSAdapter } from './runtimes/nodejs/index.js';
+
+// Register runtime adapters
+RuntimeRegistry.register(new NodeJSAdapter());
+
+const program = new Command();
+
+program
+  .name('hostfn')
+  .description('Universal application deployment CLI')
+  .version('0.1.0');
+
+// Init command
+program
+  .command('init')
+  .description('Initialize hostfn configuration in current project')
+  .action(async () => {
+    try {
+      const { initCommand } = await import('./commands/init.js');
+      await initCommand();
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Server setup command
+program
+  .command('server')
+  .description('Server management commands')
+  .addCommand(
+    new Command('setup')
+      .description('Setup a new server for deployments')
+      .argument('<host>', 'SSH connection string (user@host)')
+      .option('--env <environment>', 'Environment name', 'production')
+      .option('--node-version <version>', 'Node.js version', '20')
+      .option('--port <port>', 'Service port', '3000')
+      .option('--redis', 'Install Redis', false)
+      .option('--password <password>', 'SSH password (if not using key auth)')
+      .action(async (host, options) => {
+        try {
+          const { serverSetupCommand } = await import('./commands/server/setup.js');
+          await serverSetupCommand(host, options);
+        } catch (error) {
+          Logger.error(error instanceof Error ? error.message : String(error));
+          process.exit(1);
+        }
+      })
+  )
+  .addCommand(
+    new Command('info')
+      .description('Show server information')
+      .argument('<host>', 'SSH connection string (user@host)')
+      .action(async (host) => {
+        try {
+          const { serverInfoCommand } = await import('./commands/server/info.js');
+          await serverInfoCommand(host);
+        } catch (error) {
+          Logger.error(error instanceof Error ? error.message : String(error));
+          process.exit(1);
+        }
+      })
+  );
+
+// Deploy command
+program
+  .command('deploy')
+  .description('Deploy application to server')
+  .argument('[environment]', 'Environment to deploy to', 'production')
+  .option('--host <host>', 'Override server host')
+  .option('--ci', 'CI/CD mode (non-interactive)', false)
+  .option('--local', 'Local deployment mode (skip SSH, for self-hosted runners)', false)
+  .option('--dry-run', 'Show what would be deployed without executing', false)
+  .option('--service <name>', 'Deploy specific service in monorepo')
+  .option('--all', 'Deploy all services in monorepo (default behavior)', false)
+  .action(async (environment, options) => {
+    try {
+      const { deployCommand } = await import('./commands/deploy.js');
+      await deployCommand(environment, options);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Logs command
+program
+  .command('logs')
+  .description('View application logs')
+  .argument('[environment]', 'Environment', 'production')
+  .option('--lines <n>', 'Number of lines to show', '100')
+  .option('--errors', 'Show only errors', false)
+  .option('--output <file>', 'Save logs to file')
+  .option('--service <name>', 'View logs for specific service in monorepo')
+  .action(async (environment, options) => {
+    try {
+      const { logsCommand } = await import('./commands/logs.js');
+      await logsCommand(environment, options);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Show application status')
+  .argument('[environment]', 'Environment', 'production')
+  .option('--service <name>', 'Show status for specific service in monorepo')
+  .action(async (environment, options) => {
+    try {
+      const { statusCommand } = await import('./commands/status.js');
+      await statusCommand(environment, options);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Rollback command
+program
+  .command('rollback')
+  .description('Rollback to previous deployment')
+  .argument('[environment]', 'Environment', 'production')
+  .option('--to <timestamp>', 'Rollback to specific backup')
+  .action(async (environment, options) => {
+    try {
+      const { rollbackCommand } = await import('./commands/rollback.js');
+      await rollbackCommand(environment, options);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Expose command
+program
+  .command('expose')
+  .description('Configure Nginx and SSL for deployed services')
+  .argument('[environment]', 'Environment', 'production')
+  .option('--host <host>', 'Override server host')
+  .option('--skip-ssl', 'Skip SSL certificate setup', false)
+  .option('--force', 'Overwrite existing configuration', false)
+  .action(async (environment, options) => {
+    try {
+      const { exposeCommand } = await import('./commands/expose.js');
+      await exposeCommand(environment, options);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Environment variable commands
+const envCommand = program
+  .command('env')
+  .description('Manage environment variables');
+
+envCommand
+  .command('list')
+  .description('List environment variables on server (masked)')
+  .argument('<environment>', 'Environment')
+  .action(async (environment) => {
+    try {
+      const { envListCommand } = await import('./commands/env.js');
+      await envListCommand(environment);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+envCommand
+  .command('set')
+  .description('Set an environment variable')
+  .argument('<environment>', 'Environment')
+  .argument('<key>', 'Variable name')
+  .argument('<value>', 'Variable value')
+  .action(async (environment, key, value) => {
+    try {
+      const { envSetCommand } = await import('./commands/env.js');
+      await envSetCommand(environment, key, value);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+envCommand
+  .command('push')
+  .description('Upload .env file to server')
+  .argument('<environment>', 'Environment')
+  .argument('<file>', 'Local .env file path')
+  .action(async (environment, file) => {
+    try {
+      const { envPushCommand } = await import('./commands/env.js');
+      await envPushCommand(environment, file);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+envCommand
+  .command('pull')
+  .description('Download .env file from server')
+  .argument('<environment>', 'Environment')
+  .argument('<file>', 'Local file path to save to')
+  .action(async (environment, file) => {
+    try {
+      const { envPullCommand } = await import('./commands/env.js');
+      await envPullCommand(environment, file);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+envCommand
+  .command('validate')
+  .description('Validate required environment variables exist')
+  .argument('<environment>', 'Environment')
+  .action(async (environment) => {
+    try {
+      const { envValidateCommand } = await import('./commands/env.js');
+      await envValidateCommand(environment);
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Parse CLI arguments
+program.parse(process.argv);

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

@@ -0,0 +1,144 @@
+import { Runtime } from '../config/schema.js';
+
+/**
+ * Base interface for runtime adapters
+ * Each runtime (Node.js, Python, Go, etc.) implements this interface
+ */
+export interface RuntimeAdapter {
+  /**
+   * Runtime identifier
+   */
+  readonly name: Runtime;
+
+  /**
+   * Detect if this runtime is used in the project
+   * @param cwd Project directory
+   * @returns Detection result with confidence score
+   */
+  detect(cwd: string): Promise<RuntimeDetectionResult>;
+
+  /**
+   * Get default configuration for this runtime
+   * @param cwd Project directory
+   * @returns Partial configuration with smart defaults
+   */
+  getDefaultConfig(cwd: string): Promise<Partial<RuntimeConfig>>;
+
+  /**
+   * Generate server setup script for this runtime
+   * @param version Runtime version
+   * @param options Additional setup options
+   * @returns Shell script content
+   */
+  generateSetupScript(version: string, options?: SetupOptions): string;
+
+  /**
+   * Get process manager command (PM2, systemd, etc.)
+   */
+  getProcessManager(): ProcessManager;
+
+  /**
+   * Validate runtime-specific configuration
+   * @param config Runtime configuration
+   * @returns Validation errors (empty if valid)
+   */
+  validateConfig(config: RuntimeConfig): string[];
+}
+
+/**
+ * Runtime detection result
+ */
+export interface RuntimeDetectionResult {
+  detected: boolean;
+  confidence: number; // 0-100
+  version?: string;
+  framework?: string;
+  packageManager?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Runtime configuration
+ */
+export interface RuntimeConfig {
+  name: string;
+  runtime: Runtime;
+  version: string;
+  build?: {
+    command: string;
+    directory: string;
+  };
+  start: {
+    command: string;
+    entry?: string;
+  };
+  port?: number;
+}
+
+/**
+ * Server setup options
+ */
+export interface SetupOptions {
+  port?: number;
+  environment?: string;
+  installRedis?: boolean;
+  nodeModulesMode?: 'all' | 'production' | 'none';
+}
+
+/**
+ * Process manager interface
+ */
+export interface ProcessManager {
+  name: string;
+  
+  /**
+   * Generate start command
+   */
+  generateStartCommand(config: RuntimeConfig, environment: string): string;
+  
+  /**
+   * Generate reload command (zero-downtime)
+   */
+  generateReloadCommand(serviceName: string): string;
+  
+  /**
+   * Generate stop command
+   */
+  generateStopCommand(serviceName: string): string;
+  
+  /**
+   * Generate status command
+   */
+  generateStatusCommand(serviceName: string): string;
+  
+  /**
+   * Generate logs command
+   */
+  generateLogsCommand(serviceName: string, lines?: number): string;
+}
+
+/**
+ * Abstract base class for runtime adapters
+ */
+export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
+  abstract readonly name: Runtime;
+
+  abstract detect(cwd: string): Promise<RuntimeDetectionResult>;
+  abstract getDefaultConfig(cwd: string): Promise<Partial<RuntimeConfig>>;
+  abstract generateSetupScript(version: string, options?: SetupOptions): string;
+  abstract getProcessManager(): ProcessManager;
+
+  validateConfig(config: RuntimeConfig): string[] {
+    const errors: string[] = [];
+
+    if (!config.name) {
+      errors.push('Application name is required');
+    }
+
+    if (!config.start?.command) {
+      errors.push('Start command is required');
+    }
+
+    return errors;
+  }
+}