hostfn 0.1.0

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

@@ -0,0 +1,149 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { Logger } from '../utils/logger.js';
+import { ConfigLoader } from '../config/loader.js';
+import { createSSHConnection } from '../core/ssh.js';
+import { RuntimeRegistry } from '../runtimes/registry.js';
+
+interface StatusOptions {
+  service?: string;
+}
+
+export async function statusCommand(
+  environment: string,
+  options: StatusOptions = {}
+): Promise<void> {
+  Logger.header(`Status - ${environment}`);
+
+  // Load configuration
+  const config = ConfigLoader.load();
+  const envConfig = config.environments[environment];
+
+  if (!envConfig) {
+    throw new Error(`Environment '${environment}' not found`);
+  }
+
+  // Handle multi-service status
+  if (config.services && Object.keys(config.services).length > 0) {
+    if (options.service) {
+      // Show status for specific service
+      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;
+      await showServiceStatus(
+        `${config.name}-${options.service}-${environment}`,
+        serviceServer,
+        options.service
+      );
+    } else {
+      // Show status for all services
+      Logger.info(`Showing status for all ${Object.keys(config.services).length} services`);
+      Logger.br();
+      
+      for (const serviceName of Object.keys(config.services)) {
+        const serviceConfig = config.services[serviceName];
+        const serviceServer = serviceConfig.server || envConfig.server;
+        await showServiceStatus(
+          `${config.name}-${serviceName}-${environment}`,
+          serviceServer,
+          serviceName
+        );
+        Logger.br();
+      }
+    }
+    return;
+  }
+
+  const serviceName = `${config.name}-${environment}`;
+
+  try {
+    await showServiceStatus(serviceName, envConfig.server);
+  } catch (error) {
+    Logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+async function showServiceStatus(
+  serviceName: string,
+  server: string,
+  displayName?: string
+): Promise<void> {
+  const spinner = ora(`Fetching status for ${displayName || serviceName}...`).start();
+
+  try {
+    const ssh = await createSSHConnection(server);
+    spinner.succeed('Connected');
+
+    Logger.br();
+
+    // Get PM2 service details
+    const result = await ssh.exec(`pm2 jlist | jq '.[] | select(.name=="${serviceName}")'`);
+
+    if (result.stdout.trim()) {
+      const service = JSON.parse(result.stdout);
+      
+      const status = service.pm2_env?.status || 'unknown';
+      const statusColor = status === 'online' ? chalk.green : chalk.red;
+
+      if (displayName) {
+        Logger.section(`Service: ${displayName}`);
+      } else {
+        Logger.section('Service Information');
+      }
+      Logger.kv('Name', service.name);
+      Logger.kv('Status', statusColor(status));
+      Logger.kv('PID', service.pid?.toString() || 'N/A');
+      Logger.kv('Restarts', service.pm2_env?.restart_time?.toString() || '0');
+      Logger.br();
+
+      Logger.section('Resources');
+      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';
+
+      Logger.kv('Memory', memory);
+      Logger.kv('CPU', cpu);
+      Logger.br();
+
+      Logger.section('Timing');
+      if (service.pm2_env?.pm_uptime) {
+        const uptime = Date.now() - service.pm2_env.pm_uptime;
+        Logger.kv('Uptime', formatUptime(uptime));
+      }
+      if (service.pm2_env?.created_at) {
+        Logger.kv('Created', new Date(service.pm2_env.created_at).toLocaleString());
+      }
+      Logger.br();
+
+    } else {
+      Logger.warn(`Service '${serviceName}' not found`);
+      Logger.info('Has the service been deployed?');
+    }
+
+    ssh.disconnect();
+  } catch (error) {
+    spinner.fail('Failed to get status');
+    throw error;
+  }
+}
+
+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 ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}

package/packages/cli/src/config/loader.ts

@@ -0,0 +1,66 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { HostfnConfig, HostfnConfigSchema } from './schema.js';
+
+export class ConfigLoader {
+  private static CONFIG_FILENAME = 'hostfn.config.json';
+
+  /**
+   * Load configuration from file
+   */
+  static load(cwd: string = process.cwd()): HostfnConfig {
+    const configPath = resolve(cwd, this.CONFIG_FILENAME);
+
+    if (!existsSync(configPath)) {
+      throw new Error(
+        `Configuration file not found: ${configPath}\n` +
+        `Run 'hostfn init' to create one.`
+      );
+    }
+
+    try {
+      const content = readFileSync(configPath, 'utf-8');
+      const json = JSON.parse(content);
+      return this.validate(json);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON in config file: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Validate configuration against schema
+   */
+  static validate(config: unknown): HostfnConfig {
+    const result = HostfnConfigSchema.safeParse(config);
+
+    if (!result.success) {
+      const errors = result.error.errors
+        .map(err => `  - ${err.path.join('.')}: ${err.message}`)
+        .join('\n');
+      
+      throw new Error(
+        `Invalid configuration:\n${errors}`
+      );
+    }
+
+    return result.data;
+  }
+
+  /**
+   * Check if config file exists
+   */
+  static exists(cwd: string = process.cwd()): boolean {
+    const configPath = resolve(cwd, this.CONFIG_FILENAME);
+    return existsSync(configPath);
+  }
+
+  /**
+   * Get config file path
+   */
+  static getConfigPath(cwd: string = process.cwd()): string {
+    return resolve(cwd, this.CONFIG_FILENAME);
+  }
+}

package/packages/cli/src/config/schema.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+
+// Runtime types - extensible for future languages
+export const RuntimeSchema = z.enum(['nodejs', 'python', 'go', 'ruby', 'rust', 'docker']);
+export type Runtime = z.infer<typeof RuntimeSchema>;
+
+// Environment configuration
+export const EnvironmentConfigSchema = z.object({
+  server: z.string().describe('SSH connection string (user@host)'),
+  port: z.number().int().positive().describe('Port for the service'),
+  instances: z.union([z.number().int().positive(), z.literal('max')]).default(1),
+  domain: z.union([z.string(), z.array(z.string())]).optional().describe('Domain name(s) for the service - can be a single domain or array of domains'),
+  sslEmail: z.string().email().optional().describe('Email for SSL certificate'),
+});
+
+export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
+
+// Build configuration
+export const BuildConfigSchema = z.object({
+  command: z.string().describe('Build command to run'),
+  directory: z.string().default('dist').describe('Output directory'),
+  nodeModules: z.enum(['all', 'production', 'none']).default('production'),
+}).optional();
+
+export type BuildConfig = z.infer<typeof BuildConfigSchema>;
+
+// Start configuration
+export const StartConfigSchema = z.object({
+  command: z.string().describe('Start command'),
+  entry: z.string().optional().describe('Entry point file'),
+});
+
+export type StartConfig = z.infer<typeof StartConfigSchema>;
+
+// Health check configuration
+export const HealthCheckConfigSchema = z.object({
+  path: z.string().default('/health'),
+  timeout: z.number().int().positive().default(60),
+  retries: z.number().int().positive().default(10),
+  interval: z.number().int().positive().default(3),
+}).optional();
+
+export type HealthCheckConfig = z.infer<typeof HealthCheckConfigSchema>;
+
+// Environment variables configuration
+export const EnvConfigSchema = z.object({
+  required: z.array(z.string()).default([]),
+  optional: z.array(z.string()).default([]),
+});
+
+export type EnvConfig = z.infer<typeof EnvConfigSchema>;
+
+// Sync configuration
+export const SyncConfigSchema = z.object({
+  exclude: z.array(z.string()).default([
+    'node_modules',
+    '.git',
+    '.github',
+    'dist',
+    'build',
+    '.env',
+    '.env.*',
+    '*.log',
+    '.turbo',
+    '.wrangler',
+  ]),
+  include: z.array(z.string()).optional(),
+}).optional();
+
+export type SyncConfig = z.infer<typeof SyncConfigSchema>;
+
+// Backup configuration
+export const BackupConfigSchema = z.object({
+  keep: z.number().int().positive().default(5),
+}).optional();
+
+export type BackupConfig = z.infer<typeof BackupConfigSchema>;
+
+// Service configuration (for monorepos)
+export const ServiceConfigSchema = z.object({
+  port: z.number().int().positive(),
+  path: z.string().describe('Path in monorepo'),
+  domain: z.union([z.string(), z.array(z.string())]).optional().describe('Domain name(s) for this service - can be a single domain or array of domains'),
+  exposePath: z.string().optional().describe('Nginx path prefix (e.g., "/api", "/docs")'),
+  server: z.string().optional().describe('Override server for this service (defaults to environment server)'),
+  instances: z.union([z.number().int().positive(), z.literal('max')]).optional().describe('PM2 instances for this service'),
+});
+
+export type ServiceConfig = z.infer<typeof ServiceConfigSchema>;
+
+// Main configuration schema
+export const HostfnConfigSchema = z.object({
+  name: z.string().describe('Application name'),
+  runtime: RuntimeSchema.describe('Runtime/language'),
+  version: z.string().describe('Runtime version'),
+  
+  environments: z.record(z.string(), EnvironmentConfigSchema)
+    .describe('Environment configurations'),
+  
+  build: BuildConfigSchema,
+  start: StartConfigSchema,
+  health: HealthCheckConfigSchema,
+  env: EnvConfigSchema.default({ required: [], optional: [] }),
+  sync: SyncConfigSchema,
+  backup: BackupConfigSchema,
+  
+  services: z.record(z.string(), ServiceConfigSchema).optional()
+    .describe('Multi-service configuration for monorepos'),
+});
+
+export type HostfnConfig = z.infer<typeof HostfnConfigSchema>;
+
+// Default configuration for new projects
+export const DEFAULT_CONFIG: Partial<HostfnConfig> = {
+  health: {
+    path: '/health',
+    timeout: 60,
+    retries: 10,
+    interval: 3,
+  },
+  env: {
+    required: [],
+    optional: [],
+  },
+  sync: {
+    exclude: [
+      'node_modules',
+      '.git',
+      '.github',
+      'dist',
+      'build',
+      '.env',
+      '.env.*',
+      '*.log',
+    ],
+  },
+  backup: {
+    keep: 5,
+  },
+};

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

@@ -0,0 +1,128 @@
+import { SSHConnection } from './ssh.js';
+import { Logger } from '../utils/logger.js';
+
+export interface BackupOptions {
+  keep?: number;
+}
+
+/**
+ * Backup manager for deployments
+ */
+export class BackupManager {
+  private ssh: SSHConnection;
+  private appDir: string;
+  private backupDir: string;
+
+  constructor(ssh: SSHConnection, appDir: string) {
+    this.ssh = ssh;
+    this.appDir = appDir;
+    this.backupDir = `${appDir}/backups`;
+  }
+
+  /**
+   * Create backup of current deployment
+   */
+  async create(): Promise<string> {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = `${this.backupDir}/${timestamp}`;
+
+    // Create backup directory if it doesn't exist
+    await this.ssh.mkdir(this.backupDir, true);
+
+    // Check if there's anything to backup
+    const distExists = await this.ssh.exists(`${this.appDir}/dist`);
+    
+    if (!distExists) {
+      Logger.warn('No existing deployment to backup');
+      return backupPath;
+    }
+
+    // Create backup
+    const result = await this.ssh.exec(
+      `mkdir -p ${backupPath} && ` +
+      `cp -r ${this.appDir}/dist ${backupPath}/ && ` +
+      `cp ${this.appDir}/package.json ${backupPath}/ 2>/dev/null || true`
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to create backup: ${result.stderr}`);
+    }
+
+    return backupPath;
+  }
+
+  /**
+   * List all backups
+   */
+  async list(): Promise<string[]> {
+    const exists = await this.ssh.exists(this.backupDir);
+    
+    if (!exists) {
+      return [];
+    }
+
+    const result = await this.ssh.exec(`ls -1 ${this.backupDir}`);
+    
+    if (result.exitCode !== 0) {
+      return [];
+    }
+
+    return result.stdout
+      .trim()
+      .split('\n')
+      .filter(line => line.length > 0)
+      .sort()
+      .reverse(); // Most recent first
+  }
+
+  /**
+   * Restore from backup
+   */
+  async restore(backupName: string): Promise<void> {
+    const backupPath = `${this.backupDir}/${backupName}`;
+    
+    // Check if backup exists
+    const exists = await this.ssh.exists(backupPath);
+    
+    if (!exists) {
+      throw new Error(`Backup not found: ${backupName}`);
+    }
+
+    // Restore
+    const result = await this.ssh.exec(
+      `rm -rf ${this.appDir}/dist && ` +
+      `cp -r ${backupPath}/dist ${this.appDir}/`
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to restore backup: ${result.stderr}`);
+    }
+  }
+
+  /**
+   * Clean up old backups (keep only last N)
+   */
+  async cleanup(keep: number = 5): Promise<void> {
+    const backups = await this.list();
+
+    if (backups.length <= keep) {
+      return; // Nothing to clean up
+    }
+
+    const toDelete = backups.slice(keep);
+
+    for (const backup of toDelete) {
+      await this.ssh.exec(`rm -rf ${this.backupDir}/${backup}`);
+    }
+
+    Logger.info(`Cleaned up ${toDelete.length} old backup(s)`);
+  }
+
+  /**
+   * Get most recent backup
+   */
+  async getLatest(): Promise<string | null> {
+    const backups = await this.list();
+    return backups.length > 0 ? backups[0] : null;
+  }
+}

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

@@ -0,0 +1,116 @@
+import { Logger } from '../utils/logger.js';
+
+export interface HealthCheckOptions {
+  url: string;
+  timeout?: number;
+  retries?: number;
+  interval?: number;
+}
+
+export interface HealthCheckResult {
+  healthy: boolean;
+  statusCode?: number;
+  responseTime?: number;
+  error?: string;
+}
+
+/**
+ * Health check utility
+ */
+export class HealthCheck {
+  /**
+   * Check if service is healthy
+   */
+  static async check(options: HealthCheckOptions): Promise<HealthCheckResult> {
+    const timeout = options.timeout || 5000;
+
+    try {
+      const startTime = Date.now();
+      
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(options.url, {
+        signal: controller.signal,
+        headers: {
+          'User-Agent': 'hostfn-health-check',
+        },
+      });
+
+      clearTimeout(timeoutId);
+
+      const responseTime = Date.now() - startTime;
+
+      return {
+        healthy: response.ok,
+        statusCode: response.status,
+        responseTime,
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Poll health endpoint until healthy or max retries reached
+   */
+  static async poll(options: HealthCheckOptions): Promise<boolean> {
+    const retries = options.retries || 10;
+    const interval = options.interval || 3000;
+
+    for (let i = 0; i < retries; i++) {
+      const result = await this.check(options);
+
+      if (result.healthy) {
+        Logger.success(
+          `Health check passed (${result.statusCode}, ${result.responseTime}ms)`
+        );
+        return true;
+      }
+
+      if (i < retries - 1) {
+        Logger.warn(
+          `Health check failed (attempt ${i + 1}/${retries}), retrying in ${interval / 1000}s...`
+        );
+        await this.sleep(interval);
+      }
+    }
+
+    Logger.error(`Health check failed after ${retries} attempts`);
+    return false;
+  }
+
+  /**
+   * Wait for service to be ready
+   */
+  static async waitForReady(
+    options: HealthCheckOptions,
+    onProgress?: (attempt: number) => void
+  ): Promise<boolean> {
+    const retries = options.retries || 10;
+    const interval = options.interval || 3000;
+
+    for (let i = 0; i < retries; i++) {
+      onProgress?.(i + 1);
+
+      const result = await this.check(options);
+
+      if (result.healthy) {
+        return true;
+      }
+
+      if (i < retries - 1) {
+        await this.sleep(interval);
+      }
+    }
+
+    return false;
+  }
+
+  private static sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}

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

@@ -0,0 +1,67 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { mkdir } from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+export interface LocalCommandResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export class LocalExecutor {
+  async connect(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async exec(command: string, options?: {
+    streaming?: boolean;
+    cwd?: string;
+  }): Promise<LocalCommandResult> {
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: options?.cwd,
+        shell: '/bin/bash',
+      });
+
+      return {
+        stdout,
+        stderr,
+        exitCode: 0,
+      };
+    } catch (error: any) {
+      return {
+        stdout: error.stdout || '',
+        stderr: error.stderr || '',
+        exitCode: error.code || 1,
+      };
+    }
+  }
+
+  async uploadFile(localPath: string, remotePath: string): Promise<void> {
+    const { copyFileSync } = await import('fs');
+    copyFileSync(localPath, remotePath);
+  }
+
+  async downloadFile(remotePath: string, localPath: string): Promise<void> {
+    const { copyFileSync } = await import('fs');
+    copyFileSync(remotePath, localPath);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    return existsSync(path);
+  }
+
+  async mkdir(path: string, recursive: boolean = true): Promise<void> {
+    await mkdir(path, { recursive });
+  }
+
+  isConnected(): boolean {
+    return true;
+  }
+
+  disconnect(): void {
+  }
+}