vibecarbon 0.1.0

package/src/lib/providers/index.js

@@ -0,0 +1,164 @@
+/**
+ * Cloud Provider Registry
+ *
+ * Provides a unified interface for accessing cloud providers.
+ * Currently supports Hetzner Cloud, with abstraction for future providers.
+ *
+ * To add a new provider:
+ * 1. Create a new provider class extending BaseProvider
+ * 2. Import and register it in PROVIDERS below
+ */
+
+import { BaseProvider } from './base.js';
+import { HetznerProvider } from './hetzner.js';
+
+/**
+ * Registry of available cloud providers
+ * @type {Object<string, typeof BaseProvider>}
+ */
+export const PROVIDERS = {
+  hetzner: HetznerProvider,
+  // Future providers:
+  // digitalocean: DigitalOceanProvider,
+  // vultr: VultrProvider,
+  // linode: LinodeProvider,
+};
+
+/**
+ * Get a provider instance
+ * @param {string} providerName - Provider name (e.g., 'hetzner')
+ * @param {string} apiToken - API token for authentication
+ * @returns {BaseProvider} Provider instance
+ * @throws {Error} If provider not found
+ */
+export function getProvider(providerName, apiToken) {
+  const Provider = PROVIDERS[providerName.toLowerCase()];
+
+  if (!Provider) {
+    const available = Object.keys(PROVIDERS).join(', ');
+    throw new Error(`Unknown provider: ${providerName}. Available providers: ${available}`);
+  }
+
+  return new Provider(apiToken);
+}
+
+/**
+ * Get a provider class (not instantiated)
+ * @param {string} providerName - Provider name
+ * @returns {typeof BaseProvider} Provider class
+ * @throws {Error} If provider not found
+ */
+export function getProviderClass(providerName) {
+  const Provider = PROVIDERS[providerName.toLowerCase()];
+
+  if (!Provider) {
+    const available = Object.keys(PROVIDERS).join(', ');
+    throw new Error(`Unknown provider: ${providerName}. Available providers: ${available}`);
+  }
+
+  return Provider;
+}
+
+/**
+ * List all available providers with their details
+ * @returns {Array<{id: string, name: string, regions: object, serverTypes: object}>}
+ */
+export function listProviders() {
+  return Object.entries(PROVIDERS).map(([id, Provider]) => ({
+    id,
+    name: Provider.NAME,
+    regions: Provider.REGIONS,
+    serverTypes: Provider.SERVER_TYPES,
+    defaultType: Provider.DEFAULT_TYPE,
+    haRegions: Provider.HA_REGIONS,
+  }));
+}
+
+/**
+ * Get list of provider IDs
+ * @returns {string[]}
+ */
+export function getProviderIds() {
+  return Object.keys(PROVIDERS);
+}
+
+/**
+ * Check if a provider exists
+ * @param {string} providerName - Provider name to check
+ * @returns {boolean}
+ */
+export function hasProvider(providerName) {
+  return providerName.toLowerCase() in PROVIDERS;
+}
+
+/**
+ * Get the default provider ID
+ * @returns {string}
+ */
+export function getDefaultProvider() {
+  return 'hetzner';
+}
+
+/**
+ * Validate provider configuration
+ * @param {string} providerName - Provider name
+ * @param {object} config - Configuration to validate
+ * @param {string} [config.region] - Region to validate
+ * @param {string} [config.serverType] - Server type to validate
+ * @returns {{valid: boolean, errors: string[]}}
+ */
+export function validateProviderConfig(providerName, config) {
+  const errors = [];
+
+  const Provider = PROVIDERS[providerName.toLowerCase()];
+  if (!Provider) {
+    return { valid: false, errors: [`Unknown provider: ${providerName}`] };
+  }
+
+  if (config.region && !(config.region in Provider.REGIONS)) {
+    const available = Object.keys(Provider.REGIONS).join(', ');
+    errors.push(`Invalid region "${config.region}". Available regions: ${available}`);
+  }
+
+  if (config.serverType && !(config.serverType in Provider.SERVER_TYPES)) {
+    const available = Object.keys(Provider.SERVER_TYPES).join(', ');
+    errors.push(`Invalid server type "${config.serverType}". Available types: ${available}`);
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Format provider regions for display (e.g., in CLI prompts)
+ * @param {string} providerName - Provider name
+ * @returns {Array<{value: string, label: string}>}
+ */
+export function formatRegionsForSelect(providerName) {
+  const Provider = PROVIDERS[providerName.toLowerCase()];
+  if (!Provider) return [];
+
+  return Object.entries(Provider.REGIONS).map(([id, name]) => ({
+    value: id,
+    label: `${id} - ${name}`,
+  }));
+}
+
+/**
+ * Format provider server types for display
+ * @param {string} providerName - Provider name
+ * @returns {Array<{value: string, label: string, hint: string}>}
+ */
+export function formatServerTypesForSelect(providerName) {
+  const Provider = PROVIDERS[providerName.toLowerCase()];
+  if (!Provider) return [];
+
+  return Object.entries(Provider.SERVER_TYPES).map(([id, spec]) => ({
+    value: id,
+    label: id,
+    hint: `${spec.vcpu} vCPU, ${spec.ram}GB RAM, ${spec.disk}GB SSD - ${spec.price}`,
+  }));
+}
+
+// Re-export base class and providers for direct access
+export { BaseProvider } from './base.js';
+export { HetznerProvider } from './hetzner.js';

package/src/lib/s3.js

@@ -0,0 +1,510 @@
+/**
+ * Vibecarbon Add S3 Command
+ * Adds Hetzner Object Storage (S3) to Supabase Storage backend
+ *
+ * Usage:
+ *   vibecarbon add s3              # Interactive setup
+ *   vibecarbon add s3 --help       # Show help
+ */
+
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as p from '@clack/prompts';
+
+import { c, printBanner } from './colors.js';
+import { hasDockerCompose, loadProjectConfig } from './config.js';
+import { loadManifest, saveManifest } from './project.js';
+import { HetznerS3Provider, sanitizeBucketName } from './providers/hetzner-s3.js';
+import { VERSION } from './version.js';
+
+// Supported S3 providers (will expand when we add more cloud providers)
+const S3_PROVIDERS = {
+  hetzner: {
+    name: 'Hetzner Object Storage',
+    providerClass: HetznerS3Provider,
+  },
+  // Future: digitalocean, vultr, etc.
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Local services directory
+const SERVICES_DIR = join(__dirname, '..', '..', 'services');
+
+// ============================================================================
+// CLI ARGUMENT PARSING
+// ============================================================================
+
+function parseArgs(args) {
+  const parsed = {
+    help: false,
+    region: null,
+    ha: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else if (arg === '--region' || arg === '-r') {
+      parsed.region = nextArg;
+      i++;
+    } else if (arg === '--ha') {
+      parsed.ha = true;
+    }
+  }
+
+  return parsed;
+}
+
+function showHelp() {
+  console.log(`
+${c.bold('Vibecarbon Add S3')} - Add Hetzner Object Storage
+
+${c.bold('USAGE')}
+  vibecarbon add s3 [options]
+
+${c.bold('OPTIONS')}
+  -r, --region <region>  S3 region (fsn1, nbg1, hel1)
+  --ha                   Enable HA mode with cross-region replication
+  -h, --help             Show this help message
+
+${c.bold('EXAMPLES')}
+  ${c.dim('# Interactive setup')}
+  vibecarbon add s3
+
+  ${c.dim('# Specify region')}
+  vibecarbon add s3 --region fsn1
+
+  ${c.dim('# HA setup with cross-region sync')}
+  vibecarbon add s3 --ha
+
+${c.bold('NOTES')}
+  - S3 credentials must be created in Hetzner Console first
+  - Buckets are created automatically based on project name
+  - For HA, buckets are created in two regions with rclone sync
+`);
+}
+
+// ============================================================================
+// ENVIRONMENT UPDATES
+// ============================================================================
+
+function appendS3ToEnv(s3Config, isHA = false) {
+  const envFiles = ['.env.local', '.env'];
+
+  for (const filename of envFiles) {
+    const envPath = join(process.cwd(), filename);
+    if (!existsSync(envPath)) continue;
+
+    const content = readFileSync(envPath, 'utf-8');
+
+    // Check if S3 section already exists
+    if (content.includes('# S3 STORAGE')) {
+      continue;
+    }
+
+    let s3Section;
+    if (isHA) {
+      s3Section = `
+
+# =============================================================================
+# S3 STORAGE (Hetzner Object Storage - HA)
+# =============================================================================
+
+S3_ACCESS_KEY="${s3Config.accessKey}"
+S3_SECRET_KEY="${s3Config.secretKey}"
+S3_PRIMARY_BUCKET="${s3Config.primaryBucket}"
+S3_STANDBY_BUCKET="${s3Config.standbyBucket}"
+S3_PRIMARY_ENDPOINT="${s3Config.primaryEndpoint}"
+S3_STANDBY_ENDPOINT="${s3Config.standbyEndpoint}"
+S3_PRIMARY_REGION="${s3Config.primaryRegion}"
+S3_STANDBY_REGION="${s3Config.standbyRegion}"
+S3_SYNC_INTERVAL="${s3Config.syncInterval || '5'}"
+`;
+    } else {
+      s3Section = `
+
+# =============================================================================
+# S3 STORAGE (Hetzner Object Storage)
+# =============================================================================
+
+S3_ACCESS_KEY="${s3Config.accessKey}"
+S3_SECRET_KEY="${s3Config.secretKey}"
+S3_BUCKET="${s3Config.bucket}"
+S3_ENDPOINT="${s3Config.endpoint}"
+S3_REGION="${s3Config.region}"
+`;
+    }
+
+    writeFileSync(envPath, content.trimEnd() + s3Section);
+  }
+}
+
+// ============================================================================
+// COMPOSE FILE INSTALLATION
+// ============================================================================
+
+function installComposeOverlay(isHA = false) {
+  const srcFile = isHA ? 'docker-compose.s3-ha.yml' : 'docker-compose.s3.yml';
+  const srcPath = join(SERVICES_DIR, 's3', 'compose', srcFile);
+  const destPath = join(process.cwd(), srcFile);
+
+  if (!existsSync(srcPath)) {
+    throw new Error(`Service file not found: ${srcPath}`);
+  }
+
+  copyFileSync(srcPath, destPath);
+  return destPath;
+}
+
+// ============================================================================
+// PACKAGE.JSON SCRIPTS
+// ============================================================================
+
+function updatePackageJsonScripts(isHA = false) {
+  const packageJsonPath = join(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) return;
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+
+  // Detect package manager from packageManager field for cross-script references
+  const pm = packageJson.packageManager?.split('@')[0] || 'pnpm';
+  const run = pm === 'npm' ? 'npm run' : pm;
+
+  if (isHA) {
+    packageJson.scripts['docker:up:s3'] =
+      'docker compose -f docker-compose.yml -f docker-compose.prod.yml -f docker-compose.s3-ha.yml up -d';
+    packageJson.scripts['dev:start:s3'] = `${run} docker:up:s3 && ${run} db:migrate && ${run} dev`;
+  } else {
+    packageJson.scripts['docker:up:s3'] =
+      'docker compose -f docker-compose.yml -f docker-compose.s3.yml up -d';
+    packageJson.scripts['dev:start:s3'] = `${run} docker:up:s3 && ${run} db:migrate && ${run} dev`;
+  }
+
+  writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+
+// ============================================================================
+// INSTRUCTIONS
+// ============================================================================
+
+function showS3Instructions() {
+  const instructions = `
+${c.bold('To use S3 storage, create credentials in Hetzner Console:')}
+
+1. Go to ${c.info('https://console.hetzner.cloud/')}
+2. Select your project (or create one)
+3. Click ${c.bold('Object Storage')} in the sidebar
+4. Click ${c.bold('Create Credentials')}
+5. Copy the ${c.bold('Access Key')} and ${c.bold('Secret Key')} (secret shown only once!)
+`;
+
+  p.note(instructions.trim(), 'Hetzner Object Storage Setup');
+}
+
+// ============================================================================
+// MAIN FLOW
+// ============================================================================
+
+async function addS3(options) {
+  const { project, args } = options;
+  const isHA = args.ha || project.haConfigured;
+  const cloudProvider = project.provider || 'hetzner';
+
+  // Check if the provider's S3 service is supported
+  const s3Provider = S3_PROVIDERS[cloudProvider];
+  if (!s3Provider) {
+    p.log.error(`S3 storage is not yet supported for provider: ${cloudProvider}`);
+    p.log.info('Currently supported: Hetzner Object Storage');
+    p.log.info('Support for DigitalOcean Spaces, Vultr Object Storage coming soon.');
+    return false;
+  }
+
+  const S3ProviderClass = s3Provider.providerClass;
+  const s3ProviderName = s3Provider.name;
+
+  // Check if S3 is already configured
+  const manifest = loadManifest();
+  if (manifest.services?.s3) {
+    p.log.warn('S3 storage is already configured for this project.');
+    return false;
+  }
+
+  // Show provider-specific instructions
+  p.log.info(`Using ${c.bold(s3ProviderName)} (detected from deployment config)`);
+  showS3Instructions();
+
+  // Prompt for credentials
+  const accessKey = await p.text({
+    message: `Enter your ${s3ProviderName} Access Key`,
+    validate: (v) => (v.length < 10 ? 'Access Key is required' : undefined),
+  });
+
+  if (p.isCancel(accessKey)) {
+    p.cancel('Operation cancelled.');
+    return false;
+  }
+
+  const secretKey = await p.password({
+    message: `Enter your ${s3ProviderName} Secret Key`,
+    validate: (v) => (v.length < 10 ? 'Secret Key is required' : undefined),
+  });
+
+  if (p.isCancel(secretKey)) {
+    p.cancel('Operation cancelled.');
+    return false;
+  }
+
+  // Region selection
+  const regionOptions = Object.entries(S3ProviderClass.REGIONS).map(([id, name]) => ({
+    value: id,
+    label: `${id} - ${name}`,
+  }));
+
+  let primaryRegion, standbyRegion;
+
+  if (isHA) {
+    primaryRegion = await p.select({
+      message: 'Select PRIMARY region for S3 bucket',
+      options: regionOptions,
+      initialValue: args.region || 'fsn1',
+    });
+
+    if (p.isCancel(primaryRegion)) {
+      p.cancel('Operation cancelled.');
+      return false;
+    }
+
+    // Filter out primary region for standby selection
+    const standbyOptions = regionOptions.filter((r) => r.value !== primaryRegion);
+    standbyRegion = await p.select({
+      message: 'Select STANDBY region for S3 bucket',
+      options: standbyOptions,
+      initialValue: primaryRegion === 'fsn1' ? 'hel1' : 'fsn1',
+    });
+
+    if (p.isCancel(standbyRegion)) {
+      p.cancel('Operation cancelled.');
+      return false;
+    }
+  } else {
+    primaryRegion = await p.select({
+      message: 'Select region for S3 bucket',
+      options: regionOptions,
+      initialValue: args.region || 'fsn1',
+    });
+
+    if (p.isCancel(primaryRegion)) {
+      p.cancel('Operation cancelled.');
+      return false;
+    }
+  }
+
+  // Validate credentials
+  const s = p.spinner();
+  s.start('Verifying S3 credentials...');
+
+  const provider = new S3ProviderClass(accessKey, secretKey, primaryRegion);
+  const validation = await provider.validateCredentials();
+
+  if (!validation.valid) {
+    s.stop(`Credential validation failed: ${validation.error}`);
+    return false;
+  }
+
+  s.stop('Credentials verified');
+
+  // Create bucket(s)
+  const baseBucketName = sanitizeBucketName(project.projectName);
+
+  let s3Config;
+
+  if (isHA) {
+    // Create primary bucket
+    s.start(`Creating primary bucket: ${baseBucketName}-primary`);
+    const primaryBucket = await provider.createBucket(`${baseBucketName}-primary`);
+
+    if (primaryBucket.created) {
+      s.stop(`Primary bucket created: ${primaryBucket.name}`);
+    } else {
+      s.stop(`Primary bucket exists: ${primaryBucket.name}`);
+    }
+
+    // Configure CORS for primary
+    s.start('Configuring CORS for primary bucket...');
+    await provider.configureCORS(`${baseBucketName}-primary`);
+    s.stop('CORS configured');
+
+    // Create standby bucket in different region
+    const standbyProvider = new S3ProviderClass(accessKey, secretKey, standbyRegion);
+    s.start(`Creating standby bucket: ${baseBucketName}-standby`);
+    const standbyBucket = await standbyProvider.createBucket(`${baseBucketName}-standby`);
+
+    if (standbyBucket.created) {
+      s.stop(`Standby bucket created: ${standbyBucket.name}`);
+    } else {
+      s.stop(`Standby bucket exists: ${standbyBucket.name}`);
+    }
+
+    // Configure CORS for standby
+    s.start('Configuring CORS for standby bucket...');
+    await standbyProvider.configureCORS(`${baseBucketName}-standby`);
+    s.stop('CORS configured');
+
+    s3Config = {
+      accessKey,
+      secretKey,
+      primaryBucket: `${baseBucketName}-primary`,
+      standbyBucket: `${baseBucketName}-standby`,
+      primaryEndpoint: S3ProviderClass.getEndpointForRegion(primaryRegion),
+      standbyEndpoint: S3ProviderClass.getEndpointForRegion(standbyRegion),
+      primaryRegion,
+      standbyRegion,
+      syncInterval: '5',
+    };
+  } else {
+    // Single bucket setup
+    s.start(`Creating bucket: ${baseBucketName}`);
+    const bucket = await provider.createBucket(baseBucketName);
+
+    if (bucket.created) {
+      s.stop(`Bucket created: ${bucket.name}`);
+    } else {
+      s.stop(`Bucket exists: ${bucket.name}`);
+    }
+
+    // Configure CORS
+    s.start('Configuring CORS...');
+    await provider.configureCORS(baseBucketName);
+    s.stop('CORS configured');
+
+    s3Config = {
+      accessKey,
+      secretKey,
+      bucket: baseBucketName,
+      endpoint: provider.getEndpoint(),
+      region: primaryRegion,
+    };
+  }
+
+  // Install compose overlay
+  s.start('Installing docker-compose overlay...');
+  const composeFile = installComposeOverlay(isHA);
+  s.stop(`Created: ${composeFile.replace(`${process.cwd()}/`, '')}`);
+
+  // Update .env files
+  s.start('Updating environment files...');
+  appendS3ToEnv(s3Config, isHA);
+  s.stop('Environment files updated');
+
+  // Update package.json scripts
+  s.start('Adding npm scripts...');
+  updatePackageJsonScripts(isHA);
+  s.stop('Scripts added');
+
+  // Update project manifest
+  manifest.services = manifest.services || {};
+  manifest.services.s3 = {
+    addedAt: new Date().toISOString(),
+    version: '1.0.0',
+    provider: cloudProvider, // Cloud provider (hetzner, digitalocean, etc.)
+    s3Service: s3ProviderName, // S3 service name (Hetzner Object Storage, etc.)
+    ha: isHA,
+    region: primaryRegion,
+    ...(isHA ? { standbyRegion } : {}),
+  };
+  saveManifest(manifest);
+
+  // Show summary
+  if (isHA) {
+    p.note(
+      [
+        `Primary:  ${s3Config.primaryBucket} (${primaryRegion})`,
+        `Standby:  ${s3Config.standbyBucket} (${standbyRegion})`,
+        `Sync:     Every ${s3Config.syncInterval} minutes via rclone`,
+        '',
+        `Endpoint: ${s3Config.primaryEndpoint}`,
+      ].join('\n'),
+      'S3 HA Storage Configured',
+    );
+  } else {
+    p.note(
+      [
+        `Bucket:   ${s3Config.bucket}`,
+        `Region:   ${primaryRegion}`,
+        `Endpoint: ${s3Config.endpoint}`,
+      ].join('\n'),
+      'S3 Storage Configured',
+    );
+  }
+
+  return true;
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main(cliArgs) {
+  const args = parseArgs(cliArgs);
+
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Detect project
+  const projectConfig = loadProjectConfig();
+  if (!projectConfig || !hasDockerCompose()) {
+    p.log.error('Not in a Vibecarbon project directory.');
+    p.log.info('Run this command from within a project created with `vibecarbon create`.');
+    process.exit(1);
+  }
+  const project = { projectName: projectConfig.projectName };
+
+  printBanner();
+  p.intro(`${c.bold('vibecarbon add s3')} ${c.dim(`v${VERSION}`)}`);
+
+  try {
+    const success = await addS3({ project, args });
+
+    if (success) {
+      p.note(
+        ['# Restart services to apply changes:', 'vibecarbon down && vibecarbon up'].join('\n'),
+        'Next steps',
+      );
+      p.outro('S3 storage added successfully!');
+    } else {
+      p.outro('S3 setup was not completed.');
+      process.exit(1);
+    }
+  } catch (error) {
+    p.log.error(`Failed to add S3: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function run(args) {
+  await main(args);
+}
+
+// ============================================================================
+// EXPORTS FOR TESTING
+// ============================================================================
+
+export {
+  appendS3ToEnv,
+  installComposeOverlay,
+  parseArgs,
+  sanitizeBucketName,
+  updatePackageJsonScripts,
+};