vibecarbon 0.1.0

package/src/lib/config.js

@@ -0,0 +1,359 @@
+/**
+ * Project configuration management
+ */
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+
+/**
+ * Sanitize a project name to be a valid hostname
+ * - Extracts base name from paths (../my-app -> my-app)
+ * - Removes invalid characters
+ * - Converts to lowercase
+ * - Ensures doesn't start/end with hyphen
+ *
+ * @param {string} name - Project name to sanitize
+ * @returns {string} - Valid hostname
+ */
+export function sanitizeHostname(name) {
+  if (!name) return 'project';
+
+  // Extract base name from path (handles ../my-app, ./my-app, /path/to/my-app)
+  let sanitized = basename(name);
+
+  // Remove any characters that aren't alphanumeric or hyphens
+  sanitized = sanitized.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+
+  // Remove consecutive hyphens
+  sanitized = sanitized.replace(/-+/g, '-');
+
+  // Remove leading/trailing hyphens
+  sanitized = sanitized.replace(/^-+|-+$/g, '');
+
+  // Ensure it's not empty
+  if (!sanitized) return 'project';
+
+  // Ensure it doesn't exceed hostname limits (63 chars for labels)
+  if (sanitized.length > 63) {
+    sanitized = sanitized.substring(0, 63).replace(/-+$/, '');
+  }
+
+  return sanitized;
+}
+
+/**
+ * Load project configuration from multiple sources
+ * Priority: .vibecarbon.json > .env.local > package.json
+ *
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {object|null} - Project config or null if not found
+ */
+export function loadProjectConfig(cwd = process.cwd()) {
+  // Try to load .vibecarbon.json
+  const configPath = join(cwd, '.vibecarbon.json');
+  if (existsSync(configPath)) {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+
+    // If projectName is missing or empty, try to get it from .env.local or package.json
+    if (!config.projectName) {
+      const envPath = join(cwd, '.env.local');
+      if (existsSync(envPath)) {
+        const envContent = readFileSync(envPath, 'utf-8');
+        for (const line of envContent.split('\n')) {
+          if (line.startsWith('PROJECT_NAME=')) {
+            const rawValue = line.split('=')[1].replace(/^["']|["']$/g, '');
+            config.projectName = sanitizeHostname(rawValue);
+            break;
+          }
+        }
+      }
+
+      // Fall back to package.json name
+      if (!config.projectName) {
+        const pkgPath = join(cwd, 'package.json');
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+          config.projectName = sanitizeHostname(pkg.name);
+        }
+      }
+    }
+
+    // Final fallback - ensure projectName is always set
+    if (!config.projectName) {
+      config.projectName = 'project';
+    }
+
+    return config;
+  }
+
+  // Try to load from .env.local
+  const envPath = join(cwd, '.env.local');
+  if (existsSync(envPath)) {
+    const envContent = readFileSync(envPath, 'utf-8');
+    const config = {
+      projectName: null,
+      secrets: {},
+    };
+
+    for (const line of envContent.split('\n')) {
+      if (line.startsWith('#') || !line.includes('=')) continue;
+      const [key, ...valueParts] = line.split('=');
+      const value = valueParts.join('=').replace(/^["']|["']$/g, '');
+
+      if (key === 'PROJECT_NAME') {
+        config.projectName = sanitizeHostname(value);
+      }
+      config.secrets[key.trim()] = value;
+    }
+
+    // Try to get project name from package.json
+    const pkgPath = join(cwd, 'package.json');
+    if (!config.projectName && existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      config.projectName = sanitizeHostname(pkg.name);
+    }
+
+    // Final fallback - ensure projectName is always set
+    if (!config.projectName) {
+      config.projectName = 'project';
+    }
+
+    return config;
+  }
+
+  // Try package.json as fallback
+  const pkgPath = join(cwd, 'package.json');
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return { projectName: sanitizeHostname(pkg.name), secrets: {} };
+  }
+
+  return null;
+}
+
+/**
+ * Save project configuration to .vibecarbon.json
+ *
+ * @param {object} config - Configuration to save
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ */
+export function saveProjectConfig(config, cwd = process.cwd()) {
+  const configPath = join(cwd, '.vibecarbon.json');
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+/**
+ * Load S3 configuration for a specific environment
+ *
+ * @param {string} envName - Environment name (e.g., 'prod', 'staging')
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {object|null} - S3 config or null if not configured
+ */
+export function loadS3Config(envName, cwd = process.cwd()) {
+  const config = loadProjectConfig(cwd);
+  return config?.environments?.[envName]?.s3 || null;
+}
+
+/**
+ * Load backup configuration for a specific environment
+ *
+ * @param {string} envName - Environment name (e.g., 'prod', 'staging')
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {object|null} - Backup config or null if not configured
+ */
+export function loadBackupConfig(envName, cwd = process.cwd()) {
+  const config = loadProjectConfig(cwd);
+  return config?.environments?.[envName]?.backup || null;
+}
+
+/**
+ * Load backup S3 configuration for a specific environment.
+ * This is the dedicated backup bucket (separate from storage bucket).
+ *
+ * @param {string} envName - Environment name (e.g., 'prod', 'staging')
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {object|null} - Backup S3 config or null if not configured
+ */
+export function loadBackupS3Config(envName, cwd = process.cwd()) {
+  const config = loadProjectConfig(cwd);
+  return config?.environments?.[envName]?.backupS3 || null;
+}
+
+// ============================================================================
+// GLOBAL PROJECT REGISTRY (~/.vibecarbon/projects.json)
+// ============================================================================
+
+const DEFAULT_CONFIG_DIR = join(homedir(), '.vibecarbon');
+
+/**
+ * Ensure the global config directory exists with secure permissions
+ *
+ * @param {string} [configDir] - Config directory (default: ~/.vibecarbon/)
+ */
+function ensureConfigDir(configDir = DEFAULT_CONFIG_DIR) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  }
+}
+
+// ============================================================================
+// GLOBAL CREDENTIAL STORAGE (~/.vibecarbon/credentials.json)
+// ============================================================================
+
+/**
+ * Load saved credentials from ~/.vibecarbon/credentials.json
+ *
+ * @param {string} [configDir] - Config directory for testability
+ * @returns {{ hetzner?: { apiToken: string }, s3?: { accessKey: string, secretKey: string }, cloudflare?: { apiToken: string } }}
+ */
+export function loadCredentials(configDir = DEFAULT_CONFIG_DIR) {
+  const credPath = join(configDir, 'credentials.json');
+  if (!existsSync(credPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(readFileSync(credPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save credentials to ~/.vibecarbon/credentials.json (merges with existing)
+ * File is written with mode 0o600 (owner read/write only).
+ *
+ * @param {object} credentials - Credential object to merge (e.g. { hetzner: { apiToken } })
+ * @param {string} [configDir] - Config directory for testability
+ */
+export function saveCredentials(credentials, configDir = DEFAULT_CONFIG_DIR) {
+  ensureConfigDir(configDir);
+  const credPath = join(configDir, 'credentials.json');
+  const existing = loadCredentials(configDir);
+  const merged = { ...existing, ...credentials };
+  writeFileSync(credPath, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+}
+
+/**
+ * Delete the credentials file
+ *
+ * @param {string} [configDir] - Config directory for testability
+ */
+export function clearCredentials(configDir = DEFAULT_CONFIG_DIR) {
+  const credPath = join(configDir, 'credentials.json');
+  if (existsSync(credPath)) {
+    unlinkSync(credPath);
+  }
+}
+
+/**
+ * Load the global project registry
+ *
+ * @param {string} [configDir] - Config directory for testability
+ * @returns {{ projects: Array<{ name: string, path: string, createdAt: string, updatedAt: string }> }}
+ */
+export function loadGlobalRegistry(configDir = DEFAULT_CONFIG_DIR) {
+  const registryPath = join(configDir, 'projects.json');
+  if (!existsSync(registryPath)) {
+    return { projects: [] };
+  }
+
+  try {
+    const content = readFileSync(registryPath, 'utf-8');
+    const data = JSON.parse(content);
+    if (!Array.isArray(data.projects)) {
+      return { projects: [] };
+    }
+    return data;
+  } catch {
+    return { projects: [] };
+  }
+}
+
+/**
+ * Register (or update) a project in the global registry.
+ * Upserts by resolved absolute path.
+ *
+ * @param {string} name - Project name
+ * @param {string} projectPath - Project directory path
+ * @param {string} [configDir] - Config directory for testability
+ */
+export function registerProject(name, projectPath, configDir = DEFAULT_CONFIG_DIR) {
+  ensureConfigDir(configDir);
+  const absPath = resolve(projectPath);
+  const registry = loadGlobalRegistry(configDir);
+
+  const existing = registry.projects.find((p) => p.path === absPath);
+  const now = new Date().toISOString();
+
+  if (existing) {
+    existing.name = name;
+    existing.updatedAt = now;
+  } else {
+    registry.projects.push({ name, path: absPath, createdAt: now, updatedAt: now });
+  }
+
+  const registryPath = join(configDir, 'projects.json');
+  writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, { mode: 0o600 });
+}
+
+/**
+ * Remove a project from the global registry by path.
+ *
+ * @param {string} projectPath - Project directory path
+ * @param {string} [configDir] - Config directory for testability
+ */
+export function unregisterProject(projectPath, configDir = DEFAULT_CONFIG_DIR) {
+  const absPath = resolve(projectPath);
+  const registry = loadGlobalRegistry(configDir);
+  registry.projects = registry.projects.filter((p) => p.path !== absPath);
+
+  const registryPath = join(configDir, 'projects.json');
+  if (existsSync(join(configDir))) {
+    writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, { mode: 0o600 });
+  }
+}
+
+/**
+ * Remove registry entries where the directory no longer exists.
+ *
+ * @param {string} [configDir] - Config directory for testability
+ */
+export function cleanStaleProjects(configDir = DEFAULT_CONFIG_DIR) {
+  const registry = loadGlobalRegistry(configDir);
+  const before = registry.projects.length;
+  registry.projects = registry.projects.filter((p) => existsSync(p.path));
+
+  if (registry.projects.length !== before) {
+    const registryPath = join(configDir, 'projects.json');
+    writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, { mode: 0o600 });
+  }
+}
+
+// ============================================================================
+// PROJECT DETECTION UTILITIES
+// ============================================================================
+
+/**
+ * Check if docker-compose.yml exists in the given directory
+ *
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {boolean}
+ */
+export function hasDockerCompose(cwd = process.cwd()) {
+  return existsSync(join(cwd, 'docker-compose.yml'));
+}
+
+/**
+ * Check if K8s HA overlay directories exist
+ *
+ * @param {string} [cwd] - Working directory (defaults to process.cwd())
+ * @returns {boolean}
+ */
+export function isHAConfigured(cwd = process.cwd()) {
+  return (
+    existsSync(join(cwd, 'k8s/overlays/production-hel1')) ||
+    existsSync(join(cwd, 'k8s/overlays/production-nbg1'))
+  );
+}

package/src/lib/cost.js

@@ -0,0 +1,103 @@
+/**
+ * Shared cost breakdown utilities for deploy and scale commands.
+ */
+
+import { c } from './colors.js';
+import { HetznerProvider } from './providers/hetzner.js';
+import { parsePrice } from './server-types.js';
+
+/**
+ * Build an itemized cost breakdown for the deployment.
+ * Returns { lines: [{label, cost}], total }.
+ */
+export function buildCostBreakdown({
+  isComposeDeploy,
+  ha,
+  serverType,
+  masterServerType,
+  supabaseServerType,
+  workerServerType,
+  region,
+  services,
+}) {
+  const { INFRA_COSTS, VOLUME_SIZES } = HetznerProvider;
+  const lines = [];
+  let total = 0;
+
+  if (isComposeDeploy) {
+    const price = parsePrice(HetznerProvider.getPrice(serverType, region));
+    if (ha) {
+      const cost = price * 2;
+      lines.push({ label: 'Server:', value: `${serverType} ×2`, cost });
+      total += cost;
+    } else {
+      lines.push({ label: 'Server:', value: serverType, cost: price });
+      total += price;
+    }
+  } else {
+    const regionMultiplier = ha ? 2 : 1;
+    const suffix = ha ? ' ×2' : '';
+
+    const masterPrice = parsePrice(HetznerProvider.getPrice(masterServerType, region));
+    const supabasePrice = parsePrice(HetznerProvider.getPrice(supabaseServerType, region));
+    const workerPrice = parsePrice(HetznerProvider.getPrice(workerServerType, region));
+
+    const masterCost = masterPrice * regionMultiplier;
+    const supabaseCost = supabasePrice * regionMultiplier;
+    const workerCost = workerPrice * regionMultiplier;
+    lines.push({ label: 'Master:', value: `${masterServerType}${suffix}`, cost: masterCost });
+    lines.push({ label: 'Supabase:', value: `${supabaseServerType}${suffix}`, cost: supabaseCost });
+    lines.push({ label: 'Worker:', value: `${workerServerType}${suffix}`, cost: workerCost });
+    total += masterCost + supabaseCost + workerCost;
+
+    // Floating IP
+    const fipCost = INFRA_COSTS.floatingIp * regionMultiplier;
+    lines.push({ label: `Floating IP${suffix}`, cost: fipCost });
+    total += fipCost;
+
+    // CSI Volumes
+    let volumeGb = VOLUME_SIZES.base;
+    if (services.observability) volumeGb += VOLUME_SIZES.observability;
+    if (services.n8n) volumeGb += VOLUME_SIZES.n8n;
+    if (services.metabase) volumeGb += VOLUME_SIZES.metabase;
+    if (services.redis) volumeGb += VOLUME_SIZES.redis;
+    const volumeCost = volumeGb * INFRA_COSTS.volumePerGb * regionMultiplier;
+    lines.push({ label: 'Volumes:', value: `${volumeGb}GB${suffix}`, cost: volumeCost });
+    total += volumeCost;
+  }
+
+  // S3 Object Storage (shared, not multiplied by region)
+  lines.push({ label: 'S3 Backups', cost: INFRA_COSTS.s3MinBucket });
+  total += INFRA_COSTS.s3MinBucket;
+
+  return { lines, total };
+}
+
+/**
+ * Format a cost breakdown into a colored, grid-aligned display string.
+ */
+export function formatCostLines({ lines, total }) {
+  const labelCol = 14;
+  const colWidth = 30;
+  const header = `\n${c.bold('Estimated Monthly Cost')}`;
+
+  const priceWidth = 10;
+
+  const rows = lines.map((item) => {
+    const priceStr = `€${item.cost.toFixed(2)}`.padStart(priceWidth);
+    if (item.value) {
+      const paddedLabel = item.label.padEnd(labelCol);
+      const fullLabel = `${paddedLabel}${c.bold(item.value)}`;
+      // Pad the visible width (without ANSI codes) to colWidth
+      const visibleLen = paddedLabel.length + item.value.length;
+      const gap = Math.max(0, colWidth - visibleLen);
+      return `${fullLabel}${' '.repeat(gap)}${c.bold(priceStr)}`;
+    }
+    return `${item.label.padEnd(colWidth)}${c.bold(priceStr)}`;
+  });
+
+  const separator = c.dim('─'.repeat(colWidth + priceWidth));
+  const totalLine = `${'Est. Total'.padEnd(colWidth)}${c.boldYellow(`€${total.toFixed(2)}/mo`.padStart(priceWidth))}`;
+
+  return [header, ...rows, separator, totalLine].join('\n');
+}

package/src/lib/deploy/bundle.js

@@ -0,0 +1,231 @@
+/**
+ * Local-First Bundle Rendering
+ * Stages all deployment artifacts (Compose files, .env, scripts) into a local temp directory
+ * before any infrastructure is provisioned or network calls are made.
+ */
+
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { escapeDotenv } from '../shell.js';
+
+/**
+ * Render the reconcile.sh script
+ */
+function renderReconcileScript(projectName, composeFlags, isFast = false) {
+  const pullStep = isFast
+    ? ''
+    : `
+# 1. Pull latest images if needed
+echo "Pulling images..."
+docker compose ${composeFlags} pull --quiet --policy missing --ignore-buildable || true
+`;
+
+  return `#!/bin/bash
+set -e
+
+# Declarative Compose Reconciler
+# Generated by Vibecarbon
+
+PROJECT_DIR="/opt/${projectName}"
+cd "$PROJECT_DIR"
+
+echo "Reconciling project: ${projectName}..."
+
+echo "File layout in $(pwd):"
+ls -R | grep ":$" | sed 's/:$//' | xargs -I {} sh -c "echo '{}:' && ls {} | head -n 5"
+
+if [ -f ".env" ]; then
+  echo "Found .env file"
+  # Don't print secrets, but check for existence of keys
+  grep -E "^(S3_BUCKET|PROJECT_NAME|APP_IMAGE)=" .env | sed 's/=.*$/=***/'
+else
+  echo "WARNING: .env file NOT FOUND in $(pwd)"
+fi
+
+${pullStep}
+# 2. Re-create containers if state differs
+echo "Updating containers..."
+docker compose ${composeFlags} up -d --remove-orphans
+
+# 3. Ensure systemd service is active (if applicable)
+if [ -f "/etc/systemd/system/${projectName}.service" ]; then
+  echo "Ensuring systemd service is active..."
+  systemctl daemon-reload
+  systemctl enable "${projectName}.service"
+fi
+
+echo "Reconciliation complete."
+`;
+}
+
+/**
+ * Render the systemd service unit
+ */
+function renderSystemdUnit(projectName, composeFlags, _isFast = false) {
+  return `[Unit]
+Description=Vibecarbon Project: ${projectName}
+After=docker.service
+Requires=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=/opt/${projectName}
+ExecStart=/usr/bin/docker compose ${composeFlags} up -d --remove-orphans
+ExecStop=/usr/bin/docker compose ${composeFlags} down
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+/**
+ * Build the compose files flags string
+ */
+function composeFileFlags(options = {}) {
+  const files = ['-f', 'docker-compose.yml', '-f', 'docker-compose.prod.yml'];
+  if (options.observability) {
+    files.push('-f', 'docker-compose.observability.yml');
+    files.push('-f', 'docker-compose.observability.prod.yml');
+  }
+  if (options.n8n) {
+    files.push('-f', 'docker-compose.n8n.yml', '-f', 'docker-compose.n8n.prod.yml');
+  }
+  if (options.metabase) {
+    files.push('-f', 'docker-compose.metabase.yml', '-f', 'docker-compose.metabase.prod.yml');
+  }
+  if (options.redis) files.push('-f', 'docker-compose.redis.yml');
+  return files.join(' ');
+}
+
+/**
+ * Render the deployment bundle to a local temp directory
+ * @param {string} projectName
+ * @param {object} options
+ * @returns {string} The path to the staged bundle directory
+ */
+export function renderBundle(projectName, options = {}) {
+  const cwd = process.cwd();
+  const stageDir = mkdtempSync(join(tmpdir(), 'vc-deploy-bundle-'));
+
+  // Core Docker files
+  const rootFiles = [
+    'docker-compose.yml',
+    'docker-compose.prod.yml',
+    'Dockerfile',
+    '.dockerignore',
+  ];
+  if (options.observability) {
+    rootFiles.push('docker-compose.observability.yml', 'docker-compose.observability.prod.yml');
+  }
+  if (options.n8n) {
+    rootFiles.push('docker-compose.n8n.yml', 'docker-compose.n8n.prod.yml');
+  }
+  if (options.metabase) {
+    rootFiles.push('docker-compose.metabase.yml', 'docker-compose.metabase.prod.yml');
+  }
+  if (options.redis) rootFiles.push('docker-compose.redis.yml');
+
+  for (const file of rootFiles) {
+    const src = join(cwd, file);
+    if (existsSync(src)) {
+      if (options.verbose) console.log(`[bundle] Copying ${file}`);
+      cpSync(src, join(stageDir, file));
+    }
+  }
+
+  // Render .env locally with overrides
+  const localEnvPath = join(cwd, '.env');
+  let envContent = '';
+  if (existsSync(localEnvPath)) {
+    envContent = readFileSync(localEnvPath, 'utf-8');
+  }
+
+  const envOverrides = { ...(options.envOverrides || {}) };
+  if (options.domain) {
+    envOverrides.DOMAIN = options.domain;
+    envOverrides.ACME_EMAIL = `admin@${options.domain}`;
+    envOverrides.SITE_URL = `https://api.${options.domain}`;
+    envOverrides.SUPABASE_URL = 'http://kong:8000';
+  }
+  if (options.image) {
+    envOverrides.APP_IMAGE = options.image;
+  }
+  if (options.s3) {
+    envOverrides.S3_ACCESS_KEY = options.s3.accessKey;
+    envOverrides.S3_SECRET_KEY = options.s3.secretKey;
+    envOverrides.S3_REGION = options.s3.region;
+    envOverrides.S3_ENDPOINT = options.s3.endpoint;
+    envOverrides.S3_BUCKET = options.s3.bucket;
+  }
+  if (options.backupS3) {
+    envOverrides.S3_BACKUP_BUCKET = options.backupS3.bucket;
+  }
+  if (projectName) {
+    envOverrides.PROJECT_NAME = projectName;
+  }
+
+  // Merge overrides into local copy
+  const lines = envContent.split('\n');
+  const seen = new Set();
+  const merged = lines.map((line) => {
+    const m = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+    if (m && envOverrides[m[1]] !== undefined) {
+      seen.add(m[1]);
+      return `${m[1]}=${escapeDotenv(envOverrides[m[1]])}`;
+    }
+    return line;
+  });
+  for (const [k, v] of Object.entries(envOverrides)) {
+    if (!seen.has(k)) merged.push(`${k}=${escapeDotenv(v)}`);
+  }
+  writeFileSync(join(stageDir, '.env'), merged.join('\n'));
+
+  const isFast = Boolean(options.image?.endsWith(':local'));
+  const flags = composeFileFlags(options);
+  writeFileSync(join(stageDir, 'reconcile.sh'), renderReconcileScript(projectName, flags, isFast), {
+    mode: 0o755,
+  });
+  writeFileSync(
+    join(stageDir, `${projectName}.service`),
+    renderSystemdUnit(projectName, flags, isFast),
+  );
+
+  const copyDirIfExist = (srcDir, destDir) => {
+    const src = join(cwd, srcDir);
+    if (existsSync(src)) {
+      if (options.verbose) console.log(`[bundle] Copying ${srcDir} to ${destDir}`);
+      cpSync(src, join(stageDir, destDir), { recursive: true });
+    } else {
+      if (options.verbose) console.log(`[bundle] Skipping ${srcDir} (not found)`);
+    }
+  };
+
+  copyDirIfExist('db', 'db');
+  copyDirIfExist('volumes/db', 'volumes/db');
+  copyDirIfExist('supabase/migrations', 'supabase/migrations');
+  copyDirIfExist('volumes/kong', 'volumes/kong');
+
+  // volumes/traefik/middlewares.yml
+  const traefikMiddlewares = join(cwd, 'volumes', 'traefik', 'middlewares.yml');
+  if (existsSync(traefikMiddlewares)) {
+    mkdirSync(join(stageDir, 'volumes', 'traefik'), { recursive: true });
+    cpSync(traefikMiddlewares, join(stageDir, 'volumes', 'traefik', 'middlewares.yml'));
+  }
+
+  copyDirIfExist('backup', 'backup');
+  if (options.n8n) copyDirIfExist('volumes/n8n', 'volumes/n8n');
+  if (options.metabase) copyDirIfExist('volumes/metabase', 'volumes/metabase');
+
+  if (options.observability) {
+    copyDirIfExist('prometheus', 'prometheus');
+    copyDirIfExist('grafana', 'grafana');
+    for (const subdir of ['prometheus', 'grafana', 'loki', 'promtail']) {
+      copyDirIfExist(`volumes/${subdir}`, `volumes/${subdir}`);
+    }
+  }
+
+  return stageDir;
+}