@brewnet/cli 0.0.1

package/dist/chunk-2VWMDHGI.js

@@ -0,0 +1,1393 @@
+#!/usr/bin/env node
+import {
+  configureTunnelIngress,
+  createDnsRecord,
+  deleteDnsRecord,
+  getActiveServiceRoutes,
+  getDnsRecords,
+  getTunnelHealth
+} from "./chunk-JFPHGZ6Z.js";
+import {
+  addExternalLabels,
+  getServiceDefinition,
+  removeExternalLabels
+} from "./chunk-4TJMJZMO.js";
+import {
+  loadState,
+  runRotation,
+  saveState
+} from "./chunk-ZKMWE5AH.js";
+import {
+  DOCKER_COMPOSE_FILENAME,
+  LOG_QUERY_DEFAULT_LIMIT,
+  LOG_QUERY_MAX_LIMIT
+} from "./chunk-HCHY5UIQ.js";
+import {
+  getStackById
+} from "./chunk-SYV6PK3R.js";
+
+// src/services/service-manager.ts
+import { readFileSync, writeFileSync, existsSync, copyFileSync, readdirSync } from "fs";
+import { join, basename } from "path";
+import yaml from "js-yaml";
+var BREWNET_PREFIX = "brewnet";
+function readComposeFile(composePath) {
+  const content = readFileSync(composePath, "utf-8");
+  return yaml.load(content);
+}
+function writeComposeFile(composePath, compose) {
+  const yamlContent = yaml.dump(compose, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+    quotingType: '"',
+    forceQuotes: false
+  });
+  writeFileSync(composePath, yamlContent, "utf-8");
+}
+function backupComposeFile(composePath) {
+  const timestamp = Date.now();
+  let backupPath = `${composePath}.bak.${timestamp}`;
+  const dir = join(composePath, "..");
+  const base = basename(composePath);
+  const existing = readdirSync(dir).filter((f) => f.startsWith(`${base}.bak.`));
+  let suffix = 0;
+  while (existing.includes(basename(backupPath))) {
+    suffix++;
+    backupPath = `${composePath}.bak.${timestamp}.${suffix}`;
+  }
+  copyFileSync(composePath, backupPath);
+  return backupPath;
+}
+function getServiceVolumes(serviceId) {
+  switch (serviceId) {
+    case "traefik":
+      return [
+        "/var/run/docker.sock:/var/run/docker.sock:ro",
+        `${BREWNET_PREFIX}_traefik_certs:/letsencrypt`
+      ];
+    case "gitea":
+      return [`${BREWNET_PREFIX}_gitea_data:/data`];
+    case "postgresql":
+      return [`${BREWNET_PREFIX}_postgres_data:/var/lib/postgresql/data`];
+    case "mysql":
+      return [`${BREWNET_PREFIX}_mysql_data:/var/lib/mysql`];
+    case "redis":
+      return [`${BREWNET_PREFIX}_redis_data:/data`];
+    case "valkey":
+      return [`${BREWNET_PREFIX}_valkey_data:/data`];
+    case "keydb":
+      return [`${BREWNET_PREFIX}_keydb_data:/data`];
+    case "nextcloud":
+      return [`${BREWNET_PREFIX}_nextcloud_data:/var/www/html`];
+    case "minio":
+      return [`${BREWNET_PREFIX}_minio_data:/data`];
+    case "jellyfin":
+      return [
+        `${BREWNET_PREFIX}_jellyfin_config:/config`,
+        `${BREWNET_PREFIX}_jellyfin_media:/media`
+      ];
+    case "openssh-server":
+      return [`${BREWNET_PREFIX}_ssh_config:/config`];
+    case "docker-mailserver":
+      return [
+        `${BREWNET_PREFIX}_mail_data:/var/mail`,
+        `${BREWNET_PREFIX}_mail_state:/var/mail-state`,
+        `${BREWNET_PREFIX}_mail_config:/tmp/docker-mailserver`
+      ];
+    case "pgadmin":
+      return [`${BREWNET_PREFIX}_pgadmin_data:/var/lib/pgadmin`];
+    case "filebrowser":
+      return [
+        `${BREWNET_PREFIX}_filebrowser_data:/srv`,
+        `${BREWNET_PREFIX}_filebrowser_db:/database`
+      ];
+    case "cloudflared":
+      return [];
+    default:
+      return [];
+  }
+}
+function buildServiceBlock(def) {
+  const svc = {
+    image: def.image,
+    container_name: `${BREWNET_PREFIX}-${def.id}`,
+    restart: "unless-stopped",
+    security_opt: ["no-new-privileges:true"],
+    networks: [...def.networks]
+  };
+  const volumes = getServiceVolumes(def.id);
+  if (volumes.length > 0) {
+    svc.volumes = volumes;
+  }
+  if (def.subdomain && def.traefikLabels) {
+    svc.labels = { ...def.traefikLabels };
+  }
+  return svc;
+}
+function extractNamedVolumes(volumeMounts) {
+  const names = [];
+  for (const vol of volumeMounts) {
+    const name = vol.split(":")[0];
+    if (name && !name.startsWith("/") && !name.startsWith(".")) {
+      names.push(name);
+    }
+  }
+  return names;
+}
+async function addService(serviceId, projectPath) {
+  const def = getServiceDefinition(serviceId);
+  if (!def) {
+    return { success: false, error: `Unknown service: ${serviceId}` };
+  }
+  const composePath = join(projectPath, DOCKER_COMPOSE_FILENAME);
+  if (!existsSync(composePath)) {
+    return {
+      success: false,
+      error: `docker-compose.yml not found at ${composePath}`
+    };
+  }
+  const compose = readComposeFile(composePath);
+  if (compose.services && compose.services[serviceId]) {
+    return {
+      success: false,
+      error: `Service "${serviceId}" already exists in compose`
+    };
+  }
+  const backupPath = backupComposeFile(composePath);
+  const serviceBlock = buildServiceBlock(def);
+  if (!compose.services) {
+    compose.services = {};
+  }
+  compose.services[serviceId] = serviceBlock;
+  const volumes = getServiceVolumes(serviceId);
+  const namedVolumes = extractNamedVolumes(volumes);
+  if (namedVolumes.length > 0) {
+    if (!compose.volumes) {
+      compose.volumes = {};
+    }
+    for (const vol of namedVolumes) {
+      if (!(vol in compose.volumes)) {
+        compose.volumes[vol] = null;
+      }
+    }
+  }
+  writeComposeFile(composePath, compose);
+  return { success: true, composePath, backupPath };
+}
+async function removeService(serviceId, projectPath, options) {
+  const composePath = join(projectPath, DOCKER_COMPOSE_FILENAME);
+  if (!existsSync(composePath)) {
+    return {
+      success: false,
+      error: `docker-compose.yml not found at ${composePath}`
+    };
+  }
+  const compose = readComposeFile(composePath);
+  if (!compose.services || !compose.services[serviceId]) {
+    return {
+      success: false,
+      error: `Service "${serviceId}" not found in compose`
+    };
+  }
+  const backupPath = backupComposeFile(composePath);
+  const serviceEntry = compose.services[serviceId];
+  const serviceVolumeMounts = serviceEntry.volumes || [];
+  const namedVolumes = extractNamedVolumes(serviceVolumeMounts);
+  delete compose.services[serviceId];
+  if (options?.purge && compose.volumes && namedVolumes.length > 0) {
+    for (const vol of namedVolumes) {
+      if (vol in compose.volumes) {
+        delete compose.volumes[vol];
+      }
+    }
+  }
+  writeComposeFile(composePath, compose);
+  return { success: true, composePath, backupPath };
+}
+
+// src/utils/log-aggregator.ts
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, basename as basename2 } from "path";
+import { homedir } from "os";
+function parseDuration(input) {
+  const match = input.match(/^(\d+)([hmd])$/);
+  if (match) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const now = Date.now();
+    let ms = 0;
+    switch (unit) {
+      case "h":
+        ms = value * 60 * 60 * 1e3;
+        break;
+      case "m":
+        ms = value * 60 * 1e3;
+        break;
+      case "d":
+        ms = value * 24 * 60 * 60 * 1e3;
+        break;
+    }
+    return new Date(now - ms).toISOString();
+  }
+  const date = new Date(input);
+  if (!isNaN(date.getTime())) {
+    return date.toISOString();
+  }
+  throw new Error(
+    `Invalid time format: '${input}'. Use: 1h, 30m, 1d, or ISO date (2026-03-15)`
+  );
+}
+function readCliLogs(logsDir, since) {
+  if (!existsSync2(logsDir)) return [];
+  const files = readdirSync2(logsDir).filter((f) => /^brewnet-\d{4}-\d{2}-\d{2}\.log$/.test(f)).sort();
+  const sinceDate = since ? since.slice(0, 10) : void 0;
+  const entries = [];
+  for (const file of files) {
+    if (sinceDate) {
+      const fileDate = file.replace("brewnet-", "").replace(".log", "");
+      if (fileDate < sinceDate) continue;
+    }
+    const content = readFileSync2(join2(logsDir, file), "utf-8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (since && parsed.timestamp < since) continue;
+        entries.push({
+          timestamp: parsed.timestamp,
+          source: "cli",
+          level: parsed.level,
+          message: parsed.message,
+          metadata: { command: parsed.command, ...parsed.metadata }
+        });
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function readTunnelLogs(logsDir, since) {
+  const logFile = join2(logsDir, "tunnel.log");
+  if (!existsSync2(logFile)) return [];
+  const content = readFileSync2(logFile, "utf-8");
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (since && parsed.timestamp < since) continue;
+      const metadata = {
+        event: parsed.event,
+        tunnelMode: parsed.tunnelMode
+      };
+      if (parsed.tunnelId) metadata.tunnelId = parsed.tunnelId;
+      if (parsed.tunnelName) metadata.tunnelName = parsed.tunnelName;
+      entries.push({
+        timestamp: parsed.timestamp,
+        source: "tunnel",
+        level: parsed.error ? "error" : "info",
+        service: parsed.domain,
+        message: parsed.detail,
+        metadata
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+function readAccessLogs(projectPath, since) {
+  const logFile = join2(projectPath, "logs", "access.log");
+  if (!existsSync2(logFile)) return [];
+  const content = readFileSync2(logFile, "utf-8");
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (since && parsed.StartUTC < since) continue;
+      let level = "info";
+      if (parsed.OriginStatus >= 500) level = "error";
+      else if (parsed.OriginStatus >= 400) level = "warn";
+      const metadata = {};
+      if (parsed.RouterName) metadata.routerName = parsed.RouterName;
+      if (parsed.ClientAddr) metadata.clientAddr = parsed.ClientAddr;
+      if (parsed.Duration !== void 0) metadata.duration = parsed.Duration;
+      if (parsed.RequestHost) metadata.requestHost = parsed.RequestHost;
+      const userAgent = parsed["request_User-Agent"] ?? parsed.request_User_Agent;
+      if (userAgent) metadata.userAgent = userAgent;
+      const serviceName = parsed.ServiceName?.split("@")[0];
+      entries.push({
+        timestamp: parsed.StartUTC,
+        source: "access",
+        level,
+        service: serviceName,
+        message: `${parsed.RequestMethod} ${parsed.RequestPath} \u2192 ${parsed.OriginStatus}`,
+        metadata
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function readServiceLogs(projectPath, opts) {
+  let Dockerode;
+  try {
+    Dockerode = (await import("dockerode")).default;
+  } catch {
+    return [];
+  }
+  const docker = new Dockerode();
+  const entries = [];
+  try {
+    const containers = await docker.listContainers({ all: false });
+    const projectName = basename2(projectPath).toLowerCase().replace(/[^a-z0-9]/g, "");
+    for (const containerInfo of containers) {
+      const containerName = containerInfo.Names?.[0]?.replace(/^\//, "") ?? containerInfo.Id.slice(0, 12);
+      if (!containerName.toLowerCase().startsWith(projectName)) continue;
+      const container = docker.getContainer(containerInfo.Id);
+      const logOpts = {
+        stdout: true,
+        stderr: true,
+        timestamps: true
+      };
+      if (opts?.tail) logOpts.tail = opts.tail;
+      if (opts?.since) {
+        logOpts.since = Math.floor(new Date(opts.since).getTime() / 1e3);
+      }
+      try {
+        const logBuffer = await container.logs(logOpts);
+        const frames = [];
+        if (Buffer.isBuffer(logBuffer)) {
+          let pos = 0;
+          while (pos + 8 <= logBuffer.length) {
+            const streamType = logBuffer[pos];
+            const payloadSize = logBuffer.readUInt32BE(pos + 4);
+            pos += 8;
+            if (pos + payloadSize > logBuffer.length) break;
+            const payload = logBuffer.subarray(pos, pos + payloadSize).toString("utf-8");
+            frames.push({ stream: streamType, text: payload });
+            pos += payloadSize;
+          }
+        } else {
+          frames.push({ stream: 1, text: String(logBuffer) });
+        }
+        for (const frame of frames) {
+          const level = frame.stream === 2 ? "error" : "info";
+          for (const line of frame.text.split("\n")) {
+            if (!line.trim()) continue;
+            const tsMatch = line.match(
+              /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(.*)/
+            );
+            if (!tsMatch) continue;
+            const timestamp = tsMatch[1].endsWith("Z") ? tsMatch[1] : tsMatch[1] + "Z";
+            const message = tsMatch[2];
+            if (opts?.since && timestamp < opts.since) continue;
+            const serviceName = containerName.replace(new RegExp(`^${projectName}[-_]`), "").replace(/-\d+$/, "");
+            entries.push({
+              timestamp,
+              source: "service",
+              level,
+              service: serviceName,
+              message,
+              metadata: { containerId: containerInfo.Id.slice(0, 12) }
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+async function queryLogs(query, projectPath) {
+  const logsDir = join2(homedir(), ".brewnet", "logs");
+  const since = query.since;
+  const sourcesToRead = query.sources ?? ["cli", "tunnel", "access", "service"];
+  const readers = [];
+  if (sourcesToRead.includes("cli")) {
+    readers.push(Promise.resolve(readCliLogs(logsDir, since)));
+  }
+  if (sourcesToRead.includes("tunnel")) {
+    readers.push(Promise.resolve(readTunnelLogs(logsDir, since)));
+  }
+  if (sourcesToRead.includes("access")) {
+    readers.push(Promise.resolve(readAccessLogs(projectPath, since)));
+  }
+  if (sourcesToRead.includes("service")) {
+    readers.push(readServiceLogs(projectPath, { since }));
+  }
+  const results = await Promise.all(readers);
+  let entries = results.flat();
+  try {
+    runRotation(logsDir, projectPath);
+  } catch {
+  }
+  if (query.levels?.length) {
+    entries = entries.filter((e) => query.levels.includes(e.level));
+  }
+  if (query.services?.length) {
+    entries = entries.filter((e) => e.service && query.services.includes(e.service));
+  }
+  if (query.until) {
+    entries = entries.filter((e) => e.timestamp <= query.until);
+  }
+  if (query.search) {
+    const searchLower = query.search.toLowerCase();
+    entries = entries.filter((e) => e.message.toLowerCase().includes(searchLower));
+  }
+  entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const total = entries.length;
+  const limit = Math.min(query.limit ?? LOG_QUERY_DEFAULT_LIMIT, LOG_QUERY_MAX_LIMIT);
+  const offset = query.offset ?? 0;
+  const paged = entries.slice(offset, offset + limit);
+  return {
+    entries: paged,
+    total,
+    hasMore: offset + limit < total
+  };
+}
+async function getLogStats(projectPath) {
+  const logsDir = join2(homedir(), ".brewnet", "logs");
+  const [cliEntries, tunnelEntries, accessEntries, serviceEntries] = await Promise.all([
+    Promise.resolve(readCliLogs(logsDir)),
+    Promise.resolve(readTunnelLogs(logsDir)),
+    Promise.resolve(readAccessLogs(projectPath)),
+    readServiceLogs(projectPath, {})
+  ]);
+  const allEntries = [...cliEntries, ...tunnelEntries, ...accessEntries, ...serviceEntries];
+  const bySource = { cli: 0, tunnel: 0, access: 0, service: 0 };
+  const byLevel = { info: 0, warn: 0, error: 0, debug: 0 };
+  for (const entry of allEntries) {
+    bySource[entry.source]++;
+    byLevel[entry.level] = (byLevel[entry.level] ?? 0) + 1;
+  }
+  allEntries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const recentErrors = allEntries.filter((e) => e.level === "error").slice(0, 10);
+  return {
+    total: allEntries.length,
+    bySource,
+    byLevel,
+    recentErrors,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/services/backup-manager.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  statSync
+} from "fs";
+import { join as join3 } from "path";
+import { execSync } from "child_process";
+import crypto from "crypto";
+
+// src/utils/errors.ts
+var BrewnetError = class _BrewnetError extends Error {
+  code;
+  httpStatus;
+  remediation;
+  constructor(code, message, httpStatus, remediation) {
+    super(message);
+    this.name = "BrewnetError";
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.remediation = remediation;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Format the error for terminal display.
+   *
+   * Example output:
+   *
+   *   Error [BN001]: Docker daemon is not running
+   *
+   *     Docker is required to manage services. Please start Docker and try again.
+   *
+   *     Fix:
+   *       macOS:  Open Docker Desktop
+   *       Linux:  sudo systemctl start docker
+   */
+  format() {
+    const lines = [
+      `Error [${this.code}]: ${this.message}`,
+      "",
+      `  ${this.remediation}`
+    ];
+    return lines.join("\n");
+  }
+  /**
+   * Serialize the error for structured logging (JSONL).
+   */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      httpStatus: this.httpStatus,
+      remediation: this.remediation
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Factory methods for every Brewnet error code
+  // ---------------------------------------------------------------------------
+  /**
+   * BN001 — Docker daemon is not running (503 Service Unavailable).
+   */
+  static dockerNotRunning() {
+    return new _BrewnetError(
+      "BN001",
+      "Docker daemon is not running",
+      503,
+      [
+        "Docker is required to manage services. Please start Docker and try again.",
+        "",
+        "  Fix:",
+        "    macOS:  Open Docker Desktop",
+        "    Linux:  sudo systemctl start docker"
+      ].join("\n")
+    );
+  }
+  /**
+   * BN002 — Project directory already exists (409 Conflict).
+   */
+  static directoryConflict(name) {
+    return new _BrewnetError(
+      "BN002",
+      `Directory "${name}" already exists`,
+      409,
+      [
+        "The project directory already exists. Choose a different project name or remove it first.",
+        "",
+        "  Fix:",
+        `    rm -rf ${name}          # remove existing directory`,
+        `    brewnet create-app ${name}-v2   # use a different name`
+      ].join("\n")
+    );
+  }
+  /**
+   * BN002 — Port already in use (409 Conflict).
+   */
+  static portConflict(port, processInfo) {
+    const detail = processInfo ? ` (in use by ${processInfo})` : "";
+    return new _BrewnetError(
+      "BN002",
+      `Port ${port} is already in use${detail}`,
+      409,
+      [
+        `Port ${port} is required by one of your selected services.`,
+        "",
+        "  Fix:",
+        `    1. Find the process:  lsof -i :${port}`,
+        `    2. Stop it:           kill <PID>`,
+        "    3. Or choose a different port in your configuration."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN003 — SSL certificate issuance failed (500 Internal Server Error).
+   */
+  static sslFailed(domain) {
+    return new _BrewnetError(
+      "BN003",
+      `SSL certificate issuance failed for ${domain}`,
+      500,
+      [
+        "Let's Encrypt could not issue a certificate. Common causes:",
+        "",
+        "  - DNS records not yet propagated (wait a few minutes and retry)",
+        "  - Domain does not resolve to this server's public IP",
+        "  - Rate limit reached (max 5 duplicates per week)",
+        "",
+        "  Fix:",
+        `    1. Verify DNS:   dig +short ${domain}`,
+        "    2. Retry:        brewnet domain ssl " + domain,
+        "    3. Use Cloudflare Tunnel for automatic SSL instead."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN004 — Invalid license key (401 Unauthorized).
+   */
+  static invalidLicense() {
+    return new _BrewnetError(
+      "BN004",
+      "Invalid or expired license key",
+      401,
+      [
+        "Your Brewnet Pro/Team license key is invalid or has expired.",
+        "",
+        "  Fix:",
+        "    1. Check your key at https://brewnet.dev/account",
+        "    2. Update it:  brewnet config set license <KEY>",
+        "    3. Contact support if the issue persists."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN005 — Rate limit exceeded (429 Too Many Requests).
+   */
+  static rateLimited() {
+    return new _BrewnetError(
+      "BN005",
+      "Rate limit exceeded",
+      429,
+      [
+        "Too many requests in a short period. Please wait and try again.",
+        "",
+        "  Fix:",
+        "    Wait a few minutes before retrying.",
+        "    If using CI, consider adding a delay between requests."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN006 — Boilerplate clone failed (500 Internal Server Error).
+   */
+  static cloneFailed(stackId) {
+    return new _BrewnetError(
+      "BN006",
+      `Failed to clone boilerplate stack "${stackId}"`,
+      500,
+      [
+        "Could not download the boilerplate from GitHub. Common causes:",
+        "",
+        "  - No internet connection",
+        "  - GitHub is temporarily unavailable",
+        "  - The stack branch does not exist on the remote",
+        "",
+        "  Fix:",
+        "    1. Check your internet connection",
+        "    2. Verify connectivity:  curl -I https://github.com",
+        "    3. Retry:  brewnet create-app <name> --stack " + stackId
+      ].join("\n")
+    );
+  }
+  /**
+   * BN006 — Health check timed out after scaffolding (500 Internal Server Error).
+   */
+  static healthCheckTimeout(timeoutSec) {
+    return new _BrewnetError(
+      "BN006",
+      `Application health check timed out after ${timeoutSec}s`,
+      500,
+      [
+        "The application container started but did not respond to health checks in time.",
+        "",
+        "  Containers are still running. To diagnose:",
+        "    docker compose logs backend   # check for startup errors",
+        "    docker compose logs           # check all services",
+        "",
+        "  Fix:",
+        "    1. Check logs for errors (missing env vars, port conflicts, build errors)",
+        '    2. Run "make down" to stop containers',
+        "    3. Retry:  brewnet create-app <name> --stack <STACK_ID>"
+      ].join("\n")
+    );
+  }
+  /**
+   * BN006 — Build failed (500 Internal Server Error).
+   */
+  static buildFailed(logs) {
+    const logSnippet = logs ? `
+
+  Build output (last lines):
+    ${logs.split("\n").slice(-5).join("\n    ")}` : "";
+    return new _BrewnetError(
+      "BN006",
+      "Application build failed",
+      500,
+      [
+        "The build process exited with a non-zero status.",
+        "",
+        "  Fix:",
+        "    1. Check your build command in brewnet.yml",
+        "    2. Run the build locally to reproduce the error",
+        "    3. Review logs:  brewnet logs --build",
+        logSnippet
+      ].join("\n")
+    );
+  }
+  /**
+   * BN007 — Invalid Git repository (400 Bad Request).
+   */
+  static invalidGitRepo(path2) {
+    return new _BrewnetError(
+      "BN007",
+      `Not a valid Git repository: ${path2}`,
+      400,
+      [
+        "The specified path is not a Git repository or is inaccessible.",
+        "",
+        "  Fix:",
+        `    1. Verify the path exists:  ls -la ${path2}`,
+        `    2. Initialize if needed:    git init ${path2}`,
+        "    3. Or clone an existing repo:  git clone <url>"
+      ].join("\n")
+    );
+  }
+  /**
+   * BN008 — Resource not found (404 Not Found).
+   */
+  static resourceNotFound(resource) {
+    return new _BrewnetError(
+      "BN008",
+      `Resource not found: ${resource}`,
+      404,
+      [
+        `The requested resource "${resource}" could not be found.`,
+        "",
+        "  Fix:",
+        "    1. Check the name or ID for typos",
+        "    2. List available resources:  brewnet status",
+        "    3. The resource may have been removed or renamed."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN009 — Database error (500 Internal Server Error).
+   */
+  static databaseError(detail) {
+    return new _BrewnetError(
+      "BN009",
+      `Database error: ${detail}`,
+      500,
+      [
+        "An internal database operation failed.",
+        "",
+        "  Fix:",
+        "    1. Check disk space:  df -h",
+        "    2. Verify DB file permissions:  ls -la ~/.brewnet/db/",
+        "    3. Try resetting the local DB:  brewnet config reset-db",
+        "    4. If the issue persists, file a bug report."
+      ].join("\n")
+    );
+  }
+  /**
+   * BN010 — Feature requires Pro plan (403 Forbidden).
+   */
+  static proRequired(feature) {
+    return new _BrewnetError(
+      "BN010",
+      `"${feature}" requires a Brewnet Pro subscription`,
+      403,
+      [
+        "This feature is available on the Pro plan ($9/mo) or Team plan ($29/mo/server).",
+        "",
+        "  Upgrade:",
+        "    https://brewnet.dev/pricing",
+        "",
+        "  Activate:",
+        "    brewnet config set license <KEY>"
+      ].join("\n")
+    );
+  }
+};
+function isBrewnetError(err) {
+  return err instanceof BrewnetError;
+}
+
+// src/services/backup-manager.ts
+function generateBackupId() {
+  const ts = Date.now();
+  const rand = crypto.randomBytes(3).toString("hex");
+  return `backup-${ts}-${rand}`;
+}
+function deriveProjectName(projectPath) {
+  const segments = projectPath.replace(/\/+$/, "").split("/");
+  return segments[segments.length - 1] || "unknown";
+}
+function buildArchiveFilename(backupId) {
+  return `${backupId}.tar.gz`;
+}
+function createBackup(projectPath, backupsDir) {
+  mkdirSync(backupsDir, { recursive: true });
+  const backupId = generateBackupId();
+  const archiveFilename = buildArchiveFilename(backupId);
+  const archivePath = join3(backupsDir, archiveFilename);
+  const timestamp = Date.now();
+  const parentDir = join3(projectPath, "..");
+  const baseName = deriveProjectName(projectPath);
+  execSync(`tar -czf "${archivePath}" -C "${parentDir}" "${baseName}"`, {
+    stdio: "pipe"
+  });
+  const stats = statSync(archivePath);
+  return {
+    id: backupId,
+    timestamp,
+    path: archivePath,
+    size: stats.size,
+    projectName: baseName
+  };
+}
+function restoreBackup(backupId, backupsDir, projectPath) {
+  const archiveFilename = buildArchiveFilename(backupId);
+  const archivePath = join3(backupsDir, archiveFilename);
+  if (!existsSync3(archivePath)) {
+    throw BrewnetError.resourceNotFound(`backup:${backupId}`);
+  }
+  mkdirSync(projectPath, { recursive: true });
+  execSync(`tar -xzf "${archivePath}" -C "${projectPath}" --strip-components=1`, {
+    stdio: "pipe"
+  });
+}
+function listBackups(backupsDir) {
+  if (!existsSync3(backupsDir)) {
+    return [];
+  }
+  const files = readdirSync3(backupsDir).filter((f) => f.endsWith(".tar.gz"));
+  const records = [];
+  for (const file of files) {
+    const filePath = join3(backupsDir, file);
+    const stats = statSync(filePath);
+    const backupId = file.replace(/\.tar\.gz$/, "");
+    const parts = backupId.split("-");
+    const timestamp = parts.length >= 2 ? parseInt(parts[1], 10) : stats.mtimeMs;
+    let projectName = "unknown";
+    try {
+      const listing = execSync(`tar -tzf "${filePath}" | head -1`, {
+        stdio: "pipe",
+        encoding: "utf-8"
+      }).trim();
+      projectName = listing.replace(/\/$/, "").split("/")[0] || "unknown";
+    } catch {
+    }
+    records.push({
+      id: backupId,
+      timestamp,
+      path: filePath,
+      size: stats.size,
+      projectName
+    });
+  }
+  records.sort((a, b) => b.timestamp - a.timestamp);
+  return records;
+}
+function checkDiskSpace(path2, requiredBytes = 0) {
+  let available;
+  try {
+    const output = execSync(`df -k "${path2}" | tail -1`, {
+      stdio: "pipe",
+      encoding: "utf-8"
+    }).trim();
+    const columns = output.split(/\s+/);
+    const availableKB = parseInt(columns[3], 10);
+    available = availableKB * 1024;
+  } catch {
+    available = 0;
+  }
+  return {
+    available,
+    required: requiredBytes,
+    sufficient: available >= requiredBytes
+  };
+}
+
+// src/services/domain-manager.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execa } from "execa";
+
+// src/services/app-registry.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function readApps(appsJsonPath) {
+  if (!existsSync4(appsJsonPath)) return [];
+  try {
+    return JSON.parse(readFileSync3(appsJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeApps(appsJsonPath, apps) {
+  mkdirSync2(dirname(appsJsonPath), { recursive: true });
+  writeFileSync2(appsJsonPath, JSON.stringify(apps, null, 2), "utf-8");
+}
+function addApp(appsJsonPath, entry) {
+  const apps = readApps(appsJsonPath);
+  if (apps.some((a) => a.name === entry.name)) {
+    throw new Error(`App "${entry.name}" already exists`);
+  }
+  writeApps(appsJsonPath, [...apps, entry]);
+}
+function updateApp(appsJsonPath, name, patch) {
+  const apps = readApps(appsJsonPath);
+  const idx = apps.findIndex((a) => a.name === name);
+  if (idx === -1) throw new Error(`App "${name}" not found`);
+  apps[idx] = { ...apps[idx], ...patch };
+  writeApps(appsJsonPath, apps);
+}
+function removeApp(appsJsonPath, name) {
+  const apps = readApps(appsJsonPath).filter((a) => a.name !== name);
+  writeApps(appsJsonPath, apps);
+}
+function readDeployHistory(historyJsonPath) {
+  if (!existsSync4(historyJsonPath)) return [];
+  try {
+    return JSON.parse(readFileSync3(historyJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function appendDeployHistory(historyJsonPath, entry) {
+  const entries = readDeployHistory(historyJsonPath);
+  mkdirSync2(dirname(historyJsonPath), { recursive: true });
+  writeFileSync2(historyJsonPath, JSON.stringify([...entries, entry], null, 2), "utf-8");
+}
+
+// src/services/domain-manager.ts
+var DomainManager = class {
+  projectName;
+  state;
+  constructor(projectName) {
+    this.projectName = projectName;
+    const loaded = loadState(projectName);
+    if (!loaded) {
+      throw new Error(`Project "${projectName}" not found. Run \`brewnet init\` first.`);
+    }
+    this.state = loaded;
+  }
+  /** Reload state from disk */
+  reload() {
+    const loaded = loadState(this.projectName);
+    if (loaded) this.state = loaded;
+  }
+  /** Get a copy of the current state */
+  getState() {
+    return structuredClone(this.state);
+  }
+  // ── connect ──────────────────────────────────────────────────────────────
+  /**
+   * Connect a local app to an external domain via Cloudflare Tunnel.
+   *
+   * Steps: health check → ingress update → DNS create → Traefik labels → persist → poll DNS
+   * Rolls back on failure.
+   */
+  async connect(appName, subdomain, domain, options = {}) {
+    const hostname = `${subdomain}.${domain}`;
+    const steps = [];
+    const cf = this.state.domain.cloudflare;
+    const log = (msg) => options.onLog?.(`[domain-connect] ${msg}`);
+    log(`start: app=${appName} subdomain=${subdomain} domain=${domain}`);
+    log(`cf state: tunnelId=${cf.tunnelId || "(empty)"} apiToken=${cf.apiToken ? "***" : "(empty)"} accountId=${cf.accountId || "(empty)"} zoneId=${cf.zoneId || "(empty)"}`);
+    if (!cf.tunnelId || !cf.apiToken) {
+      const err = "Cloudflare credentials not configured. Set API token and tunnel ID first.";
+      log(`FAIL: ${err}`);
+      return {
+        success: false,
+        hostname,
+        externalUrl: `https://${hostname}`,
+        steps,
+        error: err
+      };
+    }
+    const containerPort = this.resolveContainerPort(appName);
+    log(`resolveContainerPort(${appName}) \u2192 ${containerPort ?? "null"}`);
+    if (!containerPort) {
+      const err = `Cannot determine container port for app "${appName}".`;
+      log(`FAIL: ${err}`);
+      return {
+        success: false,
+        hostname,
+        externalUrl: `https://${hostname}`,
+        steps,
+        error: err
+      };
+    }
+    const scenario = options.scenario ?? this.detectScenario();
+    log(`scenario: ${scenario}`);
+    log(`step 1/6: health check \u2192 http://127.0.0.1:${containerPort}/`);
+    const healthStart = Date.now();
+    try {
+      const healthy = await this.checkLocalHealth(appName, containerPort);
+      if (!healthy) {
+        const err = `App "${appName}" not responding on port ${containerPort}`;
+        log(`FAIL step 1: ${err}`);
+        steps.push({ step: "health_check", status: "failed", error: err });
+        return { success: false, hostname, externalUrl: `https://${hostname}`, steps, error: `APP_NOT_RUNNING: Local health check failed for ${appName} on port ${containerPort}` };
+      }
+      steps.push({ step: "health_check", status: "completed", durationMs: Date.now() - healthStart });
+      log(`step 1 OK (${Date.now() - healthStart}ms)`);
+    } catch (err) {
+      log(`FAIL step 1 exception: ${err}`);
+      steps.push({ step: "health_check", status: "failed", error: String(err) });
+      return { success: false, hostname, externalUrl: `https://${hostname}`, steps, error: `Health check failed: ${err}` };
+    }
+    log(`step 2/6: configure tunnel ingress (accountId=${cf.accountId || "(empty)"}, tunnelId=${cf.tunnelId})`);
+    const ingressStart = Date.now();
+    let previousIngress = null;
+    try {
+      previousIngress = getActiveServiceRoutes(this.state);
+      const projectDomain = this.state.domain.zoneName;
+      const builtinRoutes = previousIngress.map((r) => ({ ...r, domain: projectDomain }));
+      const existingExtRoutes = (this.state.domainConnections ?? []).filter((c) => c.appName !== appName).map((c) => ({ subdomain: c.subdomain, containerName: this.resolveContainerName(c.appName), port: c.containerPort, domain: c.domain }));
+      const newRoute = { subdomain, containerName: this.resolveContainerName(appName), port: containerPort, domain };
+      const allRoutes = [...builtinRoutes, ...existingExtRoutes, newRoute];
+      log(`ingress routes: ${JSON.stringify(allRoutes.map((r) => `${r.subdomain} \u2192 ${r.containerName}:${r.port}`))}`);
+      await configureTunnelIngress(cf.apiToken, cf.accountId, cf.tunnelId, domain, allRoutes);
+      steps.push({ step: "ingress_update", status: "completed", durationMs: Date.now() - ingressStart });
+      log(`step 2 OK (${Date.now() - ingressStart}ms)`);
+    } catch (err) {
+      log(`FAIL step 2: ${err}`);
+      steps.push({ step: "ingress_update", status: "failed", error: String(err) });
+      return { success: false, hostname, externalUrl: `https://${hostname}`, steps, error: `Ingress update failed: ${err}` };
+    }
+    log(`step 3/6: DNS CNAME check/create for ${hostname} (zoneId=${cf.zoneId || "(empty)"})`);
+    const dnsStart = Date.now();
+    let cnameRecordId = "";
+    try {
+      const existing = await getDnsRecords(cf.apiToken, cf.zoneId, hostname);
+      log(`existing DNS records for ${hostname}: ${existing.length}`);
+      if (existing.length > 0 && !options.force) {
+        await this.rollbackIngress(cf, previousIngress, domain);
+        const err = `CNAME_CONFLICT: A CNAME record already exists for ${hostname}`;
+        log(`FAIL step 3: ${err}`);
+        steps.push({ step: "dns_creation", status: "failed", error: err });
+        return { success: false, hostname, externalUrl: `https://${hostname}`, steps, error: `CNAME_CONFLICT` };
+      }
+      if (existing.length > 0 && options.force) {
+        for (const rec of existing) {
+          await deleteDnsRecord(cf.apiToken, cf.zoneId, rec.id);
+        }
+        log(`deleted ${existing.length} existing CNAME record(s)`);
+      }
+      await createDnsRecord(cf.apiToken, cf.zoneId, cf.tunnelId, subdomain, domain);
+      const created = await getDnsRecords(cf.apiToken, cf.zoneId, hostname);
+      cnameRecordId = created[0]?.id ?? "";
+      steps.push({ step: "dns_creation", status: "completed", durationMs: Date.now() - dnsStart });
+      log(`step 3 OK \u2014 cnameRecordId=${cnameRecordId} (${Date.now() - dnsStart}ms)`);
+    } catch (err) {
+      await this.rollbackIngress(cf, previousIngress, domain);
+      log(`FAIL step 3: ${err}`);
+      steps.push({ step: "dns_creation", status: "failed", error: String(err) });
+      return { success: false, hostname, externalUrl: `https://${hostname}`, steps, error: `DNS creation failed: ${err}` };
+    }
+    log(`step 4/6: Traefik labels for ${appName}`);
+    try {
+      const composePath = this.getComposePath();
+      if (fs.existsSync(composePath)) {
+        addExternalLabels(composePath, appName, hostname, containerPort);
+        log(`step 4 OK \u2014 labels added to ${composePath}`);
+      } else {
+        log(`step 4 SKIP \u2014 compose file not found at ${composePath}`);
+      }
+      steps.push({ step: "traefik_labels", status: "completed" });
+    } catch (err) {
+      log(`step 4 WARN (non-fatal): ${err}`);
+      steps.push({ step: "traefik_labels", status: "failed", error: String(err) });
+    }
+    log(`step 5/6: persist connection to state`);
+    const connection = {
+      appName,
+      subdomain,
+      domain,
+      hostname,
+      tunnelId: cf.tunnelId,
+      cnameRecordId,
+      containerPort,
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      scenario
+    };
+    if (!this.state.domainConnections) {
+      this.state.domainConnections = [];
+    }
+    this.state.domainConnections = this.state.domainConnections.filter((c) => c.appName !== appName);
+    this.state.domainConnections.push(connection);
+    saveState(this.state);
+    log(`step 5 OK`);
+    log(`step 6/6: poll DNS propagation for ${hostname} (timeout 30s)`);
+    const pollStart = Date.now();
+    try {
+      await this.pollDnsPropagation(hostname, 3e4);
+      steps.push({ step: "dns_propagation", status: "completed", durationMs: Date.now() - pollStart });
+      log(`step 6 OK (${Date.now() - pollStart}ms)`);
+    } catch {
+      steps.push({ step: "dns_propagation", status: "skipped", durationMs: Date.now() - pollStart });
+      log(`step 6 SKIP \u2014 DNS not yet propagated (${Date.now() - pollStart}ms)`);
+    }
+    log(`SUCCESS: https://${hostname}`);
+    return {
+      success: true,
+      hostname,
+      externalUrl: `https://${hostname}`,
+      steps
+    };
+  }
+  // ── disconnect ───────────────────────────────────────────────────────────
+  /**
+   * Disconnect an app from its external domain.
+   *
+   * Steps: remove ingress → delete DNS → remove Traefik labels → update state
+   * Atomic rollback on failure.
+   */
+  async disconnect(appName) {
+    const steps = [];
+    const connections = this.state.domainConnections ?? [];
+    const conn = connections.find((c) => c.appName === appName);
+    if (!conn) {
+      return {
+        success: false,
+        appName,
+        removedHostname: "",
+        steps,
+        error: `NOT_CONNECTED: No external domain connection found for app: ${appName}`
+      };
+    }
+    const cf = this.state.domain.cloudflare;
+    try {
+      const remainingRoutes = getActiveServiceRoutes(this.state);
+      const projectDomain = this.state.domain.zoneName;
+      const builtinRoutes = remainingRoutes.filter((r) => r.subdomain !== conn.subdomain).map((r) => ({ ...r, domain: projectDomain }));
+      const remainingExtRoutes = (this.state.domainConnections ?? []).filter((c) => c.appName !== appName).map((c) => ({ subdomain: c.subdomain, containerName: this.resolveContainerName(c.appName), port: c.containerPort, domain: c.domain }));
+      const filteredRoutes = [...builtinRoutes, ...remainingExtRoutes];
+      if (cf.apiToken && cf.accountId && cf.tunnelId) {
+        await configureTunnelIngress(cf.apiToken, cf.accountId, cf.tunnelId, conn.domain, filteredRoutes);
+      }
+      steps.push({ step: "ingress_removal", status: "completed" });
+    } catch (err) {
+      steps.push({ step: "ingress_removal", status: "failed", error: String(err) });
+      return { success: false, appName, removedHostname: conn.hostname, steps, error: `Ingress removal failed: ${err}` };
+    }
+    try {
+      if (cf.apiToken && cf.zoneId) {
+        if (conn.cnameRecordId) {
+          await deleteDnsRecord(cf.apiToken, cf.zoneId, conn.cnameRecordId);
+        } else {
+          const records = await getDnsRecords(cf.apiToken, cf.zoneId, conn.hostname);
+          for (const rec of records) {
+            await deleteDnsRecord(cf.apiToken, cf.zoneId, rec.id);
+          }
+        }
+      }
+      steps.push({ step: "dns_deletion", status: "completed" });
+    } catch (err) {
+      try {
+        const routes = getActiveServiceRoutes(this.state);
+        const projectDomain = this.state.domain.zoneName;
+        const allBuiltin = routes.map((r) => ({ ...r, domain: projectDomain }));
+        const allExt = (this.state.domainConnections ?? []).map((c) => ({ subdomain: c.subdomain, containerName: this.resolveContainerName(c.appName), port: c.containerPort, domain: c.domain }));
+        const allRoutes = [...allBuiltin, ...allExt];
+        if (cf.apiToken && cf.accountId && cf.tunnelId) {
+          await configureTunnelIngress(cf.apiToken, cf.accountId, cf.tunnelId, conn.domain, allRoutes);
+        }
+      } catch {
+      }
+      steps.push({ step: "dns_deletion", status: "failed", error: String(err) });
+      return { success: false, appName, removedHostname: conn.hostname, steps, error: `DNS deletion failed: ${err}` };
+    }
+    try {
+      const composePath = this.getComposePath();
+      if (fs.existsSync(composePath)) {
+        removeExternalLabels(composePath, appName);
+      }
+      steps.push({ step: "traefik_cleanup", status: "completed" });
+    } catch (err) {
+      steps.push({ step: "traefik_cleanup", status: "failed", error: String(err) });
+    }
+    this.state.domainConnections = connections.filter((c) => c.appName !== appName);
+    saveState(this.state);
+    return {
+      success: true,
+      appName,
+      removedHostname: conn.hostname,
+      steps
+    };
+  }
+  // ── list ─────────────────────────────────────────────────────────────────
+  /** Returns all active domain connections. */
+  list() {
+    return this.state.domainConnections ?? [];
+  }
+  // ── status ───────────────────────────────────────────────────────────────
+  /**
+   * Get detailed status for a specific app's domain connection,
+   * or all connections if appName is omitted.
+   */
+  async status(appName) {
+    const connections = this.state.domainConnections ?? [];
+    const targets = appName ? connections.filter((c) => c.appName === appName) : connections;
+    const cf = this.state.domain.cloudflare;
+    const results = [];
+    for (const conn of targets) {
+      const info = {
+        appName: conn.appName,
+        local: { url: `http://localhost:${conn.containerPort}`, healthy: false },
+        external: { url: `https://${conn.hostname}`, dnsResolved: false, httpsReachable: false },
+        tunnel: { status: "inactive", connectorCount: 0 },
+        dns: null
+      };
+      try {
+        info.local.healthy = await this.checkLocalHealth(conn.appName, conn.containerPort);
+      } catch {
+      }
+      if (cf.apiToken && cf.accountId && cf.tunnelId) {
+        try {
+          const health = await getTunnelHealth(cf.apiToken, cf.accountId, cf.tunnelId);
+          info.tunnel = health;
+        } catch {
+        }
+      }
+      if (cf.apiToken && cf.zoneId) {
+        try {
+          const records = await getDnsRecords(cf.apiToken, cf.zoneId, conn.hostname);
+          if (records.length > 0) {
+            info.dns = {
+              type: "CNAME",
+              name: records[0].name,
+              content: records[0].content,
+              proxied: records[0].proxied
+            };
+            info.external.dnsResolved = true;
+          }
+        } catch {
+        }
+      }
+      try {
+        const resolved = await this.checkDnsResolution(conn.hostname);
+        info.external.dnsResolved = info.external.dnsResolved || resolved;
+      } catch {
+      }
+      try {
+        info.external.httpsReachable = await this.checkHttpsReachable(conn.hostname);
+      } catch {
+      }
+      results.push(info);
+    }
+    return results;
+  }
+  // ── getConnectableApps ───────────────────────────────────────────────────
+  /** Returns apps that can be connected to domains (running services not yet connected). */
+  getConnectableApps() {
+    const routes = getActiveServiceRoutes(this.state);
+    const connections = this.state.domainConnections ?? [];
+    return routes.map((route) => {
+      const existing = connections.find((c) => c.subdomain === route.subdomain);
+      return {
+        name: route.subdomain,
+        containerName: route.containerName,
+        port: route.port,
+        running: true,
+        // We assume routes represent running services
+        alreadyConnected: !!existing,
+        hostname: existing?.hostname
+      };
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────────────
+  detectScenario() {
+    const cf = this.state.domain.cloudflare;
+    if (cf.zoneId) return "A";
+    return "C";
+  }
+  resolveContainerPort(appName) {
+    const routes = getActiveServiceRoutes(this.state);
+    const route = routes.find((r) => r.subdomain === appName || r.containerName === appName);
+    if (route) return route.port;
+    const appsJsonPath = path.join(os.homedir(), ".brewnet", "apps.json");
+    const apps = readApps(appsJsonPath);
+    const found = apps.find((a) => a.name === appName);
+    if (!found) return null;
+    const stackEntry = found.stackId ? getStackById(found.stackId) : null;
+    if (stackEntry?.isUnified === false && found.appDir) {
+      let frontendPort = 3e3;
+      const envPath = path.join(found.appDir, ".env");
+      try {
+        const envContent = fs.readFileSync(envPath, "utf-8");
+        const match = envContent.match(/^FRONTEND_PORT=(\d+)/m);
+        if (match) frontendPort = parseInt(match[1], 10);
+      } catch {
+      }
+      return frontendPort;
+    }
+    return found.port;
+  }
+  resolveContainerName(appName) {
+    const routes = getActiveServiceRoutes(this.state);
+    const route = routes.find((r) => r.subdomain === appName || r.containerName === appName);
+    if (route) return route.containerName;
+    const appsJsonPath = path.join(os.homedir(), ".brewnet", "apps.json");
+    const apps = readApps(appsJsonPath);
+    const found = apps.find((a) => a.name === appName);
+    if (found) return "host.docker.internal";
+    return appName;
+  }
+  getComposePath() {
+    const projectPath = this.state.projectPath.startsWith("~") ? path.join(os.homedir(), this.state.projectPath.slice(1)) : this.state.projectPath;
+    return path.join(projectPath, "docker-compose.yml");
+  }
+  async checkLocalHealth(_appName, port) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5e3);
+      const resp = await fetch(`http://127.0.0.1:${port}/`, { signal: controller.signal });
+      clearTimeout(timeout);
+      return resp.ok || resp.status < 500;
+    } catch {
+      return false;
+    }
+  }
+  async checkDnsResolution(hostname) {
+    try {
+      const result = await execa("dig", ["+short", "CNAME", hostname, "@1.1.1.1"], { timeout: 1e4 });
+      return result.stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async checkHttpsReachable(hostname) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      const resp = await fetch(`https://${hostname}/`, {
+        method: "HEAD",
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      return resp.ok || resp.status < 500;
+    } catch {
+      return false;
+    }
+  }
+  async rollbackIngress(cf, previousRoutes, domain) {
+    if (!previousRoutes || !cf.apiToken || !cf.accountId || !cf.tunnelId) return;
+    try {
+      await configureTunnelIngress(cf.apiToken, cf.accountId, cf.tunnelId, domain, previousRoutes);
+    } catch {
+    }
+  }
+  async pollDnsPropagation(hostname, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const resolved = await this.checkDnsResolution(hostname);
+      if (resolved) return;
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
+    throw new Error("DNS propagation timeout");
+  }
+};
+
+export {
+  BrewnetError,
+  isBrewnetError,
+  addService,
+  removeService,
+  parseDuration,
+  queryLogs,
+  getLogStats,
+  createBackup,
+  restoreBackup,
+  listBackups,
+  checkDiskSpace,
+  readApps,
+  addApp,
+  updateApp,
+  removeApp,
+  readDeployHistory,
+  appendDeployHistory,
+  DomainManager
+};
+//# sourceMappingURL=chunk-2VWMDHGI.js.map