@netrunner714/pegas 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,2885 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs12 from "node:fs";
+import path11 from "node:path";
+import child_process5 from "node:child_process";
+import { parseArgs } from "node:util";
+
+// src/commands/init.ts
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+import os2 from "node:os";
+
+// src/docker.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function runCommand(cmd, args, cwd) {
+  try {
+    const { stdout, stderr } = await execFileAsync(cmd, args, { cwd });
+    return { success: true, stdout: stdout.trim(), stderr: stderr.trim() };
+  } catch (err) {
+    return {
+      success: false,
+      stdout: (err.stdout || "").toString().trim(),
+      stderr: (err.stderr || err.message || "").toString().trim()
+    };
+  }
+}
+async function checkDocker() {
+  const res = await runCommand("docker", ["info", "--format", "{{.ServerVersion}}"]);
+  return res.success;
+}
+async function checkDockerCompose() {
+  const res = await runCommand("docker", ["compose", "version"]);
+  return res.success;
+}
+async function ensureDockerNetwork(networkName = "pegas-network") {
+  const inspect = await runCommand("docker", ["network", "inspect", networkName]);
+  if (inspect.success) {
+    return true;
+  }
+  const create = await runCommand("docker", ["network", "create", networkName]);
+  return create.success;
+}
+async function validateCaddyConfig(gatewayDir) {
+  return await runCommand("docker", ["compose", "exec", "-T", "caddy", "caddy", "validate", "--config", "/etc/caddy/Caddyfile"], gatewayDir);
+}
+async function reloadCaddyConfig(gatewayDir) {
+  return await runCommand("docker", ["compose", "exec", "-T", "caddy", "caddy", "reload", "--config", "/etc/caddy/Caddyfile"], gatewayDir);
+}
+async function startGatewayContainer(gatewayDir) {
+  return await runCommand("docker", ["compose", "up", "-d"], gatewayDir);
+}
+async function getGatewayContainerStatus(gatewayDir) {
+  return await runCommand("docker", ["compose", "ps", "--format", "json"], gatewayDir);
+}
+
+// src/gateway.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import os from "node:os";
+
+// src/contract.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var CONTRACT_FILENAME = "pegas.json";
+function normalizeDomain(raw) {
+  let domain = raw.trim().toLowerCase();
+  domain = domain.replace(/^https?:\/\//, "");
+  domain = domain.replace(/^.*@/, "");
+  domain = domain.replace(/[/?#].*$/, "");
+  domain = domain.replace(/:\d+$/, "");
+  domain = domain.replace(/\.+$/, "");
+  return domain;
+}
+function toAsciiDomain(domain) {
+  try {
+    return new URL(`http://${domain}`).hostname;
+  } catch {
+    return domain;
+  }
+}
+function slugify(name) {
+  const unscope = name.replace(/^@[^/]+\//, "");
+  const slug = unscope.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "app";
+}
+async function detectProjectSlug(projectDir) {
+  const pkgPath = path.join(projectDir, "package.json");
+  try {
+    const raw = await fs.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (pkg.name && typeof pkg.name === "string" && pkg.name.trim()) {
+      return slugify(pkg.name.trim());
+    }
+  } catch {}
+  const dirName = path.basename(path.resolve(projectDir));
+  return slugify(dirName);
+}
+async function detectComposeWebService(projectDir) {
+  const composeFiles = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml"
+  ];
+  for (const f of composeFiles) {
+    try {
+      const content = await fs.readFile(path.join(projectDir, f), "utf-8");
+      const lines = content.replace(/\r\n/g, `
+`).split(`
+`);
+      let inServices = false;
+      let serviceIndent = null;
+      let currentService = null;
+      let currentPorts = [];
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const indent = line.search(/\S/);
+        if (indent === 0 && /^services:\s*$/.test(line)) {
+          inServices = true;
+          continue;
+        }
+        if (indent === 0 && inServices && /^[a-zA-Z0-9_-]+:\s*$/.test(line)) {
+          break;
+        }
+        if (inServices) {
+          if (serviceIndent === null && indent > 0 && /^[a-zA-Z0-9._-]+:\s*$/.test(trimmed)) {
+            serviceIndent = indent;
+          }
+          if (serviceIndent !== null && indent === serviceIndent && /^[a-zA-Z0-9._-]+:\s*$/.test(trimmed)) {
+            if (currentService && currentPorts.length > 0) {
+              const clean = currentPorts[0].replace(/['"]/g, "").trim();
+              const portMatch = clean.match(/:(\d+)$/) || clean.match(/(\d+)$/);
+              return { name: currentService, port: portMatch ? portMatch[1] : "3000" };
+            }
+            currentService = trimmed.replace(/:\s*$/, "");
+            currentPorts = [];
+          } else if (currentService && /^\s*-\s*["']?\d+/.test(line)) {
+            currentPorts.push(line.trim());
+          }
+        }
+      }
+      if (currentService && currentPorts.length > 0) {
+        const clean = currentPorts[0].replace(/['"]/g, "").trim();
+        const portMatch = clean.match(/:(\d+)$/) || clean.match(/(\d+)$/);
+        return { name: currentService, port: portMatch ? portMatch[1] : "3000" };
+      }
+    } catch {}
+  }
+  return null;
+}
+function createDefaultContract(slug, serviceName = "web", port = "3000") {
+  return {
+    projectName: slug,
+    services: {
+      [serviceName]: {
+        upstream: `${serviceName}:${port}`,
+        domains: {
+          dev: [`${slug}.localhost`],
+          prod: [`${slug}.com`]
+        }
+      }
+    }
+  };
+}
+var DEFAULT_CONTRACT = createDefaultContract("app", "web", "3000");
+async function setupProjectContract(projectDir) {
+  const contractPath = path.join(projectDir, CONTRACT_FILENAME);
+  const slug = await detectProjectSlug(projectDir);
+  try {
+    await fs.access(contractPath);
+    return { created: false, file: CONTRACT_FILENAME, slug };
+  } catch {
+    const detected = await detectComposeWebService(projectDir);
+    const serviceName = detected?.name || "web";
+    const port = detected?.port || "3000";
+    const defaultContract = createDefaultContract(slug, serviceName, port);
+    await fs.writeFile(contractPath, JSON.stringify(defaultContract, null, 2) + `
+`, "utf-8");
+    return { created: true, file: CONTRACT_FILENAME, slug };
+  }
+}
+async function updatePackageJson(projectDir) {
+  const actions = [];
+  const pkgPath = path.join(projectDir, "package.json");
+  try {
+    const raw = await fs.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (!pkg.scripts) {
+      pkg.scripts = {};
+    }
+    if (pkg.scripts.dev) {
+      if (!pkg.scripts.dev.includes("pegas dev")) {
+        pkg.scripts.dev = `pegas dev -- ${pkg.scripts.dev}`;
+        actions.push("Обновлён скрипт 'dev' в package.json: обёрнут в 'pegas dev --'");
+      }
+    } else {
+      pkg.scripts.dev = "pegas dev";
+      actions.push("Добавлен скрипт 'dev': 'pegas dev' в package.json");
+    }
+    if (!pkg.scripts.deploy || !pkg.scripts.deploy.includes("pegas deploy")) {
+      pkg.scripts.deploy = "pegas deploy";
+      actions.push("Добавлен скрипт 'deploy': 'pegas deploy' в package.json");
+    }
+    if (!pkg.devDependencies) {
+      pkg.devDependencies = {};
+    }
+    if (!pkg.devDependencies["@netrunner714/pegas"] && !pkg.devDependencies.pegas) {
+      pkg.devDependencies["@netrunner714/pegas"] = "^1.0.0";
+      actions.push("Добавлен '@netrunner714/pegas' в devDependencies в package.json");
+    }
+    await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + `
+`, "utf-8");
+  } catch {}
+  return actions;
+}
+
+// src/gateway.ts
+async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = path2.resolve(startDir);
+  let packageJsonDir = null;
+  while (true) {
+    try {
+      await fs2.access(path2.join(currentDir, ".git"));
+      return currentDir;
+    } catch {}
+    if (!packageJsonDir) {
+      try {
+        await fs2.access(path2.join(currentDir, "package.json"));
+        packageJsonDir = currentDir;
+      } catch {}
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return packageJsonDir;
+}
+async function findGatewayDir(explicitDir) {
+  if (explicitDir) {
+    return path2.resolve(explicitDir);
+  }
+  if (process.env.PEGAS_DIR) {
+    return path2.resolve(process.env.PEGAS_DIR);
+  }
+  const cwd = process.cwd();
+  try {
+    await fs2.access(path2.join(cwd, "Caddyfile"));
+    await fs2.access(path2.join(cwd, "conf.d"));
+    return cwd;
+  } catch {}
+  const homeGateway = path2.join(os.homedir(), "gateway");
+  try {
+    await fs2.access(path2.join(homeGateway, "Caddyfile"));
+    return homeGateway;
+  } catch {}
+  const homePegas = path2.join(os.homedir(), "pegas-server");
+  try {
+    await fs2.access(path2.join(homePegas, "Caddyfile"));
+    return homePegas;
+  } catch {}
+  return homeGateway;
+}
+function getConfDir(gatewayDir) {
+  return path2.join(gatewayDir, "conf.d");
+}
+function getRouteFilePath(gatewayDir, domain) {
+  const ascii = toAsciiDomain(domain);
+  const sanitized = ascii.toLowerCase().replace(/[^a-z0-9.-]/g, "_");
+  return path2.join(getConfDir(gatewayDir), `${sanitized}.caddy`);
+}
+function getProjectRouteFilePath(gatewayDir, projectName) {
+  const sanitized = projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "_");
+  return path2.join(getConfDir(gatewayDir), `${sanitized}.caddy`);
+}
+async function listRoutes(gatewayDir) {
+  const confDir = getConfDir(gatewayDir);
+  const routes = [];
+  try {
+    const files = await fs2.readdir(confDir);
+    for (const file of files) {
+      if (!file.endsWith(".caddy"))
+        continue;
+      const filePath = path2.join(confDir, file);
+      const content = await fs2.readFile(filePath, "utf-8");
+      const domain = file.replace(/\.caddy$/, "");
+      const isSpa = content.includes("handle /api/*");
+      const hasWwwRedirect = content.includes(`www.${domain}`);
+      const proxyMatches = [...content.matchAll(/reverse_proxy\s+([^\s\n]+)/g)];
+      const upstreams = proxyMatches.map((m) => m[1]);
+      let upstream = upstreams[0] || "unknown";
+      let apiUpstream = undefined;
+      if (isSpa && upstreams.length >= 2) {
+        apiUpstream = upstreams[0];
+        upstream = upstreams[1];
+      }
+      routes.push({
+        domain,
+        upstream,
+        apiUpstream,
+        filePath,
+        hasWwwRedirect,
+        isSpa
+      });
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return routes;
+}
+
+// src/compose.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+function createDefaultCompose(projectName = "app") {
+  return `services:
+  web:
+    build: .
+    restart: unless-stopped
+    expose:
+      - "3000"
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "50m"
+        max-file: "3"
+    networks:
+      pegas-network:
+        aliases:
+          - ${projectName}-web
+
+networks:
+  pegas-network:
+    external: true
+`;
+}
+var DEFAULT_COMPOSE_CONTENT = createDefaultCompose("app");
+var INFRA_PORTS = new Set([
+  22,
+  2222,
+  3306,
+  4222,
+  5432,
+  5672,
+  6379,
+  6380,
+  8123,
+  9000,
+  9092,
+  9200,
+  9300,
+  11211,
+  15672,
+  27017,
+  27018
+]);
+var INFRA_SERVICE_NAMES = new Set([
+  "db",
+  "database",
+  "postgres",
+  "postgresql",
+  "redis",
+  "valkey",
+  "mysql",
+  "mariadb",
+  "mongo",
+  "mongodb",
+  "rabbitmq",
+  "queue",
+  "broker",
+  "elastic",
+  "elasticsearch",
+  "kafka",
+  "memcached"
+]);
+function parsePortEntry(raw) {
+  const clean = raw.trim().replace(/^-\s*/, "").replace(/^['"]|['"]$/g, "");
+  const protoIndex = clean.indexOf("/");
+  const noProto = protoIndex !== -1 ? clean.slice(0, protoIndex) : clean;
+  const parts = noProto.split(":");
+  const containerStr = parts[parts.length - 1];
+  const containerPort = parseInt(containerStr, 10);
+  if (isNaN(containerPort))
+    return null;
+  const hostPort = parts.length > 1 ? parts[parts.length - 2] : undefined;
+  return { host: hostPort, container: containerPort, raw };
+}
+function isInfraService(serviceName, serviceLines) {
+  const lowerName = serviceName.toLowerCase();
+  if (INFRA_SERVICE_NAMES.has(lowerName))
+    return true;
+  for (const name of INFRA_SERVICE_NAMES) {
+    if (lowerName.includes(name))
+      return true;
+  }
+  for (const line of serviceLines) {
+    const match = line.match(/^\s*image:\s*([^\s]+)/);
+    if (match) {
+      const img = match[1].toLowerCase();
+      for (const name of INFRA_SERVICE_NAMES) {
+        if (img.includes(name))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function detectInfraServices(content) {
+  const normalized = content.replace(/\r\n/g, `
+`);
+  const lines = normalized.split(`
+`);
+  const services = [];
+  let inServices = false;
+  let serviceIndent = null;
+  let currentService = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const indent = line.search(/\S/);
+    if (indent === 0) {
+      if (trimmed.startsWith("services:")) {
+        inServices = true;
+        serviceIndent = null;
+        currentService = null;
+        continue;
+      } else {
+        inServices = false;
+        if (currentService) {
+          services.push(currentService);
+          currentService = null;
+        }
+        continue;
+      }
+    }
+    if (inServices) {
+      if (serviceIndent === null) {
+        serviceIndent = indent;
+        const match = trimmed.match(/^([a-zA-Z0-9._-]+):/);
+        if (match) {
+          currentService = { name: match[1], lines: [] };
+        }
+      } else if (indent === serviceIndent) {
+        if (currentService) {
+          services.push(currentService);
+        }
+        const match = trimmed.match(/^([a-zA-Z0-9._-]+):/);
+        if (match) {
+          currentService = { name: match[1], lines: [] };
+        } else {
+          currentService = null;
+        }
+      } else if (indent > serviceIndent && currentService) {
+        currentService.lines.push(line);
+      }
+    }
+  }
+  if (currentService) {
+    services.push(currentService);
+  }
+  const infraServices = [];
+  for (const s of services) {
+    if (isInfraService(s.name, s.lines)) {
+      let hostPort = undefined;
+      let containerPort = undefined;
+      let inPorts = false;
+      let portsIndent = null;
+      for (const line of s.lines) {
+        const trimmed = line.trim();
+        const indent = line.search(/\S/);
+        if (trimmed.startsWith("ports:")) {
+          inPorts = true;
+          portsIndent = indent;
+          continue;
+        }
+        if (inPorts) {
+          if (indent > portsIndent && trimmed.startsWith("-")) {
+            const parsed = parsePortEntry(trimmed);
+            if (parsed) {
+              hostPort = parsed.host || String(parsed.container);
+              containerPort = parsed.container;
+              break;
+            }
+          } else if (indent <= portsIndent) {
+            inPorts = false;
+          }
+        }
+      }
+      infraServices.push({
+        name: s.name,
+        hostPort,
+        containerPort
+      });
+    }
+  }
+  return infraServices;
+}
+function patchExistingCompose(content, projectName = "app") {
+  const normalized = content.replace(/\r\n/g, `
+`);
+  const lines = normalized.split(`
+`);
+  const outputLines = [];
+  let inServices = false;
+  let serviceNameIndent = null;
+  let currentServiceName = null;
+  let currentServiceHeader = null;
+  let currentServiceLines = [];
+  let inNetworksSection = false;
+  function processService(name, header, sLines) {
+    const isInfra = isInfraService(name, sLines);
+    const hasPorts = sLines.some((l) => /^\s*ports:\s*$/.test(l));
+    const hasExpose = sLines.some((l) => /^\s*expose:\s*$/.test(l));
+    const hasPegasNetworkAlready = sLines.some((l) => l.includes("pegas-network"));
+    const isWeb = !isInfra && (hasPorts || hasExpose || hasPegasNetworkAlready);
+    if (!isWeb) {
+      return [header, ...sLines];
+    }
+    const remainingLines = [];
+    const exposedPorts = [];
+    let hasNetworks = false;
+    let hasPegasNetwork = false;
+    let propIndent = 4;
+    for (const l of sLines) {
+      const ind = l.search(/\S/);
+      if (ind > (serviceNameIndent ?? 2)) {
+        propIndent = ind;
+        break;
+      }
+    }
+    const propIndentStr = " ".repeat(propIndent);
+    const itemIndentStr = " ".repeat(propIndent + 2);
+    let i = 0;
+    while (i < sLines.length) {
+      const line = sLines[i];
+      const lineIndent = line.search(/\S/);
+      const portsMatch = line.match(/^(\s*)ports:\s*$/);
+      if (portsMatch && lineIndent === propIndent) {
+        i++;
+        const preservedPortLines = [];
+        while (i < sLines.length) {
+          const pLine = sLines[i];
+          const pTrimmed = pLine.trim();
+          const pIndent = pLine.search(/\S/);
+          if (pTrimmed === "" || pTrimmed.startsWith("#")) {
+            i++;
+            continue;
+          }
+          if (pIndent > propIndent) {
+            const parsed = parsePortEntry(pTrimmed);
+            if (parsed) {
+              if (isWeb) {
+                exposedPorts.push(parsed.container.toString());
+              } else {
+                preservedPortLines.push(pLine);
+              }
+            } else {
+              preservedPortLines.push(pLine);
+            }
+            i++;
+          } else {
+            break;
+          }
+        }
+        if (preservedPortLines.length > 0) {
+          remainingLines.push(line);
+          remainingLines.push(...preservedPortLines);
+        }
+        continue;
+      }
+      const exposeMatch = line.match(/^(\s*)expose:\s*$/);
+      if (exposeMatch && lineIndent === propIndent) {
+        remainingLines.push(line);
+        i++;
+        while (i < sLines.length) {
+          const eLine = sLines[i];
+          const eTrimmed = eLine.trim();
+          const eIndent = eLine.search(/\S/);
+          if (eTrimmed === "" || eTrimmed.startsWith("#")) {
+            remainingLines.push(eLine);
+            i++;
+            continue;
+          }
+          if (eIndent > propIndent) {
+            const clean = eTrimmed.replace(/^-\s*/, "").replace(/^['"]|['"]$/g, "");
+            exposedPorts.push(clean);
+            remainingLines.push(eLine);
+            i++;
+          } else {
+            break;
+          }
+        }
+        continue;
+      }
+      const networksMatch = line.match(/^(\s*)networks:\s*$/);
+      if (networksMatch && lineIndent === propIndent) {
+        hasNetworks = true;
+        remainingLines.push(line);
+        i++;
+        while (i < sLines.length) {
+          const nextLine = sLines[i];
+          const nextTrimmed = nextLine.trim();
+          const nextIndent = nextLine.search(/\S/);
+          if (nextTrimmed === "" || nextTrimmed.startsWith("#")) {
+            remainingLines.push(nextLine);
+            i++;
+            continue;
+          }
+          if (nextIndent > propIndent) {
+            if (nextTrimmed.startsWith("-")) {
+              const netName = nextTrimmed.replace(/^-\s*/, "").trim();
+              if (netName === "pegas-network") {
+                hasPegasNetwork = true;
+              }
+            } else if (nextTrimmed.startsWith("pegas-network:")) {
+              hasPegasNetwork = true;
+            }
+            remainingLines.push(nextLine);
+            i++;
+          } else {
+            break;
+          }
+        }
+        continue;
+      }
+      remainingLines.push(line);
+      i++;
+    }
+    if (isWeb) {
+      const hasExposeSection = remainingLines.some((l) => {
+        const ind = l.search(/\S/);
+        return ind === propIndent && /^\s*expose:\s*$/.test(l);
+      });
+      if (!hasExposeSection) {
+        let insertIdx = remainingLines.length;
+        const netIdx = remainingLines.findIndex((l) => {
+          const ind = l.search(/\S/);
+          return ind === propIndent && /^\s*networks:\s*$/.test(l);
+        });
+        if (netIdx !== -1) {
+          insertIdx = netIdx;
+        }
+        if (exposedPorts.length > 0) {
+          const unique = [...new Set(exposedPorts)];
+          const exposeLines = [
+            `${propIndentStr}expose:`,
+            ...unique.map((p) => `${itemIndentStr}- "${p}"`)
+          ];
+          remainingLines.splice(insertIdx, 0, ...exposeLines);
+        }
+      }
+      const scopedAlias = `${projectName}-${name}`;
+      const netIndentStr = " ".repeat(propIndent + 2);
+      const aliasIndentStr = " ".repeat(propIndent + 4);
+      const itemAliasIndentStr = " ".repeat(propIndent + 6);
+      const aliasSnippet = [
+        `${netIndentStr}pegas-network:`,
+        `${aliasIndentStr}aliases:`,
+        `${itemAliasIndentStr}- ${scopedAlias}`
+      ];
+      if (!hasNetworks) {
+        remainingLines.push(`${propIndentStr}networks:`);
+        remainingLines.push(...aliasSnippet);
+      } else {
+        const netIdx = remainingLines.findIndex((l) => {
+          const ind = l.search(/\S/);
+          return ind === propIndent && /^\s*networks:\s*$/.test(l);
+        });
+        if (netIdx !== -1) {
+          let existingPegasNetworkIdx = -1;
+          let hasScopedAlias = false;
+          let listPegasNetworkIdx = -1;
+          for (let k = netIdx + 1;k < remainingLines.length; k++) {
+            const nl = remainingLines[k];
+            const nind = nl.search(/\S/);
+            if (nind <= propIndent && nl.trim() !== "" && !nl.trim().startsWith("#")) {
+              break;
+            }
+            if (nl.trim() === "- pegas-network") {
+              listPegasNetworkIdx = k;
+            } else if (nl.trim() === "pegas-network:") {
+              existingPegasNetworkIdx = k;
+            }
+            if (nl.trim() === `- ${scopedAlias}`) {
+              hasScopedAlias = true;
+            }
+          }
+          if (listPegasNetworkIdx !== -1) {
+            remainingLines.splice(listPegasNetworkIdx, 1, ...aliasSnippet);
+          } else if (existingPegasNetworkIdx !== -1) {
+            if (!hasScopedAlias) {
+              let aliasHeaderIdx = -1;
+              for (let k = existingPegasNetworkIdx + 1;k < remainingLines.length; k++) {
+                const nl = remainingLines[k];
+                const nind = nl.search(/\S/);
+                if (nind <= propIndent + 2 && nl.trim() !== "" && !nl.trim().startsWith("#")) {
+                  break;
+                }
+                if (nl.trim() === "aliases:") {
+                  aliasHeaderIdx = k;
+                  break;
+                }
+              }
+              if (aliasHeaderIdx !== -1) {
+                remainingLines.splice(aliasHeaderIdx + 1, 0, `${itemAliasIndentStr}- ${scopedAlias}`);
+              } else {
+                remainingLines.splice(existingPegasNetworkIdx + 1, 0, `${aliasIndentStr}aliases:`, `${itemAliasIndentStr}- ${scopedAlias}`);
+              }
+            }
+          } else {
+            remainingLines.splice(netIdx + 1, 0, ...aliasSnippet);
+          }
+        }
+      }
+      const hasLogging = sLines.some((l) => /^\s*logging:\s*$/.test(l));
+      if (!hasLogging) {
+        const logIndentStr = propIndentStr;
+        const logSubIndentStr = " ".repeat(propIndent + 2);
+        const logOptIndentStr = " ".repeat(propIndent + 4);
+        const loggingSnippet = [
+          `${logIndentStr}logging:`,
+          `${logSubIndentStr}driver: "json-file"`,
+          `${logSubIndentStr}options:`,
+          `${logOptIndentStr}max-size: "50m"`,
+          `${logOptIndentStr}max-file: "3"`
+        ];
+        const netIdx = remainingLines.findIndex((l) => {
+          const ind = l.search(/\S/);
+          return ind === propIndent && /^\s*networks:\s*$/.test(l);
+        });
+        if (netIdx !== -1) {
+          remainingLines.splice(netIdx, 0, ...loggingSnippet);
+        } else {
+          remainingLines.push(...loggingSnippet);
+        }
+      }
+    }
+    return [header, ...remainingLines];
+  }
+  for (let idx = 0;idx < lines.length; idx++) {
+    const line = lines[idx];
+    const trimmed = line.trim();
+    const lineIndent = line.search(/\S/);
+    if (lineIndent === 0 && /^[a-zA-Z0-9_-]+:\s*$/.test(line)) {
+      if (currentServiceName && currentServiceHeader) {
+        const processed = processService(currentServiceName, currentServiceHeader, currentServiceLines);
+        outputLines.push(...processed);
+        currentServiceName = null;
+        currentServiceHeader = null;
+        currentServiceLines = [];
+      }
+      if (/^services:\s*$/.test(line)) {
+        inServices = true;
+        serviceNameIndent = null;
+        inNetworksSection = false;
+      } else {
+        inServices = false;
+        inNetworksSection = /^networks:\s*$/.test(line);
+      }
+      outputLines.push(line);
+      continue;
+    }
+    if (inServices) {
+      if (serviceNameIndent === null && lineIndent > 0 && /^[a-zA-Z0-9._-]+:\s*$/.test(trimmed)) {
+        serviceNameIndent = lineIndent;
+      }
+      if (serviceNameIndent !== null && lineIndent === serviceNameIndent && /^[a-zA-Z0-9._-]+:\s*$/.test(trimmed)) {
+        if (currentServiceName && currentServiceHeader) {
+          const processed = processService(currentServiceName, currentServiceHeader, currentServiceLines);
+          outputLines.push(...processed);
+          currentServiceLines = [];
+        }
+        currentServiceName = trimmed.replace(/:\s*$/, "");
+        currentServiceHeader = line;
+        continue;
+      }
+      if (currentServiceName) {
+        currentServiceLines.push(line);
+        continue;
+      }
+    }
+    outputLines.push(line);
+  }
+  if (currentServiceName && currentServiceHeader) {
+    const processed = processService(currentServiceName, currentServiceHeader, currentServiceLines);
+    outputLines.push(...processed);
+  }
+  let finalContent = outputLines.join(`
+`);
+  if (!/pegas-network:\s*\n\s*external:\s*true/m.test(finalContent)) {
+    const rootNetIndex = finalContent.search(/^networks:\s*$/m);
+    if (rootNetIndex !== -1) {
+      const afterNet = finalContent.indexOf(`
+`, rootNetIndex) + 1;
+      finalContent = finalContent.slice(0, afterNet) + `  pegas-network:
+    external: true
+` + finalContent.slice(afterNet);
+    } else {
+      finalContent = finalContent.trimEnd() + `
+
+networks:
+  pegas-network:
+    external: true
+`;
+    }
+  }
+  return finalContent;
+}
+async function findRootCompose(dir) {
+  const candidates = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml"
+  ];
+  for (const file of candidates) {
+    try {
+      await fs3.access(path3.join(dir, file));
+      return file;
+    } catch {}
+  }
+  return null;
+}
+async function setupProjectCompose(projectDir, projectName) {
+  const slug = projectName || await detectProjectSlug(projectDir);
+  const existingFile = await findRootCompose(projectDir);
+  if (!existingFile) {
+    const targetFile = "docker-compose.yml";
+    await fs3.writeFile(path3.join(projectDir, targetFile), createDefaultCompose(slug), "utf-8");
+    return { created: true, updated: false, file: targetFile };
+  }
+  const fullPath = path3.join(projectDir, existingFile);
+  const original = await fs3.readFile(fullPath, "utf-8");
+  const patched = patchExistingCompose(original, slug);
+  if (patched !== original) {
+    await fs3.writeFile(fullPath, patched, "utf-8");
+    return { created: false, updated: true, file: existingFile };
+  }
+  return { created: false, updated: false, file: existingFile };
+}
+
+// src/commands/init.ts
+var DOCS_PEGAS_MD = `# Pegas
+
+Этот проект настроен для работы со стандартизированным L7-шлюзом **Pegas**.
+
+## Контракт сервисов
+Конфигурация роутинга объявлена в файле \`pegas.json\`:
+- \`upstream\`: адрес контейнера во внутренней сети \`pegas-network\` (например: \`app:3000\`)
+- \`domains.dev\`: локальные домены разработки (например: \`app.localhost\`)
+- \`domains.prod\`: боевые домены с автоматическим SSL Let's Encrypt
+
+## Команды
+* Локальная разработка: \`npm/pnpm/bun run dev\` (запускает \`pegas dev\`)
+* Деплой на продакшен: \`npm/pnpm/bun run deploy\` (запускает \`pegas deploy\`)
+* Остановка проекта: \`pegas down\`
+
+Документация: https://netrunner714.ru/pegas
+`;
+async function setupGitignore(projectDir) {
+  const gitignorePath = path4.join(projectDir, ".gitignore");
+  try {
+    const content = await fs4.readFile(gitignorePath, "utf-8");
+    const lines = content.split(`
+`).map((line) => line.trim());
+    if (lines.includes(".pegas") || lines.includes(".pegas/")) {
+      return null;
+    }
+    const updated = content.endsWith(`
+`) ? `${content}.pegas
+` : `${content}
+.pegas
+`;
+    await fs4.writeFile(gitignorePath, updated, "utf-8");
+    return "Добавлена запись .pegas в .gitignore";
+  } catch {
+    await fs4.writeFile(gitignorePath, `.pegas
+`, "utf-8");
+    return "Создан .gitignore с записью .pegas";
+  }
+}
+async function handleProjectInit(cwd = process.cwd(), isJson = false) {
+  const actions = [];
+  if (cwd !== process.cwd()) {
+    actions.push(`Корень репозитория: ${cwd}`);
+  }
+  const contractRes = await setupProjectContract(cwd);
+  if (contractRes.created) {
+    actions.push(`Создан контракт ${contractRes.file} для проекта '${contractRes.slug}'`);
+  } else {
+    actions.push(`Контракт ${contractRes.file} уже существует`);
+  }
+  const pkgActions = await updatePackageJson(cwd);
+  actions.push(...pkgActions);
+  const gitignoreAction = await setupGitignore(cwd);
+  if (gitignoreAction) {
+    actions.push(gitignoreAction);
+  }
+  const docsDir = path4.join(cwd, "docs");
+  await fs4.mkdir(docsDir, { recursive: true });
+  const docsPath = path4.join(docsDir, "pegas.md");
+  await fs4.writeFile(docsPath, DOCS_PEGAS_MD, "utf-8");
+  actions.push("Сгенерирован docs/pegas.md");
+  const composeRes = await setupProjectCompose(cwd, contractRes.slug);
+  if (composeRes.created) {
+    actions.push(`Создан ${composeRes.file} с expose и сетью pegas-network`);
+  } else if (composeRes.updated) {
+    actions.push(`Выполнена трансформация портов и подключение pegas-network в ${composeRes.file}`);
+  } else {
+    actions.push(`${composeRes.file}: порты и сеть pegas-network уже оптимизированы`);
+  }
+  if (isJson) {
+    console.log(JSON.stringify({ status: "success", actions, docs: docsPath }));
+    return;
+  }
+  console.log(`
+✨ Project initialized with Pegas!
+`);
+  for (const act of actions) {
+    console.log(`  ✓ ${act}`);
+  }
+  console.log(`
+Next steps:`);
+  console.log("  1. Check pegas.json and set your domains.");
+  console.log(`  2. Start local dev with: npm run dev
+`);
+}
+async function handleServerInit(options) {
+  const isJson = options.json ?? false;
+  const hasDocker = await checkDocker();
+  if (!hasDocker) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Docker daemon is not running or not installed." }));
+    } else {
+      console.error("❌ Error: Docker daemon is not running or not installed.");
+    }
+    process.exit(1);
+  }
+  const hasCompose = await checkDockerCompose();
+  if (!hasCompose) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Docker Compose is not available." }));
+    } else {
+      console.error("❌ Error: Docker Compose is not available.");
+    }
+    process.exit(1);
+  }
+  const gatewayDir = options.gatewayDir ? path4.resolve(options.gatewayDir) : path4.join(os2.homedir(), "gateway");
+  await fs4.mkdir(gatewayDir, { recursive: true });
+  const confDir = path4.join(gatewayDir, "conf.d");
+  await fs4.mkdir(confDir, { recursive: true });
+  const networkName = options.networkName || "pegas-network";
+  await ensureDockerNetwork(networkName);
+  const caddyfilePath = path4.join(gatewayDir, "Caddyfile");
+  try {
+    await fs4.access(caddyfilePath);
+  } catch {
+    const globalOptions = options.email ? `{
+    email ${options.email}
+}` : `{
+    # Global options
+}`;
+    const defaultCaddyfile = `${globalOptions}
+
+import /etc/caddy/conf.d/*.caddy
+`;
+    await fs4.writeFile(caddyfilePath, defaultCaddyfile, "utf-8");
+  }
+  const composePath = path4.join(gatewayDir, "docker-compose.yml");
+  try {
+    await fs4.access(composePath);
+  } catch {
+    const defaultCompose = `services:
+  caddy:
+    image: caddy:2-alpine
+    container_name: gateway-caddy
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "50m"
+        max-file: "3"
+    ports:
+      - "80:80"
+      - "443:443"
+      - "443:443/udp"
+    volumes:
+      - ./Caddyfile:/etc/caddy/Caddyfile:ro
+      - ./conf.d:/etc/caddy/conf.d:ro
+      - caddy_data:/data
+      - caddy_config:/config
+    networks:
+      - ${networkName}
+
+networks:
+  ${networkName}:
+    external: true
+
+volumes:
+  caddy_data:
+  caddy_config:
+`;
+    await fs4.writeFile(composePath, defaultCompose, "utf-8");
+  }
+  const startRes = await startGatewayContainer(gatewayDir);
+  if (!startRes.success) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Failed to start Caddy container", details: startRes.stderr }));
+    } else {
+      console.error("❌ Failed to start Caddy container:", startRes.stderr);
+    }
+    process.exit(1);
+  }
+  const validateRes = await validateCaddyConfig(gatewayDir);
+  if (isJson) {
+    console.log(JSON.stringify({
+      status: "success",
+      gatewayDir,
+      network: networkName,
+      validated: validateRes.success
+    }));
+  } else {
+    console.log(`
+\uD83D\uDE80 Pegas server gateway initialized successfully!`);
+    console.log(`   Gateway directory: ${gatewayDir}`);
+    console.log(`   Docker network:    ${networkName}`);
+    console.log(`   Caddy container:   Running on :80 and :443`);
+    console.log("\nNext step: run `pegas add <domain> --upstream <service:port>` to route your first site.\n");
+  }
+}
+async function handleInit(options) {
+  const isJson = options.json ?? false;
+  if (options.server) {
+    await handleServerInit(options);
+    return;
+  }
+  if (options.project) {
+    await handleProjectInit(process.cwd(), isJson);
+    return;
+  }
+  const projectRoot = await findProjectRoot(process.cwd());
+  if (projectRoot) {
+    await handleProjectInit(projectRoot, isJson);
+  } else {
+    await handleServerInit(options);
+  }
+}
+
+// src/commands/deploy.ts
+import fs6 from "node:fs/promises";
+import path6 from "node:path";
+import child_process from "node:child_process";
+
+// src/generator.ts
+function isSubdomainOrIp(domain) {
+  if (/^(\d{1,3}\.){3}\d{1,3}$/.test(domain) || domain.includes(":")) {
+    return true;
+  }
+  if (domain.startsWith("www.") || domain === "localhost") {
+    return true;
+  }
+  const parts = domain.split(".");
+  return parts.length > 2;
+}
+function generateCaddyfileSnippet(options) {
+  const {
+    domain,
+    upstream,
+    spa = false,
+    apiUpstream,
+    apiPrefix = "/api/*",
+    noWww = false,
+    security = true
+  } = options;
+  const lines = [];
+  if (!noWww && !isSubdomainOrIp(domain)) {
+    lines.push(`www.${domain} {`);
+    lines.push(`    redir https://${domain}{uri} permanent`);
+    lines.push(`}`);
+    lines.push(``);
+  }
+  lines.push(`${domain} {`);
+  if (spa && apiUpstream) {
+    lines.push(`    encode gzip zstd`);
+    lines.push(``);
+    lines.push(`    handle ${apiPrefix} {`);
+    lines.push(`        reverse_proxy ${apiUpstream}`);
+    lines.push(`    }`);
+    lines.push(``);
+    lines.push(`    handle {`);
+    lines.push(`        reverse_proxy ${upstream || "app:80"}`);
+    lines.push(`    }`);
+  } else {
+    lines.push(`    reverse_proxy ${upstream || "app:3000"}`);
+    lines.push(``);
+    lines.push(`    encode gzip zstd`);
+  }
+  if (security) {
+    lines.push(``);
+    lines.push(`    header {`);
+    lines.push(`        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"`);
+    lines.push(`        X-Content-Type-Options nosniff`);
+    lines.push(`        Referrer-Policy strict-origin-when-cross-origin`);
+    lines.push(`    }`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join(`
+`);
+}
+
+// src/commands/reload.ts
+async function handleReload(options) {
+  const isJson = options.json ?? false;
+  const exitOnError = options.exitOnError ?? true;
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const validateRes = await validateCaddyConfig(gatewayDir);
+  if (!validateRes.success) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Validation failed", details: validateRes.stderr || validateRes.stdout }));
+    } else {
+      console.error("❌ Validation failed:");
+      console.error(validateRes.stderr || validateRes.stdout);
+    }
+    if (exitOnError) {
+      process.exit(1);
+    }
+    return false;
+  }
+  const reloadRes = await reloadCaddyConfig(gatewayDir);
+  if (!reloadRes.success) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Reload failed", details: reloadRes.stderr }));
+    } else {
+      console.error("❌ Reload failed:", reloadRes.stderr);
+    }
+    if (exitOnError) {
+      process.exit(1);
+    }
+    return false;
+  }
+  if (!options.silent) {
+    if (isJson) {
+      console.log(JSON.stringify({ status: "success", message: "Caddy configuration reloaded" }));
+    } else {
+      console.log(`
+\uD83D\uDD04 Caddy configuration reloaded with zero downtime.
+`);
+    }
+  }
+  return true;
+}
+
+// src/commands/list.ts
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
+
+// src/table.ts
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function stringVisualWidth(str) {
+  const clean = stripAnsi(str);
+  let width = 0;
+  for (const char of clean) {
+    const cp = char.codePointAt(0) || 0;
+    if (cp >= 127744 && cp <= 129791 || cp >= 9728 && cp <= 10175) {
+      width += 2;
+    } else if (cp >= 32 && cp <= 126) {
+      width += 1;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function padEndVisual(str, targetWidth) {
+  const current = stringVisualWidth(str);
+  const diff = targetWidth - current;
+  return diff > 0 ? str + " ".repeat(diff) : str;
+}
+function renderTable({ headers, rows }) {
+  if (headers.length === 0)
+    return "";
+  const colWidths = headers.map((header, colIdx) => {
+    let max = stringVisualWidth(header);
+    for (const row of rows) {
+      const cell = row[colIdx] || "";
+      const w = stringVisualWidth(cell);
+      if (w > max)
+        max = w;
+    }
+    return max;
+  });
+  const topBorder = "┌─" + colWidths.map((w) => "─".repeat(w)).join("─┬─") + "─┐";
+  const midBorder = "├─" + colWidths.map((w) => "─".repeat(w)).join("─┼─") + "─┤";
+  const botBorder = "└─" + colWidths.map((w) => "─".repeat(w)).join("─┴─") + "─┘";
+  const headerLine = "│ " + headers.map((h, i) => padEndVisual(`\x1B[1m${h}\x1B[0m`, colWidths[i])).join(" │ ") + " │";
+  const dataLines = rows.map((row) => {
+    return "│ " + colWidths.map((w, colIdx) => padEndVisual(row[colIdx] || "", w)).join(" │ ") + " │";
+  });
+  return [topBorder, headerLine, midBorder, ...dataLines, botBorder].join(`
+`);
+}
+
+// src/commands/list.ts
+function parseCaddyProjectFile(content, filename) {
+  let projectName = path5.basename(filename, ".caddy");
+  const projectCommentMatch = content.match(/#\s*Auto-generated by Pegas for project:\s*([^\n\r]+)/i);
+  if (projectCommentMatch && projectCommentMatch[1]) {
+    projectName = projectCommentMatch[1].trim();
+  }
+  const routes = [];
+  const wwwRedirects = new Set;
+  const redirMatches = content.matchAll(/^([^{\n]+)\s*\{[^{}]*?redir\s+https?:\/\/([^\s\n{/]+)/gm);
+  for (const rm of redirMatches) {
+    const fromDomain = rm[1].trim();
+    if (fromDomain.startsWith("www.")) {
+      wwwRedirects.add(fromDomain);
+    }
+  }
+  const blockRegex = /^([^{\n]+)\s*\{([\s\S]*?)^\}/gm;
+  let blockMatch;
+  while ((blockMatch = blockRegex.exec(content)) !== null) {
+    const header = blockMatch[1].trim();
+    const body = blockMatch[2];
+    if (!header || header.startsWith("#"))
+      continue;
+    const proxyMatches = [...body.matchAll(/reverse_proxy\s+([^\s\n{}]+)/g)];
+    if (proxyMatches.length === 0) {
+      continue;
+    }
+    const upstream = proxyMatches[0][1];
+    const rawDomains = header.split(",").map((d) => d.trim()).filter((d) => d && !d.startsWith("#"));
+    const domains = [];
+    for (const d of rawDomains) {
+      const clean = d.replace(/:\d+$/, "");
+      if (!domains.includes(clean)) {
+        domains.push(clean);
+      }
+      const wwwVariant = `www.${clean}`;
+      if (wwwRedirects.has(wwwVariant) && !domains.includes(wwwVariant)) {
+        domains.push(wwwVariant);
+      }
+    }
+    if (domains.length > 0) {
+      routes.push({
+        projectName,
+        domains,
+        upstream,
+        filePath: filename
+      });
+    }
+  }
+  if (routes.length === 0) {
+    const proxyMatch = content.match(/reverse_proxy\s+([^\s\n{}]+)/);
+    if (proxyMatch) {
+      routes.push({
+        projectName,
+        domains: [projectName],
+        upstream: proxyMatch[1],
+        filePath: filename
+      });
+    }
+  }
+  return routes;
+}
+function matchContainerForRoute(upstream, projectName, containers) {
+  const parts = upstream.split(":");
+  const upstreamHost = parts[0];
+  for (const c of containers) {
+    const cleanName = c.name.replace(/^\//, "");
+    if (cleanName === upstreamHost) {
+      return c;
+    }
+  }
+  for (const c of containers) {
+    const cleanName = c.name.replace(/^\//, "");
+    if (cleanName.startsWith(`${upstreamHost}-`) || cleanName.includes(upstreamHost)) {
+      return c;
+    }
+  }
+  let serviceName = upstreamHost;
+  if (upstreamHost.startsWith(`${projectName}-`)) {
+    serviceName = upstreamHost.slice(projectName.length + 1);
+  }
+  for (const c of containers) {
+    if (c.composeProject === projectName && c.composeService === serviceName) {
+      return c;
+    }
+  }
+  for (const c of containers) {
+    if (c.composeProject === projectName) {
+      return c;
+    }
+  }
+  for (const c of containers) {
+    const cleanName = c.name.replace(/^\//, "");
+    if (cleanName.startsWith(`${projectName}-`) || cleanName.startsWith(projectName)) {
+      return c;
+    }
+  }
+  return null;
+}
+function formatDockerStatus(container) {
+  if (!container) {
+    return {
+      displayStatus: "\x1B[31m\uD83D\uDD34 Offline\x1B[0m",
+      state: "offline",
+      statusText: "Offline"
+    };
+  }
+  const state = container.state.toLowerCase();
+  const rawStatus = container.status || state;
+  if (state === "running") {
+    const text = rawStatus.startsWith("Up") ? rawStatus : "Up";
+    return {
+      displayStatus: `\x1B[32m\uD83D\uDFE2 ${text}\x1B[0m`,
+      state: "running",
+      statusText: text
+    };
+  }
+  if (state === "restarting") {
+    return {
+      displayStatus: `\x1B[33m\uD83D\uDFE1 ${rawStatus}\x1B[0m`,
+      state: "restarting",
+      statusText: rawStatus
+    };
+  }
+  return {
+    displayStatus: `\x1B[31m\uD83D\uDD34 ${rawStatus || "Offline"}\x1B[0m`,
+    state: state || "exited",
+    statusText: rawStatus || "Offline"
+  };
+}
+async function getDockerContainers() {
+  try {
+    const res = await runCommand("docker", ["ps", "-a", "--format", "{{json .}}"]);
+    if (!res.success || !res.stdout.trim()) {
+      return [];
+    }
+    const lines = res.stdout.trim().split(`
+`);
+    const containers = [];
+    for (const line of lines) {
+      try {
+        const item = JSON.parse(line.trim());
+        const labels = item.Labels || "";
+        const projectMatch = labels.match(/com\.docker\.compose\.project=([^,]+)/);
+        const serviceMatch = labels.match(/com\.docker\.compose\.service=([^,]+)/);
+        containers.push({
+          id: item.ID || "",
+          name: item.Names || "",
+          image: item.Image || "",
+          state: (item.State || "").toLowerCase(),
+          status: item.Status || "",
+          networks: (item.Networks || "").split(",").map((n) => n.trim()),
+          composeProject: projectMatch ? projectMatch[1] : undefined,
+          composeService: serviceMatch ? serviceMatch[1] : undefined
+        });
+      } catch {}
+    }
+    return containers;
+  } catch {
+    return [];
+  }
+}
+async function handleList(options) {
+  const isJson = options.json ?? false;
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const confDir = path5.join(gatewayDir, "conf.d");
+  const routes = [];
+  try {
+    const files = await fs5.readdir(confDir);
+    for (const file of files) {
+      if (!file.endsWith(".caddy"))
+        continue;
+      const filePath = path5.join(confDir, file);
+      try {
+        const content = await fs5.readFile(filePath, "utf-8");
+        const parsed = parseCaddyProjectFile(content, file);
+        routes.push(...parsed);
+      } catch {}
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  if (routes.length === 0) {
+    if (isJson) {
+      console.log(JSON.stringify([], null, 2));
+      return;
+    }
+    console.log(`
+ℹ️  No projects currently deployed to Pegas gateway.`);
+    console.log(`   Run 'pegas deploy' inside a project directory to launch your first service.
+`);
+    return;
+  }
+  const containers = await getDockerContainers();
+  const items = routes.map((route) => {
+    const matchedContainer = matchContainerForRoute(route.upstream, route.projectName, containers);
+    const { displayStatus, state, statusText } = formatDockerStatus(matchedContainer);
+    return {
+      project: route.projectName,
+      domains: route.domains,
+      upstream: route.upstream,
+      status: statusText,
+      state,
+      displayStatus,
+      container: matchedContainer ? matchedContainer.name.replace(/^\//, "") : undefined,
+      containerId: matchedContainer?.id
+    };
+  });
+  items.sort((a, b) => a.project.localeCompare(b.project));
+  if (isJson) {
+    const cleanJson = items.map(({ displayStatus, ...rest }) => rest);
+    console.log(JSON.stringify(cleanJson, null, 2));
+    return;
+  }
+  console.log(`
+\uD83D\uDE80 \x1B[1mPegas Global Dashboard\x1B[0m — Active Projects in ${gatewayDir}:
+`);
+  const headers = ["PROJECT", "DOMAINS", "UPSTREAM", "STATUS"];
+  const rows = items.map((item) => [
+    item.project,
+    item.domains.join(", "),
+    item.upstream,
+    item.displayStatus
+  ]);
+  console.log(renderTable({ headers, rows }));
+  console.log(`
+Total: ${items.length} active route${items.length === 1 ? "" : "s"}
+`);
+}
+
+// src/dns.ts
+import dns from "node:dns/promises";
+import https from "node:https";
+function fetchIpFromUrl(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: timeoutMs }, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      let data = "";
+      res.setEncoding("utf-8");
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => resolve(data.trim()));
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+    req.on("error", reject);
+  });
+}
+async function getPublicIp(timeoutMs = 2500) {
+  if (process.env.PEGAS_SERVER_IP) {
+    return process.env.PEGAS_SERVER_IP.trim();
+  }
+  try {
+    return await fetchIpFromUrl("https://api.ipify.org", timeoutMs);
+  } catch {
+    return await fetchIpFromUrl("https://icanhazip.com", timeoutMs);
+  }
+}
+function isPublicDomain(domain) {
+  const clean = domain.trim().toLowerCase();
+  if (!clean || clean === "yourdomain.com")
+    return false;
+  if (clean === "localhost" || clean.endsWith(".localhost"))
+    return false;
+  if (clean.endsWith(".local") || clean.endsWith(".test") || clean.endsWith(".internal"))
+    return false;
+  if (/^(\d{1,3}\.){3}\d{1,3}$/.test(clean) || clean.includes(":"))
+    return false;
+  return clean.includes(".");
+}
+async function validateDomains(domains, options = {}) {
+  if (options.skipDnsCheck || !domains || domains.length === 0) {
+    return { valid: true, warnings: [] };
+  }
+  const targets = [...new Set(domains.map((d) => d.trim()))].filter(isPublicDomain);
+  if (targets.length === 0) {
+    return { valid: true, warnings: [] };
+  }
+  let serverIp = options.serverIp;
+  if (!serverIp) {
+    try {
+      serverIp = await getPublicIp();
+    } catch {
+      const msg = "⚠️  Warning: Unable to determine server's public IP. Skipping DNS pre-flight verification.";
+      if (!options.json) {
+        console.warn(msg);
+      }
+      return { valid: true, warnings: [msg] };
+    }
+  }
+  const warnings = [];
+  let hasMismatches = false;
+  for (const domain of targets) {
+    try {
+      const records = await dns.resolve4(domain);
+      if (!records.includes(serverIp)) {
+        const warn = `⚠️  DNS Warning: '${domain}' resolves to ${records.join(", ")}, but this server's public IP is ${serverIp}.
+    Let's Encrypt SSL certificate issuance will fail until DNS propagates.`;
+        warnings.push(warn);
+        hasMismatches = true;
+        if (!options.json) {
+          console.warn(`
+${warn}`);
+        }
+      }
+    } catch (err) {
+      if (err.code === "ENOTFOUND" || err.code === "ENODATA") {
+        const warn = `⚠️  DNS Warning: '${domain}' does not resolve to any IPv4 address (ENOTFOUND).
+    Let's Encrypt SSL certificate issuance will fail until DNS propagates.`;
+        warnings.push(warn);
+        hasMismatches = true;
+        if (!options.json) {
+          console.warn(`
+${warn}`);
+        }
+      } else {
+        const warn = `⚠️  DNS Warning: Failed to query DNS for '${domain}': ${err.message}`;
+        warnings.push(warn);
+        if (!options.json) {
+          console.warn(`
+${warn}`);
+        }
+      }
+    }
+  }
+  if (hasMismatches && options.strictDns) {
+    const errMsg = "❌ Error: Strict DNS check failed (--strict-dns). Deploy aborted to prevent Let's Encrypt rate limits.";
+    if (!options.json) {
+      console.error(`
+${errMsg}`);
+    }
+    return {
+      valid: false,
+      warnings,
+      serverIp
+    };
+  }
+  return {
+    valid: !hasMismatches,
+    warnings,
+    serverIp
+  };
+}
+
+// src/commands/deploy.ts
+async function waitForContainerReadiness(projectRoot, serviceName, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const pollIntervalMs = options.pollIntervalMs ?? 500;
+  const defaultGrace = process.env.PEGAS_DEPLOY_GRACE_MS !== undefined ? parseInt(process.env.PEGAS_DEPLOY_GRACE_MS, 10) : 3000;
+  const gracePeriodMs = options.gracePeriodMs ?? defaultGrace;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    let containerId = "";
+    try {
+      const psRes = child_process.execFileSync("docker", ["compose", "ps", "-q", serviceName], { cwd: projectRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 3000 });
+      containerId = psRes.trim().split(`
+`)[0]?.trim();
+    } catch {}
+    if (!containerId) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+      continue;
+    }
+    try {
+      const inspectRes = child_process.execFileSync("docker", ["inspect", containerId], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+      const inspectData = JSON.parse(inspectRes);
+      if (Array.isArray(inspectData) && inspectData.length > 0) {
+        const state = inspectData[0].State;
+        if (state) {
+          const status = state.Status?.toLowerCase();
+          if (status === "exited" || status === "dead") {
+            return {
+              ready: false,
+              service: serviceName,
+              containerId,
+              reason: `Container exited unexpectedly (exit code ${state.ExitCode})`
+            };
+          }
+          if (status === "running") {
+            if (state.Health) {
+              const healthStatus = state.Health.Status?.toLowerCase();
+              if (healthStatus === "healthy") {
+                return { ready: true, service: serviceName, containerId };
+              }
+              if (healthStatus === "unhealthy") {
+                return {
+                  ready: false,
+                  service: serviceName,
+                  containerId,
+                  reason: `Container healthcheck failed: status is '${state.Health.Status}'`
+                };
+              }
+            } else {
+              if (gracePeriodMs > 0) {
+                await new Promise((r) => setTimeout(r, gracePeriodMs));
+              }
+              return { ready: true, service: serviceName, containerId };
+            }
+          }
+        }
+      }
+    } catch {}
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+  return {
+    ready: false,
+    service: serviceName,
+    reason: `Timed out waiting for service '${serviceName}' to become ready after ${timeoutMs / 1000}s`
+  };
+}
+function resolveScopedUpstream(upstream, projectName) {
+  const parts = upstream.split(":");
+  const host = parts[0];
+  const port = parts[1] || "3000";
+  if (!host)
+    return upstream;
+  if (host.startsWith(`${projectName}-`)) {
+    return upstream;
+  }
+  if (host === "localhost" || host === "127.0.0.1" || /^(\d{1,3}\.){3}\d{1,3}$/.test(host)) {
+    return upstream;
+  }
+  return `${projectName}-${host}:${port}`;
+}
+async function handleDeploy(options = {}) {
+  const isJson = options.json ?? false;
+  const cwd = options.cwd || process.cwd();
+  const projectRoot = await findProjectRoot(cwd) || cwd;
+  const contractPath = path6.join(projectRoot, CONTRACT_FILENAME);
+  let rawContract;
+  try {
+    rawContract = await fs6.readFile(contractPath, "utf-8");
+  } catch {
+    if (isJson) {
+      console.log(JSON.stringify({
+        error: `Contract '${CONTRACT_FILENAME}' not found. Run 'pegas init' first.`
+      }));
+    } else {
+      console.error(`❌ Error: Contract '${CONTRACT_FILENAME}' not found in project root (${projectRoot}).`);
+      console.error(`   Run 'pegas init' to generate it.`);
+    }
+    if (!options.noExit) {
+      if (!options.noExit) {
+        process.exit(1);
+      }
+      return;
+    }
+    return;
+  }
+  let contract;
+  try {
+    contract = JSON.parse(rawContract);
+  } catch (err) {
+    if (isJson) {
+      console.log(JSON.stringify({
+        error: `Failed to parse '${path6.basename(contractPath)}': Invalid JSON syntax.`,
+        details: err.message
+      }));
+    } else {
+      console.error(`❌ Error: Failed to parse '${path6.basename(contractPath)}': Invalid JSON syntax.`);
+      console.error(`   ${err.message}`);
+    }
+    if (!options.noExit) {
+      if (!options.noExit) {
+        process.exit(1);
+      }
+      return;
+    }
+    return;
+  }
+  const projectName = contract.projectName || path6.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]/g, "_");
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const caddyfilePath = path6.join(gatewayDir, "Caddyfile");
+  try {
+    await fs6.access(caddyfilePath);
+  } catch {
+    if (!options.dryRun) {
+      if (!isJson) {
+        console.log("ℹ️  Server gateway not initialized yet. Auto-bootstrapping Pegas on the fly...");
+      }
+      await handleServerInit({ gatewayDir, json: options.json });
+    }
+  }
+  const requestedDomains = [];
+  for (const [, serviceConfig] of Object.entries(contract.services || {})) {
+    for (const d of serviceConfig.domains?.prod || []) {
+      const norm = normalizeDomain(d);
+      if (norm && norm !== "yourdomain.com") {
+        if (!requestedDomains.includes(norm)) {
+          requestedDomains.push(norm);
+        }
+        const parts = norm.split(".");
+        if (!norm.startsWith("www.") && parts.length === 2) {
+          const wwwVar = `www.${norm}`;
+          if (!requestedDomains.includes(wwwVar)) {
+            requestedDomains.push(wwwVar);
+          }
+        }
+      }
+    }
+  }
+  const projectRouteFile = getProjectRouteFilePath(gatewayDir, projectName);
+  const confDir = path6.join(gatewayDir, "conf.d");
+  const currentProjectFileName = path6.basename(projectRouteFile);
+  try {
+    const existingFiles = await fs6.readdir(confDir);
+    for (const file of existingFiles) {
+      if (!file.endsWith(".caddy") || file === currentProjectFileName) {
+        continue;
+      }
+      const otherFilePath = path6.join(confDir, file);
+      const otherContent = await fs6.readFile(otherFilePath, "utf-8");
+      const otherRoutes = parseCaddyProjectFile(otherContent, file);
+      for (const route of otherRoutes) {
+        for (const claimedDomain of route.domains) {
+          if (requestedDomains.includes(claimedDomain)) {
+            const conflictErr = `Domain '${claimedDomain}' is already owned by project '${route.projectName}' (in ${file}).`;
+            if (isJson) {
+              console.log(JSON.stringify({
+                error: "Domain collision",
+                domain: claimedDomain,
+                ownerProject: route.projectName,
+                ownerFile: file
+              }));
+            } else {
+              console.error(`
+❌ Error: ${conflictErr}`);
+              console.error(`   Deploy aborted to prevent route hijacking.`);
+            }
+            if (!options.noExit) {
+              process.exit(1);
+            }
+            return;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {}
+  }
+  if (!options.skipDnsCheck && requestedDomains.length > 0) {
+    const dnsResult = await validateDomains(requestedDomains, {
+      skipDnsCheck: options.skipDnsCheck,
+      strictDns: options.strictDns,
+      serverIp: options.serverIp,
+      json: isJson,
+      noExit: options.noExit
+    });
+    if (!dnsResult.valid && options.strictDns) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          error: "Strict DNS validation failed",
+          warnings: dnsResult.warnings,
+          serverIp: dnsResult.serverIp
+        }));
+      }
+      if (!options.noExit) {
+        process.exit(1);
+      }
+      return;
+    }
+  }
+  if (!options.dryRun && !options.skipUp) {
+    if (!isJson) {
+      console.log(`
+\uD83D\uDE80 [1/3] Starting project containers with Docker Compose...`);
+    }
+    try {
+      child_process.execSync("docker compose up -d", {
+        stdio: "inherit",
+        cwd: projectRoot
+      });
+    } catch (err) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          error: "Failed to execute 'docker compose up -d'",
+          details: err.message
+        }));
+      } else {
+        console.error("❌ Error: Failed to execute 'docker compose up -d':", err.message);
+      }
+      if (!options.noExit) {
+        process.exit(1);
+      }
+      return;
+    }
+    if (!options.skipReadiness) {
+      const servicesToCheck = [];
+      for (const [sName, sCfg] of Object.entries(contract.services || {})) {
+        if (Array.isArray(sCfg.domains?.prod) && sCfg.domains.prod.length > 0) {
+          servicesToCheck.push(sName);
+        }
+      }
+      if (servicesToCheck.length > 0) {
+        if (!isJson) {
+          console.log(`
+⏳ Checking container readiness for: ${servicesToCheck.join(", ")}...`);
+        }
+        for (const sName of servicesToCheck) {
+          const checkRes = await waitForContainerReadiness(projectRoot, sName, {
+            timeoutMs: options.readinessTimeoutMs,
+            gracePeriodMs: options.gracePeriodMs
+          });
+          if (!checkRes.ready) {
+            const errMsg = `Service '${sName}' failed readiness check: ${checkRes.reason}`;
+            if (isJson) {
+              console.log(JSON.stringify({ error: errMsg, service: sName, reason: checkRes.reason }));
+            } else {
+              console.error(`
+❌ Error: ${errMsg}`);
+              console.error(`   Deployment aborted before updating Caddy routes.`);
+            }
+            if (!options.noExit) {
+              if (!options.noExit) {
+                process.exit(1);
+              }
+              return;
+            }
+            return;
+          }
+          if (!isJson) {
+            console.log(`  \uD83D\uDFE2 Service '${sName}' is ready to accept traffic`);
+          }
+        }
+      }
+    }
+  }
+  const snippets = [];
+  const deployedRoutes = [];
+  const services = contract.services || {};
+  for (const [serviceName, serviceConfig] of Object.entries(services)) {
+    const prodDomains = serviceConfig.domains?.prod;
+    const upstream = serviceConfig.upstream;
+    if (!Array.isArray(prodDomains) || prodDomains.length === 0) {
+      continue;
+    }
+    if (!upstream) {
+      if (!isJson) {
+        console.warn(`⚠️  Warning: Service '${serviceName}' has prod domains but no upstream. Skipping.`);
+      }
+      continue;
+    }
+    const scopedUpstream = resolveScopedUpstream(upstream, projectName);
+    for (const domain of prodDomains) {
+      const normDomain = normalizeDomain(domain);
+      if (!normDomain)
+        continue;
+      if (normDomain === "yourdomain.com") {
+        if (!isJson) {
+          console.warn(`⚠️  Warning: Service '${serviceName}' has placeholder domain 'yourdomain.com'. Skipping.`);
+        }
+        continue;
+      }
+      const snippet = generateCaddyfileSnippet({
+        domain: normDomain,
+        upstream: scopedUpstream
+      });
+      snippets.push(snippet);
+      deployedRoutes.push({
+        service: serviceName,
+        domain: normDomain,
+        upstream: scopedUpstream
+      });
+    }
+  }
+  if (options.dryRun) {
+    if (!isJson) {
+      console.log(`
+\uD83D\uDCCB [dry-run] Target project route file: ${projectRouteFile}`);
+      for (const r of deployedRoutes) {
+        console.log(`  - Route: https://${r.domain} -> ${r.upstream}`);
+      }
+      if (snippets.length === 0) {
+        console.log("  (No production domains to configure)");
+      }
+    } else {
+      console.log(JSON.stringify({ status: "dry-run", project: projectName, file: projectRouteFile, routes: deployedRoutes }));
+    }
+    return;
+  }
+  let originalContent = null;
+  try {
+    originalContent = await fs6.readFile(projectRouteFile, "utf-8");
+  } catch {}
+  let fileModified = false;
+  if (snippets.length > 0) {
+    const combinedCaddyfile = `# Auto-generated by Pegas for project: ${projectName}
+# Do not edit manually; update pegas.json instead.
+
+` + snippets.join(`
+
+`) + `
+`;
+    await fs6.mkdir(path6.dirname(projectRouteFile), { recursive: true });
+    await fs6.writeFile(projectRouteFile, combinedCaddyfile, "utf-8");
+    await fs6.chmod(projectRouteFile, 420).catch(() => {});
+    fileModified = true;
+    if (!isJson) {
+      console.log(`
+\uD83D\uDCC4 [2/3] Generated route config: ${projectRouteFile}`);
+      for (const r of deployedRoutes) {
+        console.log(`  ✓ Route: https://${r.domain} -> ${r.upstream}`);
+      }
+    }
+  } else if (originalContent !== null) {
+    await fs6.unlink(projectRouteFile).catch(() => {});
+    fileModified = true;
+    if (!isJson) {
+      console.log(`
+\uD83D\uDDD1️  [2/3] Removed old project route config: ${projectRouteFile}`);
+    }
+  } else {
+    if (!isJson) {
+      console.log(`
+ℹ️  [2/3] No active production domains found in 'pegas.json'.`);
+    }
+  }
+  if (fileModified) {
+    if (!isJson) {
+      console.log(`
+\uD83D\uDD04 [3/3] Validating and hot-reloading Caddy gateway...`);
+    }
+    const reloaded = await handleReload({
+      gatewayDir,
+      json: options.json,
+      silent: isJson,
+      exitOnError: false
+    });
+    if (!reloaded) {
+      if (!isJson) {
+        console.error("⚠️  Hot reload failed. Rolling back route configuration...");
+      }
+      if (originalContent !== null) {
+        await fs6.writeFile(projectRouteFile, originalContent, "utf-8");
+      } else {
+        await fs6.unlink(projectRouteFile).catch(() => {});
+      }
+      if (!options.noExit) {
+        process.exit(1);
+      }
+      return;
+    }
+  }
+  if (isJson) {
+    console.log(JSON.stringify({
+      status: "success",
+      project: projectName,
+      routeFile: projectRouteFile,
+      routes: deployedRoutes
+    }));
+    return;
+  }
+  console.log(`
+\uD83C\uDF89 Project '${projectName}' successfully deployed to Pegas gateway!
+`);
+}
+
+// src/commands/down.ts
+import fs7 from "node:fs/promises";
+import path7 from "node:path";
+import child_process2 from "node:child_process";
+async function handleDown(options = {}) {
+  const isJson = options.json ?? false;
+  const cwd = options.cwd || process.cwd();
+  const projectRoot = await findProjectRoot(cwd) || cwd;
+  let projectName = path7.basename(projectRoot).toLowerCase().replace(/[^a-z0-9._-]/g, "_");
+  try {
+    const rawContract = await fs7.readFile(path7.join(projectRoot, CONTRACT_FILENAME), "utf-8");
+    const contract = JSON.parse(rawContract);
+    if (contract.projectName) {
+      projectName = contract.projectName;
+    }
+  } catch {}
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const routeFilePath = getProjectRouteFilePath(gatewayDir, projectName);
+  let fileRemoved = false;
+  try {
+    await fs7.unlink(routeFilePath);
+    fileRemoved = true;
+    if (!isJson) {
+      console.log(`
+\uD83D\uDDD1️  [1/2] Removed project route file: ${routeFilePath}`);
+    }
+  } catch {
+    if (!isJson) {
+      console.log(`
+ℹ️  [1/2] No route file found for project '${projectName}' at ${routeFilePath}`);
+    }
+  }
+  if (fileRemoved) {
+    if (!isJson) {
+      console.log("\uD83D\uDD04 Reloading Caddy gateway...");
+    }
+    await handleReload({
+      gatewayDir,
+      json: options.json,
+      silent: false,
+      exitOnError: false
+    });
+  }
+  if (!options.skipComposeDown) {
+    if (!isJson) {
+      console.log(`
+\uD83D\uDED1 [2/2] Stopping project containers with 'docker compose down'...
+`);
+    }
+    try {
+      child_process2.execSync("docker compose down", {
+        stdio: "inherit",
+        cwd: projectRoot
+      });
+    } catch (err) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          error: "Failed to execute 'docker compose down'",
+          details: err.message
+        }));
+      } else {
+        console.error("❌ Error: Failed to execute 'docker compose down':", err.message);
+      }
+      process.exit(1);
+    }
+  }
+  if (isJson) {
+    console.log(JSON.stringify({
+      status: "success",
+      project: projectName,
+      routeFile: routeFilePath,
+      fileRemoved
+    }));
+    return;
+  }
+  console.log(`
+✨ Project '${projectName}' taken down and routes cleaned up successfully.
+`);
+}
+
+// src/commands/dev.ts
+import fs9 from "node:fs/promises";
+import path9 from "node:path";
+import child_process4 from "node:child_process";
+
+// src/binary.ts
+import fs8 from "node:fs/promises";
+import path8 from "node:path";
+import os3 from "node:os";
+import child_process3 from "node:child_process";
+async function findOrDownloadCaddy(options = {}) {
+  const isWin = process.platform === "win32";
+  const binaryName = isWin ? "caddy.exe" : "caddy";
+  if (process.env.CADDY_PATH) {
+    try {
+      await fs8.access(process.env.CADDY_PATH);
+      return process.env.CADDY_PATH;
+    } catch {}
+  }
+  try {
+    const whichCmd = isWin ? `where ${binaryName}` : `which ${binaryName}`;
+    const sysPath = child_process3.execSync(whichCmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split(`
+`)[0].trim();
+    if (sysPath) {
+      return sysPath;
+    }
+  } catch {}
+  const cacheDir = path8.join(os3.homedir(), ".pegas", "bin");
+  const cachedBinary = path8.join(cacheDir, binaryName);
+  try {
+    await fs8.access(cachedBinary);
+    return cachedBinary;
+  } catch {}
+  if (!options.silent) {
+    console.log("⬇️  Caddy binary not found in PATH or cache. Downloading official release...");
+  }
+  await fs8.mkdir(cacheDir, { recursive: true });
+  const platformMap = {
+    linux: "linux",
+    darwin: "mac",
+    win32: "windows"
+  };
+  const archMap = {
+    x64: "amd64",
+    arm64: "arm64",
+    arm: "armv7"
+  };
+  const plat = platformMap[process.platform];
+  const arch = archMap[process.arch];
+  if (!plat || !arch) {
+    throw new Error(`Unsupported platform or architecture for Caddy: ${process.platform}/${process.arch}`);
+  }
+  const version = "2.9.1";
+  const ext = isWin ? "zip" : "tar.gz";
+  const filename = `caddy_${version}_${plat}_${arch}.${ext}`;
+  const url = `https://github.com/caddyserver/caddy/releases/download/v${version}/${filename}`;
+  const archivePath = path8.join(cacheDir, filename);
+  const res = await fetch(url, { redirect: "follow" });
+  if (!res.ok) {
+    throw new Error(`Failed to download Caddy from ${url}: ${res.status} ${res.statusText}`);
+  }
+  const buffer = Buffer.from(await res.arrayBuffer());
+  await fs8.writeFile(archivePath, buffer);
+  if (isWin) {
+    child_process3.execSync(`tar -xf "${archivePath}" -C "${cacheDir}" "${binaryName}"`);
+  } else {
+    child_process3.execSync(`tar -xzf "${archivePath}" -C "${cacheDir}" "${binaryName}"`);
+    await fs8.chmod(cachedBinary, 493);
+  }
+  await fs8.unlink(archivePath).catch(() => {});
+  if (!options.silent) {
+    console.log(`✓ Caddy installed to ${cachedBinary}`);
+  }
+  return cachedBinary;
+}
+
+// src/ports.ts
+import net from "node:net";
+function isPortAvailable(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.once("error", () => {
+      resolve(false);
+    });
+    const options = { port };
+    if (host) {
+      options.host = host;
+    }
+    server.listen(options, () => {
+      server.close(() => {
+        resolve(true);
+      });
+    });
+  });
+}
+async function findAvailablePort(startPort, exclude = []) {
+  let port = startPort;
+  while (port < 65535) {
+    if (!exclude.includes(port)) {
+      const free = await isPortAvailable(port);
+      if (free) {
+        return port;
+      }
+    }
+    port++;
+  }
+  throw new Error(`No available port found starting from ${startPort}`);
+}
+
+// src/commands/dev.ts
+function generateDevCaddyfile(contract, ports = { httpsPort: 8443, httpPort: 8080 }) {
+  const globalBlock = `{
+    admin off
+    http_port ${ports.httpPort}
+    https_port ${ports.httpsPort}
+    skip_install_trust
+}`;
+  const blocks = [globalBlock];
+  const services = contract.services || {};
+  for (const [, serviceConfig] of Object.entries(services)) {
+    const devDomains = serviceConfig.domains?.dev;
+    if (!Array.isArray(devDomains) || devDomains.length === 0) {
+      continue;
+    }
+    let port = "3000";
+    if (serviceConfig.upstream) {
+      const match = serviceConfig.upstream.match(/:(\d+)$/);
+      if (match) {
+        port = match[1];
+      }
+    }
+    const domainList = devDomains.map((d) => d.trim()).filter(Boolean).join(", ");
+    if (!domainList)
+      continue;
+    blocks.push(`${domainList} {
+    reverse_proxy localhost:${port}
+}`);
+  }
+  if (blocks.length === 1) {
+    blocks.push(`app.localhost {
+    reverse_proxy localhost:3000
+}`);
+  }
+  return `# Auto-generated by pegas dev. Do not edit manually.
+
+` + blocks.join(`
+
+`) + `
+`;
+}
+async function handleDev(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const projectRoot = await findProjectRoot(cwd) || cwd;
+  const contractPath = path9.join(projectRoot, CONTRACT_FILENAME);
+  let contractRaw;
+  try {
+    contractRaw = await fs9.readFile(contractPath, "utf-8");
+  } catch {
+    console.error(`❌ Error: Contract '${CONTRACT_FILENAME}' not found in project root (${projectRoot}).`);
+    console.error(`   Run 'pegas init' first to generate the contract.`);
+    if (!options.noExit) {
+      process.exit(1);
+    }
+    return;
+  }
+  let contract;
+  try {
+    contract = JSON.parse(contractRaw);
+  } catch (err) {
+    console.error(`❌ Error: Failed to parse '${path9.basename(contractPath)}': Invalid JSON syntax.`);
+    console.error(`   ${err.message}`);
+    if (!options.noExit) {
+      process.exit(1);
+    }
+    return;
+  }
+  let shouldBoot = false;
+  if (options.infra === true) {
+    shouldBoot = true;
+  } else if (options.infra === false || options.skipInfra === true) {
+    shouldBoot = false;
+  } else if (contract.bootInfra !== undefined) {
+    shouldBoot = Boolean(contract.bootInfra);
+  }
+  let startedInfraServices = [];
+  const composeFile = await findRootCompose(projectRoot);
+  if (composeFile) {
+    try {
+      const composeContent = await fs9.readFile(path9.join(projectRoot, composeFile), "utf-8");
+      const infraServices = detectInfraServices(composeContent);
+      if (infraServices.length > 0) {
+        if (shouldBoot) {
+          console.log(`\uD83D\uDCE6 Booting project infrastructure with Docker Compose...`);
+          const serviceNames = infraServices.map((s) => s.name);
+          try {
+            child_process4.execFileSync("docker", ["compose", "up", "-d", ...serviceNames], {
+              cwd: projectRoot,
+              stdio: "pipe"
+            });
+            startedInfraServices = serviceNames;
+            for (const s of infraServices) {
+              const port = s.hostPort || (s.containerPort ? String(s.containerPort) : "ready");
+              console.log(`\uD83D\uDFE2 Infra [${s.name}] is ready on localhost:${port}`);
+            }
+            console.log("");
+          } catch (err) {
+            console.warn(`⚠️  Warning: Failed to auto-start infra services: ${err.message}
+`);
+          }
+        } else {
+          const list = infraServices.map((s) => s.name).join(", ");
+          console.log(`\uD83D\uDCA1 Tip: Detected infra services (${list}). Pass '--infra' or set '"bootInfra": true' in ${CONTRACT_FILENAME} to auto-boot.
+`);
+        }
+      }
+    } catch {}
+  }
+  const httpsPort = await findAvailablePort(8443);
+  const httpPort = await findAvailablePort(8080, [httpsPort]);
+  const caddyPath = await findOrDownloadCaddy();
+  const devCaddyDir = path9.join(projectRoot, ".pegas");
+  await fs9.mkdir(devCaddyDir, { recursive: true });
+  const devCaddyfilePath = path9.join(devCaddyDir, "Caddyfile.dev");
+  const caddyfileContent = generateDevCaddyfile(contract, { httpsPort, httpPort });
+  await fs9.writeFile(devCaddyfilePath, caddyfileContent, "utf-8");
+  console.log("\uD83D\uDD12 Starting local Caddy HTTPS proxy...");
+  const caddyProc = child_process4.spawn(caddyPath, ["run", "--config", devCaddyfilePath], {
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd: projectRoot
+  });
+  let caddyStderr = "";
+  caddyProc.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    caddyStderr += text;
+    if (text.includes("bind: address already in use") || text.includes("permission denied")) {
+      console.error(`
+❌ Caddy error: ${text.trim()}`);
+    }
+  });
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  if (caddyProc.exitCode !== null) {
+    console.error("❌ Failed to start Caddy proxy:");
+    console.error(caddyStderr);
+    if (!options.noExit) {
+      process.exit(1);
+    }
+    return;
+  }
+  const devUrls = [];
+  for (const s of Object.values(contract.services || {})) {
+    for (const d of s.domains?.dev || []) {
+      devUrls.push(`https://${d}:${httpsPort}`);
+    }
+  }
+  if (devUrls.length === 0) {
+    devUrls.push(`https://app.localhost:${httpsPort}`);
+  }
+  for (const u of devUrls) {
+    console.log(`\uD83D\uDE80 Pegas proxy active at: ${u}`);
+  }
+  let userProc = null;
+  const userCmdArgs = options.command || [];
+  const isWin = process.platform === "win32";
+  let isCleaningUp = false;
+  function cleanup(exitCode = 0) {
+    if (isCleaningUp)
+      return;
+    isCleaningUp = true;
+    if (caddyProc && !caddyProc.killed) {
+      try {
+        caddyProc.kill("SIGTERM");
+      } catch {}
+    }
+    if (userProc && !userProc.killed && userProc.pid) {
+      try {
+        if (isWin) {
+          userProc.kill("SIGTERM");
+        } else {
+          process.kill(-userProc.pid, "SIGTERM");
+        }
+      } catch {}
+    }
+    if (startedInfraServices.length > 0) {
+      try {
+        console.log(`
+\uD83D\uDED1 Stopping infrastructure services: ${startedInfraServices.join(", ")}...`);
+        child_process4.execFileSync("docker", ["compose", "stop", ...startedInfraServices], {
+          cwd: projectRoot,
+          stdio: "pipe"
+        });
+      } catch {}
+    }
+    if (!options.noExit) {
+      process.exit(exitCode);
+    }
+  }
+  process.on("SIGINT", () => cleanup(0));
+  process.on("SIGTERM", () => cleanup(0));
+  caddyProc.on("exit", (code) => {
+    if (!isCleaningUp) {
+      console.log(`
+⚠️  Caddy proxy exited with code ${code}`);
+      cleanup(code || 0);
+    }
+  });
+  if (userCmdArgs.length > 0) {
+    const cmdBinary = userCmdArgs[0];
+    const cmdArgs = userCmdArgs.slice(1);
+    const cmdStr = userCmdArgs.join(" ");
+    console.log(`\uD83D\uDCE6 Running command: ${cmdStr}
+`);
+    await new Promise((resolve) => {
+      userProc = child_process4.spawn(cmdBinary, cmdArgs, {
+        shell: isWin,
+        stdio: "inherit",
+        cwd: projectRoot,
+        detached: !isWin
+      });
+      userProc.on("exit", (code) => {
+        cleanup(code || 0);
+        resolve();
+      });
+      userProc.on("error", (err) => {
+        console.error(`❌ Failed to start command '${cmdStr}':`, err.message);
+        cleanup(1);
+        resolve();
+      });
+    });
+  } else {
+    console.log("\uD83D\uDCA1 Caddy proxy running in foreground. Press Ctrl+C to stop.");
+    await new Promise(() => {});
+  }
+}
+
+// src/commands/add.ts
+import fs10 from "node:fs/promises";
+import path10 from "node:path";
+async function createOrUpdateRouteFile(options) {
+  const routeFilePath = getRouteFilePath(options.gatewayDir, options.domain);
+  let alreadyExists = false;
+  let originalContent = null;
+  try {
+    originalContent = await fs10.readFile(routeFilePath, "utf-8");
+    alreadyExists = true;
+  } catch {}
+  const snippet = generateCaddyfileSnippet(options);
+  await fs10.writeFile(routeFilePath, snippet, "utf-8");
+  return { routeFilePath, snippet, alreadyExists, originalContent };
+}
+async function handleAdd(options) {
+  const isJson = options.json ?? false;
+  if (!options.domain) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Missing domain argument. Usage: pegas add <domain> --upstream <service:port>" }));
+    } else {
+      console.error("❌ Error: Missing domain name. Usage: pegas add <domain> --upstream <service:port>");
+    }
+    process.exit(1);
+  }
+  if (!options.upstream) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Missing --upstream argument. Usage: pegas add <domain> --upstream <service:port>" }));
+    } else {
+      console.error("❌ Error: Missing --upstream argument. Usage: pegas add <domain> --upstream <service:port>");
+    }
+    process.exit(1);
+  }
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const caddyfilePath = path10.join(gatewayDir, "Caddyfile");
+  try {
+    await fs10.access(caddyfilePath);
+  } catch {
+    if (!options.dryRun) {
+      if (!isJson) {
+        console.log("ℹ️  Server gateway not initialized yet. Auto-bootstrapping Pegas on the fly...");
+      }
+      await handleServerInit({ gatewayDir, json: options.json });
+    }
+  }
+  const routeFilePath = getRouteFilePath(gatewayDir, options.domain);
+  let alreadyExists = false;
+  try {
+    await fs10.access(routeFilePath);
+    alreadyExists = true;
+  } catch {}
+  if (alreadyExists && !options.force && !options.dryRun) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: `Route for ${options.domain} already exists. Use --force to overwrite.` }));
+    } else {
+      console.error(`⚠️  Route for '${options.domain}' already exists at: ${routeFilePath}`);
+      console.error(`   Use '--force' flag to overwrite.`);
+    }
+    process.exit(1);
+  }
+  if (options.dryRun) {
+    const snippet = generateCaddyfileSnippet(options);
+    if (isJson) {
+      console.log(JSON.stringify({ domain: options.domain, snippet }));
+    } else {
+      console.log(`
+--- Preview of ${routeFilePath} ---
+`);
+      console.log(snippet);
+      console.log(`--- End of preview (dry run) ---
+`);
+    }
+    return;
+  }
+  const { originalContent } = await createOrUpdateRouteFile({
+    domain: options.domain,
+    upstream: options.upstream,
+    gatewayDir,
+    spa: options.spa,
+    apiUpstream: options.apiUpstream,
+    apiPrefix: options.apiPrefix,
+    noWww: options.noWww,
+    security: options.security
+  });
+  const validateRes = await validateCaddyConfig(gatewayDir);
+  if (!validateRes.success) {
+    if (originalContent !== null) {
+      await fs10.writeFile(routeFilePath, originalContent, "utf-8");
+    } else {
+      await fs10.unlink(routeFilePath).catch(() => {});
+    }
+    if (isJson) {
+      console.log(JSON.stringify({
+        error: "Caddy configuration validation failed. Changes were rolled back.",
+        details: validateRes.stderr || validateRes.stdout
+      }));
+    } else {
+      console.error("❌ Caddy configuration validation failed! Changes have been rolled back.");
+      console.error(validateRes.stderr || validateRes.stdout);
+    }
+    process.exit(1);
+  }
+  const reloadRes = await reloadCaddyConfig(gatewayDir);
+  if (!reloadRes.success) {
+    if (isJson) {
+      console.log(JSON.stringify({
+        error: "Failed to reload Caddy.",
+        details: reloadRes.stderr
+      }));
+    } else {
+      console.error("❌ Failed to reload Caddy:", reloadRes.stderr);
+    }
+    process.exit(1);
+  }
+  const composePatch = `services:
+  ${(options.upstream || "app:3000").split(":")[0]}:
+    networks:
+      pegas-network:
+        aliases:
+          - ${(options.upstream || "app:3000").split(":")[0]}
+
+networks:
+  pegas-network:
+    external: true`;
+  if (isJson) {
+    console.log(JSON.stringify({
+      status: "success",
+      domain: options.domain,
+      upstream: options.upstream || "app:3000",
+      configFile: routeFilePath,
+      composePatch
+    }));
+  } else {
+    console.log(`
+✅ Route for https://${options.domain} successfully configured and live!`);
+    console.log(`   Config:   ${routeFilePath}`);
+    console.log(`   Upstream: ${options.upstream || "app:3000"}`);
+    console.log(`   SSL:      Automatic Let's Encrypt (issued on first HTTP/HTTPS request)
+`);
+    console.log(`\uD83D\uDCCB Add this to your project's docker-compose.yml:
+`);
+    console.log(composePatch);
+    console.log(`
+`);
+  }
+}
+
+// src/commands/remove.ts
+import fs11 from "node:fs/promises";
+async function handleRemove(options) {
+  const isJson = options.json ?? false;
+  if (!options.domain) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Missing domain argument. Usage: pegas remove <domain>" }));
+    } else {
+      console.error("❌ Error: Missing domain argument. Usage: pegas remove <domain>");
+    }
+    process.exit(1);
+  }
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const routeFilePath = getRouteFilePath(gatewayDir, options.domain);
+  try {
+    await fs11.unlink(routeFilePath);
+  } catch (err) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: `Route for ${options.domain} not found.` }));
+    } else {
+      console.error(`❌ Route for '${options.domain}' not found at: ${routeFilePath}`);
+    }
+    process.exit(1);
+  }
+  const reloadRes = await reloadCaddyConfig(gatewayDir);
+  if (!reloadRes.success) {
+    if (isJson) {
+      console.log(JSON.stringify({ error: "Failed to reload Caddy.", details: reloadRes.stderr }));
+    } else {
+      console.error("❌ Failed to reload Caddy:", reloadRes.stderr);
+    }
+    process.exit(1);
+  }
+  if (isJson) {
+    console.log(JSON.stringify({ status: "success", domain: options.domain, removed: routeFilePath }));
+  } else {
+    console.log(`
+\uD83D\uDDD1️  Route for ${options.domain} removed and Caddy reloaded successfully.
+`);
+  }
+}
+
+// src/commands/status.ts
+async function handleStatus(options) {
+  const isJson = options.json ?? false;
+  const dockerOk = await checkDocker();
+  const composeOk = await checkDockerCompose();
+  const gatewayDir = await findGatewayDir(options.gatewayDir);
+  const netInspect = await runCommand("docker", ["network", "inspect", "pegas-network"]);
+  const networkOk = netInspect.success;
+  const containerStatus = await getGatewayContainerStatus(gatewayDir);
+  const isRunning = containerStatus.success && containerStatus.stdout.includes("caddy");
+  const routes = await listRoutes(gatewayDir);
+  if (isJson) {
+    console.log(JSON.stringify({
+      docker: dockerOk,
+      compose: composeOk,
+      gatewayDir,
+      network: { name: "pegas-network", exists: networkOk },
+      container: { running: isRunning, details: containerStatus.stdout },
+      activeRoutesCount: routes.length
+    }, null, 2));
+    return;
+  }
+  console.log(`
+\uD83D\uDCE1 Pegas Gateway Status:
+`);
+  console.log(`  Docker Engine:      ${dockerOk ? "✓ Active" : "✗ Offline"}`);
+  console.log(`  Docker Compose:     ${composeOk ? "✓ Available" : "✗ Missing"}`);
+  console.log(`  Docker Network:     ${networkOk ? "✓ 'pegas-network' exists" : "✗ 'pegas-network' missing"}`);
+  console.log(`  Gateway Location:   ${gatewayDir}`);
+  console.log(`  Caddy Container:    ${isRunning ? "✓ Running" : "✗ Stopped or not found"}`);
+  console.log(`  Configured Routes:  ${routes.length} domain(s)`);
+  console.log(`
+`);
+}
+
+// src/commands/llms.ts
+var LLMS_TXT_CONTENT = `# pegas
+
+> Agent-native zero-config Caddy reverse proxy for Docker multi-app VPS setups.
+
+## Core Concepts
+- Manages single reverse proxy (Caddy 2) listening on :80 and :443.
+- All Docker projects attach to a shared Docker bridge network named \`pegas-network\`.
+- Never expose 80:80 or 443:443 in application compose files.
+- Each project gets an isolated declarative drop-in configuration in \`conf.d/<projectName>.caddy\`.
+- Hot-reloads Caddy via API with zero downtime and automatic validation rollback.
+- Auto-provisions Let's Encrypt SSL on first request.
+
+## CLI Usage for Agents
+- \`npx @netrunner714/pegas init\` — Initialize gateway and Docker network on a clean VPS, or initialize a project with \`pegas.json\`.
+- \`npx pegas dev -- <command>\` — Local HTTPS proxy for dev domains without Docker.
+- \`npx pegas deploy\` — Declaratively deploy project containers and route Caddy domains from \`pegas.json\`.
+- \`npx pegas down\` — Tear down project containers and unbind Caddy routes.
+- \`npx pegas add <domain> --upstream <service:port>\` — Route a new domain to a container service.
+- \`npx pegas add <domain> --spa --upstream <client:80> --api-upstream <api:8000>\` — Route SPA + API.
+- \`npx pegas list --json\` — List all active routes.
+- \`npx pegas remove <domain>\` — Remove route and reload Caddy.
+- \`npx pegas status\` — Check Docker, network, and Caddy health.
+
+## Example Docker Compose Patch for Any App
+\`\`\`yaml
+services:
+  app:
+    networks:
+      pegas-network:
+        aliases:
+          - app
+
+networks:
+  pegas-network:
+    external: true
+\`\`\`
+`;
+function handleLlms(options) {
+  if (options.json) {
+    console.log(JSON.stringify({ llms: LLMS_TXT_CONTENT }));
+  } else {
+    console.log(LLMS_TXT_CONTENT);
+  }
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var HELP_TEXT = `pegas v${VERSION} — Agent-native Caddy gateway for multi-app VPS
+
+USAGE:
+  $ pegas <command> [options]
+
+COMMANDS:
+  init                     Init Pegas in current project (or --server for host)
+  dev [-- <command>]       Run local dev HTTPS proxy and start dev command (e.g. pegas dev -- next dev)
+  deploy                   Declarative deploy: configure Caddy routes from pegas.json and start containers
+  down                     Tear down project containers and remove Caddy routes
+  add <domain> [options]   Route a domain to an internal container upstream
+  list, ls                 List all active domain routes
+  remove, rm <domain>      Delete route and reload Caddy
+  reload                   Validate and hot-reload Caddy configuration
+  status                   Check Docker and gateway health
+  llms                     Print machine-readable LLM context
+
+OPTIONS FOR 'add':
+  -u, --upstream <target>  Upstream container:port (e.g. web:3000)
+      --spa                SPA mode (separate frontend and API proxying)
+      --api-upstream <tgt> Upstream for API backend (e.g. api:8000)
+      --api-prefix <pfx>   API path prefix (default: /api/*)
+      --no-www             Do not auto-generate www redirect
+      --force              Overwrite existing route file
+      --dry-run            Print generated config without applying
+
+OPTIONS FOR 'dev':
+      --infra              Boot infrastructure services defined in docker-compose.yml
+      --no-infra           Do not boot infrastructure services even if enabled in pegas.json
+
+OPTIONS FOR 'deploy':
+      --strict-dns         Abort deployment if DNS records do not match server IP
+      --skip-dns-check     Bypass DNS pre-flight verification
+
+GLOBAL OPTIONS:
+      --gateway-dir <path> Override path to gateway directory
+      --json               Output machine-readable JSON (ideal for AI agents)
+  -h, --help               Show this help message
+  -v, --version            Show version
+
+EXAMPLES:
+  $ pegas init
+  $ pegas add myapp.ru --upstream web:3000
+  $ pegas add api.myapp.ru --upstream api:8000
+  $ pegas list
+`;
+function tryLocalDelegation() {
+  if (process.env.PEGAS_DELEGATED) {
+    return;
+  }
+  const scopedTarget = path11.join(process.cwd(), "node_modules", "@netrunner714", "pegas", "dist", "index.js");
+  const unscopedTarget = path11.join(process.cwd(), "node_modules", "pegas", "dist", "index.js");
+  const localPegas = fs12.existsSync(scopedTarget) ? scopedTarget : fs12.existsSync(unscopedTarget) ? unscopedTarget : null;
+  if (!localPegas) {
+    return;
+  }
+  try {
+    const currentScript = fs12.realpathSync(process.argv[1] || "");
+    const targetScript = fs12.realpathSync(localPegas);
+    if (currentScript === targetScript) {
+      return;
+    }
+  } catch {}
+  const result = child_process5.spawnSync(process.execPath, [localPegas, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      PEGAS_DELEGATED: "1"
+    }
+  });
+  process.exit(result.status ?? (result.signal ? 1 : 0));
+}
+async function main() {
+  tryLocalDelegation();
+  const rawArgs = process.argv.slice(2);
+  const doubleDashIdx = rawArgs.indexOf("--");
+  const pegasArgs = doubleDashIdx !== -1 ? rawArgs.slice(0, doubleDashIdx) : rawArgs;
+  if (pegasArgs.length === 0 || pegasArgs.includes("-h") || pegasArgs.includes("--help")) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  if (pegasArgs.includes("-v") || pegasArgs.includes("--version")) {
+    console.log(`pegas v${VERSION}`);
+    return;
+  }
+  const { values, positionals } = parseArgs({
+    args: pegasArgs,
+    options: {
+      upstream: { type: "string", short: "u" },
+      spa: { type: "boolean", default: false },
+      "api-upstream": { type: "string" },
+      "api-prefix": { type: "string", default: "/api/*" },
+      "no-www": { type: "boolean", default: false },
+      force: { type: "boolean", default: false },
+      "dry-run": { type: "boolean", default: false },
+      "skip-up": { type: "boolean", default: false },
+      "skip-readiness": { type: "boolean", default: false },
+      "strict-dns": { type: "boolean", default: false },
+      "skip-dns-check": { type: "boolean", default: false },
+      infra: { type: "boolean" },
+      "no-infra": { type: "boolean" },
+      "gateway-dir": { type: "string" },
+      server: { type: "boolean", default: false },
+      project: { type: "boolean", default: false },
+      email: { type: "string" },
+      network: { type: "string" },
+      write: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const command = positionals[0]?.toLowerCase();
+  switch (command) {
+    case "init": {
+      await handleInit({
+        gatewayDir: values["gateway-dir"],
+        server: values.server,
+        project: values.project,
+        email: values.email,
+        networkName: values.network,
+        json: values.json
+      });
+      break;
+    }
+    case "dev": {
+      const userCmd = doubleDashIdx !== -1 ? rawArgs.slice(doubleDashIdx + 1) : positionals.slice(1);
+      let infra = undefined;
+      if (values["no-infra"]) {
+        infra = false;
+      } else if (values.infra) {
+        infra = true;
+      }
+      await handleDev({
+        command: userCmd,
+        infra
+      });
+      break;
+    }
+    case "deploy": {
+      await handleDeploy({
+        gatewayDir: values["gateway-dir"],
+        dryRun: values["dry-run"],
+        skipUp: values["skip-up"],
+        skipReadiness: values["skip-readiness"],
+        strictDns: values["strict-dns"],
+        skipDnsCheck: values["skip-dns-check"],
+        json: values.json
+      });
+      break;
+    }
+    case "down": {
+      await handleDown({
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "add": {
+      const domain = positionals[1];
+      await handleAdd({
+        domain: domain || "",
+        upstream: values.upstream,
+        spa: values.spa,
+        apiUpstream: values["api-upstream"],
+        apiPrefix: values["api-prefix"],
+        noWww: values["no-www"],
+        force: values.force,
+        dryRun: values["dry-run"],
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "list":
+    case "ls": {
+      await handleList({
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "remove":
+    case "rm": {
+      const domain = positionals[1];
+      await handleRemove({
+        domain: domain || "",
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "reload": {
+      await handleReload({
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "status": {
+      await handleStatus({
+        gatewayDir: values["gateway-dir"],
+        json: values.json
+      });
+      break;
+    }
+    case "llms": {
+      handleLlms({
+        json: values.json
+      });
+      break;
+    }
+    default: {
+      console.error(`Unknown command: '${command}'. Run 'pegas --help' for usage.`);
+      process.exit(1);
+    }
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});