dokku-compose 0.2.0

package/dist/index.js

@@ -0,0 +1,965 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import * as fs3 from "fs";
+import * as yaml3 from "js-yaml";
+
+// src/core/config.ts
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+
+// src/core/schema.ts
+import { z } from "zod";
+var PortSchema = z.string().regex(
+  /^(http|https|tcp|udp):\d+:\d+$/,
+  "Port must be scheme:host:container (e.g. http:80:3000)"
+);
+var EnvMapSchema = z.union([
+  z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
+  z.literal(false)
+]);
+var ChecksSchema = z.union([
+  z.literal(false),
+  z.object({
+    disabled: z.array(z.string()).optional(),
+    skipped: z.array(z.string()).optional()
+  }).catchall(z.union([z.string(), z.number(), z.boolean()]))
+]);
+var AppSchema = z.object({
+  domains: z.union([z.array(z.string()), z.literal(false)]).optional(),
+  links: z.array(z.string()).optional(),
+  ports: z.array(PortSchema).optional(),
+  env: EnvMapSchema.optional(),
+  ssl: z.union([
+    z.literal(false),
+    z.literal(true),
+    z.object({ certfile: z.string(), keyfile: z.string() })
+  ]).optional(),
+  storage: z.array(z.string()).optional(),
+  proxy: z.object({ enabled: z.boolean() }).optional(),
+  networks: z.array(z.string()).optional(),
+  network: z.object({
+    attach_post_create: z.union([z.array(z.string()), z.literal(false)]).optional(),
+    initial_network: z.union([z.string(), z.literal(false)]).optional(),
+    bind_all_interfaces: z.boolean().optional(),
+    tld: z.union([z.string(), z.literal(false)]).optional()
+  }).optional(),
+  nginx: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  logs: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  registry: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  scheduler: z.string().optional(),
+  checks: ChecksSchema.optional(),
+  build: z.object({
+    dockerfile: z.string().optional(),
+    app_json: z.string().optional(),
+    context: z.string().optional(),
+    args: z.record(z.string(), z.string()).optional()
+  }).optional(),
+  docker_options: z.object({
+    build: z.array(z.string()).optional(),
+    deploy: z.array(z.string()).optional(),
+    run: z.array(z.string()).optional()
+  }).optional()
+});
+var ServiceSchema = z.object({
+  plugin: z.string(),
+  version: z.string().optional(),
+  image: z.string().optional()
+});
+var PluginSchema = z.object({
+  url: z.string().url(),
+  version: z.string().optional()
+});
+var ConfigSchema = z.object({
+  dokku: z.object({
+    version: z.string().optional()
+  }).optional(),
+  plugins: z.record(z.string(), PluginSchema).optional(),
+  networks: z.array(z.string()).optional(),
+  services: z.record(z.string(), ServiceSchema).optional(),
+  apps: z.record(z.string(), AppSchema),
+  domains: z.union([z.array(z.string()), z.literal(false)]).optional(),
+  env: EnvMapSchema.optional(),
+  nginx: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  logs: z.record(z.string(), z.union([z.string(), z.number()])).optional()
+});
+function parseConfig(raw) {
+  return ConfigSchema.parse(raw);
+}
+
+// src/core/config.ts
+function loadConfig(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Config file not found: ${filePath}`);
+  }
+  const raw = yaml.load(fs.readFileSync(filePath, "utf8"));
+  return parseConfig(raw);
+}
+
+// src/core/dokku.ts
+import { execa } from "execa";
+function createRunner(opts = {}) {
+  const log = [];
+  async function execDokku(args) {
+    if (opts.host) {
+      try {
+        const result = await execa("ssh", [`dokku@${opts.host}`, ...args]);
+        return { stdout: result.stdout, ok: true };
+      } catch (e) {
+        return { stdout: e.stdout ?? "", ok: false };
+      }
+    } else {
+      try {
+        const result = await execa("dokku", args);
+        return { stdout: result.stdout, ok: true };
+      } catch (e) {
+        return { stdout: e.stdout ?? "", ok: false };
+      }
+    }
+  }
+  return {
+    dryRunLog: log,
+    async run(...args) {
+      if (opts.dryRun) {
+        log.push(args.join(" "));
+        return;
+      }
+      await execDokku(args);
+    },
+    async query(...args) {
+      if (opts.dryRun) return "";
+      const { stdout } = await execDokku(args);
+      return stdout.trim();
+    },
+    async check(...args) {
+      if (opts.dryRun) return false;
+      const { ok } = await execDokku(args);
+      return ok;
+    }
+  };
+}
+
+// src/core/logger.ts
+import chalk from "chalk";
+function logAction(context, message) {
+  process.stdout.write(chalk.blue(`[${context.padEnd(12)}]`) + ` ${message}`);
+}
+function logDone() {
+  console.log(`... ${chalk.green("done")}`);
+}
+function logSkip() {
+  console.log(`... ${chalk.yellow("already configured")}`);
+}
+
+// src/modules/apps.ts
+async function ensureApp(runner, app) {
+  const exists = await runner.check("apps:exists", app);
+  logAction(app, "Creating app");
+  if (exists) {
+    logSkip();
+    return;
+  }
+  await runner.run("apps:create", app);
+  logDone();
+}
+async function destroyApp(runner, app) {
+  const exists = await runner.check("apps:exists", app);
+  logAction(app, "Destroying app");
+  if (!exists) {
+    logSkip();
+    return;
+  }
+  await runner.run("apps:destroy", app, "--force");
+  logDone();
+}
+async function exportApps(runner) {
+  const output = await runner.query("apps:list");
+  return output.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+
+// src/modules/domains.ts
+async function ensureAppDomains(runner, app, domains) {
+  if (domains === void 0) return;
+  logAction(app, "Configuring domains");
+  if (domains === false) {
+    await runner.run("domains:disable", app);
+    await runner.run("domains:clear", app);
+  } else {
+    await runner.run("domains:enable", app);
+    await runner.run("domains:set", app, ...domains);
+  }
+  logDone();
+}
+async function ensureGlobalDomains(runner, domains) {
+  logAction("global", "Configuring domains");
+  if (domains === false) {
+    await runner.run("domains:clear-global");
+  } else {
+    await runner.run("domains:set-global", ...domains);
+  }
+  logDone();
+}
+async function exportAppDomains(runner, app) {
+  const enabledRaw = await runner.query("domains:report", app, "--domains-app-enabled");
+  if (enabledRaw.trim() === "false") return false;
+  const raw = await runner.query("domains:report", app, "--domains-app-vhosts");
+  const vhosts = raw.split("\n").map((s) => s.trim()).filter(Boolean);
+  if (vhosts.length === 0) return void 0;
+  return vhosts;
+}
+
+// src/modules/plugins.ts
+async function ensurePlugins(runner, plugins) {
+  const listOutput = await runner.query("plugin:list");
+  const installedNames = new Set(
+    listOutput.split("\n").map((line) => line.trim().split(/\s+/)[0]).filter(Boolean)
+  );
+  for (const [name, config] of Object.entries(plugins)) {
+    logAction("plugins", `Installing ${name}`);
+    if (installedNames.has(name)) {
+      logSkip();
+      continue;
+    }
+    await runner.run("plugin:install", config.url, "--name", name);
+    logDone();
+  }
+}
+
+// src/modules/network.ts
+async function ensureNetworks(runner, networks) {
+  for (const net of networks) {
+    logAction("network", `Creating ${net}`);
+    const exists = await runner.check("network:exists", net);
+    if (exists) {
+      logSkip();
+      continue;
+    }
+    await runner.run("network:create", net);
+    logDone();
+  }
+}
+async function ensureAppNetworks(runner, app, networks) {
+  if (!networks || networks.length === 0) return;
+  logAction(app, "Setting networks");
+  await runner.run("network:set", app, "attach-post-deploy", ...networks);
+  logDone();
+}
+async function ensureAppNetwork(runner, app, network) {
+  if (!network) return;
+  if (network.attach_post_create !== void 0 && network.attach_post_create !== false) {
+    const nets = Array.isArray(network.attach_post_create) ? network.attach_post_create : [network.attach_post_create];
+    await runner.run("network:set", app, "attach-post-create", ...nets);
+  }
+  if (network.initial_network !== void 0 && network.initial_network !== false) {
+    await runner.run("network:set", app, "initial-network", network.initial_network);
+  }
+  if (network.bind_all_interfaces !== void 0) {
+    await runner.run("network:set", app, "bind-all-interfaces", String(network.bind_all_interfaces));
+  }
+  if (network.tld !== void 0 && network.tld !== false) {
+    await runner.run("network:set", app, "tld", network.tld);
+  }
+}
+async function exportNetworks(runner) {
+  const output = await runner.query("network:list");
+  return output.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+async function exportAppNetwork(runner, app) {
+  const output = await runner.query("network:report", app);
+  if (!output) return void 0;
+  const result = {};
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const [key, ...valueParts] = line.split(":").map((s) => s.trim());
+    const value = valueParts.join(":").trim();
+    if (!key || !value) continue;
+    if (key === "Network attach post deploy") {
+      result.networks = value.split(" ").filter(Boolean);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/modules/services.ts
+async function ensureServices(runner, services) {
+  for (const [name, config] of Object.entries(services)) {
+    logAction("services", `Ensuring ${name}`);
+    const exists = await runner.check(`${config.plugin}:exists`, name);
+    if (exists) {
+      logSkip();
+      continue;
+    }
+    await runner.run(`${config.plugin}:create`, name);
+    logDone();
+  }
+}
+async function ensureAppLinks(runner, app, desiredLinks, allServices) {
+  const desiredSet = new Set(desiredLinks);
+  for (const [serviceName, serviceConfig] of Object.entries(allServices)) {
+    const isLinked = await runner.check(`${serviceConfig.plugin}:linked`, serviceName, app);
+    const isDesired = desiredSet.has(serviceName);
+    if (isDesired && !isLinked) {
+      logAction(app, `Linking ${serviceName}`);
+      await runner.run(`${serviceConfig.plugin}:link`, serviceName, app, "--no-restart");
+      logDone();
+    } else if (!isDesired && isLinked) {
+      logAction(app, `Unlinking ${serviceName}`);
+      await runner.run(`${serviceConfig.plugin}:unlink`, serviceName, app, "--no-restart");
+      logDone();
+    }
+  }
+}
+async function destroyAppLinks(runner, app, links, allServices) {
+  for (const serviceName of links) {
+    const config = allServices[serviceName];
+    if (!config) continue;
+    const isLinked = await runner.check(`${config.plugin}:linked`, serviceName, app);
+    if (isLinked) {
+      await runner.run(`${config.plugin}:unlink`, serviceName, app, "--no-restart");
+    }
+  }
+}
+async function destroyServices(runner, services) {
+  for (const [name, config] of Object.entries(services)) {
+    logAction("services", `Destroying ${name}`);
+    const exists = await runner.check(`${config.plugin}:exists`, name);
+    if (!exists) {
+      logSkip();
+      continue;
+    }
+    await runner.run(`${config.plugin}:destroy`, name, "--force");
+    logDone();
+  }
+}
+async function exportServices(_runner) {
+  return {};
+}
+async function exportAppLinks(runner, app, services) {
+  const linked = [];
+  for (const [serviceName, config] of Object.entries(services)) {
+    const isLinked = await runner.check(`${config.plugin}:linked`, serviceName, app);
+    if (isLinked) linked.push(serviceName);
+  }
+  return linked;
+}
+
+// src/modules/proxy.ts
+async function ensureAppProxy(runner, app, enabled) {
+  logAction(app, `Setting proxy enabled=${enabled}`);
+  const currentRaw = await runner.query("proxy:report", app, "--proxy-enabled");
+  const current = currentRaw.trim() === "true";
+  if (current === enabled) {
+    logSkip();
+    return;
+  }
+  if (enabled) {
+    await runner.run("proxy:enable", app);
+  } else {
+    await runner.run("proxy:disable", app);
+  }
+  logDone();
+}
+async function exportAppProxy(runner, app) {
+  const raw = await runner.query("proxy:report", app, "--proxy-enabled");
+  const enabled = raw.trim() === "true";
+  if (enabled) return void 0;
+  return { enabled };
+}
+
+// src/modules/ports.ts
+async function ensureAppPorts(runner, app, ports) {
+  logAction(app, "Configuring ports");
+  const currentRaw = await runner.query("ports:report", app, "--ports-map");
+  const current = currentRaw.split(/\s+/).map((s) => s.trim()).filter(Boolean).sort();
+  const desired = [...ports].sort();
+  if (JSON.stringify(current) === JSON.stringify(desired)) {
+    logSkip();
+    return;
+  }
+  await runner.run("ports:set", app, ...ports);
+  logDone();
+}
+async function exportAppPorts(runner, app) {
+  const raw = await runner.query("ports:report", app, "--ports-map");
+  const ports = raw.split(/\s+/).map((s) => s.trim()).filter(Boolean);
+  if (ports.length === 0) return void 0;
+  return ports;
+}
+
+// src/modules/certs.ts
+async function ensureAppCerts(runner, app, ssl) {
+  logAction(app, "Configuring SSL");
+  const enabledRaw = await runner.query("certs:report", app, "--ssl-enabled");
+  const enabled = enabledRaw.trim() === "true";
+  if (ssl === false) {
+    if (!enabled) {
+      logSkip();
+      return;
+    }
+    await runner.run("certs:remove", app);
+    logDone();
+    return;
+  }
+  if (ssl === true) {
+    if (enabled) {
+      logSkip();
+      return;
+    }
+    logSkip();
+    return;
+  }
+  if (enabled) {
+    logSkip();
+    return;
+  }
+  await runner.run("certs:add", app, ssl.certfile, ssl.keyfile);
+  logDone();
+}
+async function exportAppCerts(runner, app) {
+  const raw = await runner.query("certs:report", app, "--ssl-enabled");
+  const enabled = raw.trim() === "true";
+  if (!enabled) return void 0;
+  return true;
+}
+
+// src/modules/storage.ts
+async function ensureAppStorage(runner, app, storage) {
+  logAction(app, "Configuring storage");
+  const currentRaw = await runner.query("storage:report", app, "--storage-mounts");
+  const current = currentRaw.split("\n").map((s) => s.trim()).filter(Boolean);
+  const desired = new Set(storage);
+  const currentSet = new Set(current);
+  const toUnmount = current.filter((m) => !desired.has(m));
+  const toMount = storage.filter((m) => !currentSet.has(m));
+  if (toUnmount.length === 0 && toMount.length === 0) {
+    logSkip();
+    return;
+  }
+  for (const mount of toUnmount) {
+    await runner.run("storage:unmount", app, mount);
+  }
+  for (const mount of toMount) {
+    await runner.run("storage:mount", app, mount);
+  }
+  logDone();
+}
+async function exportAppStorage(runner, app) {
+  const raw = await runner.query("storage:report", app, "--storage-mounts");
+  const mounts = raw.split("\n").map((s) => s.trim()).filter(Boolean);
+  if (mounts.length === 0) return void 0;
+  return mounts;
+}
+
+// src/modules/nginx.ts
+async function ensureAppNginx(runner, app, nginx) {
+  for (const [key, value] of Object.entries(nginx)) {
+    await runner.run("nginx:set", app, key, String(value));
+  }
+}
+async function ensureGlobalNginx(runner, nginx) {
+  for (const [key, value] of Object.entries(nginx)) {
+    await runner.run("nginx:set", "--global", key, String(value));
+  }
+}
+async function exportAppNginx(runner, app) {
+  const raw = await runner.query("nginx:report", app);
+  if (!raw) return void 0;
+  const result = {};
+  for (const line of raw.split("\n")) {
+    const match = line.match(/^\s*Nginx\s+(.+?):\s*(.+?)\s*$/);
+    if (match) {
+      const key = match[1].toLowerCase().replace(/\s+/g, "-");
+      result[key] = match[2];
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/modules/checks.ts
+async function ensureAppChecks(runner, app, checks) {
+  logAction(app, "Configuring checks");
+  if (checks === false) {
+    await runner.run("checks:disable", app);
+    logDone();
+    return;
+  }
+  if (checks.disabled && checks.disabled.length > 0) {
+    await runner.run("checks:disable", app, ...checks.disabled);
+  }
+  if (checks.skipped && checks.skipped.length > 0) {
+    await runner.run("checks:skip", app, ...checks.skipped);
+  }
+  for (const [key, value] of Object.entries(checks)) {
+    if (key === "disabled" || key === "skipped") continue;
+    await runner.run("checks:set", app, key, String(value));
+  }
+  logDone();
+}
+async function exportAppChecks(runner, app) {
+  const raw = await runner.query("checks:report", app);
+  if (!raw) return void 0;
+  return void 0;
+}
+
+// src/modules/logs.ts
+async function ensureAppLogs(runner, app, logs) {
+  for (const [key, value] of Object.entries(logs)) {
+    await runner.run("logs:set", app, key, String(value));
+  }
+}
+async function ensureGlobalLogs(runner, logs) {
+  for (const [key, value] of Object.entries(logs)) {
+    await runner.run("logs:set", "--global", key, String(value));
+  }
+}
+async function exportAppLogs(runner, app) {
+  const raw = await runner.query("logs:report", app);
+  if (!raw) return void 0;
+  return void 0;
+}
+
+// src/modules/registry.ts
+async function ensureAppRegistry(runner, app, registry) {
+  for (const [key, value] of Object.entries(registry)) {
+    await runner.run("registry:set", app, key, String(value));
+  }
+}
+async function exportAppRegistry(runner, app) {
+  const raw = await runner.query("registry:report", app);
+  if (!raw) return void 0;
+  return void 0;
+}
+
+// src/modules/scheduler.ts
+async function ensureAppScheduler(runner, app, scheduler) {
+  logAction(app, `Setting scheduler to ${scheduler}`);
+  const current = await runner.query("scheduler:report", app, "--scheduler-selected");
+  if (current.trim() === scheduler) {
+    logSkip();
+    return;
+  }
+  await runner.run("scheduler:set", app, "selected", scheduler);
+  logDone();
+}
+async function exportAppScheduler(runner, app) {
+  const raw = await runner.query("scheduler:report", app, "--scheduler-selected");
+  const scheduler = raw.trim();
+  if (!scheduler || scheduler === "docker-local") return void 0;
+  return scheduler;
+}
+
+// src/modules/config.ts
+var MANAGED_KEYS_VAR = "DOKKU_COMPOSE_MANAGED_KEYS";
+async function ensureAppConfig(runner, app, env) {
+  logAction(app, "Configuring env vars");
+  if (env === false) {
+    logSkip();
+    return;
+  }
+  const prevManagedRaw = await runner.query("config:get", app, MANAGED_KEYS_VAR);
+  const prevManaged = prevManagedRaw.trim() ? prevManagedRaw.trim().split(",").filter(Boolean) : [];
+  const desiredKeys = Object.keys(env);
+  const toUnset = prevManaged.filter((k) => !desiredKeys.includes(k));
+  if (toUnset.length > 0) {
+    await runner.run("config:unset", "--no-restart", app, ...toUnset);
+  }
+  const pairs = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  const newManagedKeys = desiredKeys.join(",");
+  await runner.run(
+    "config:set",
+    "--no-restart",
+    app,
+    ...pairs,
+    `${MANAGED_KEYS_VAR}=${newManagedKeys}`
+  );
+  logDone();
+}
+async function ensureGlobalConfig(runner, env) {
+  if (env === false) return;
+  const pairs = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  await runner.run("config:set", "--global", ...pairs);
+}
+async function exportAppConfig(runner, app) {
+  const raw = await runner.query("config:export", app, "--format", "shell");
+  if (!raw) return void 0;
+  const result = {};
+  for (const line of raw.split("\n")) {
+    const match = line.match(/^export\s+(\w+)=['"]?(.*?)['"]?$/);
+    if (match && match[1] !== MANAGED_KEYS_VAR) {
+      result[match[1]] = match[2];
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/modules/builder.ts
+async function ensureAppBuilder(runner, app, build) {
+  if (build.dockerfile) {
+    await runner.run("builder-dockerfile:set", app, "dockerfile-path", build.dockerfile);
+  }
+  if (build.app_json) {
+    await runner.run("app-json:set", app, "appjson-path", build.app_json);
+  }
+  if (build.context) {
+    await runner.run("builder:set", app, "build-dir", build.context);
+  }
+  if (build.args && Object.keys(build.args).length > 0) {
+    for (const [key, value] of Object.entries(build.args)) {
+      await runner.run("docker-options:add", app, "build", `--build-arg ${key}=${value}`);
+    }
+  }
+}
+
+// src/modules/docker-options.ts
+async function ensureAppDockerOptions(runner, app, options) {
+  const phases = ["build", "deploy", "run"];
+  for (const phase of phases) {
+    const opts = options[phase];
+    if (!opts || opts.length === 0) continue;
+    await runner.run("docker-options:clear", app, phase);
+    for (const opt of opts) {
+      await runner.run("docker-options:add", app, phase, opt);
+    }
+  }
+}
+
+// src/commands/up.ts
+async function runUp(runner, config, appFilter) {
+  const apps = appFilter.length > 0 ? appFilter : Object.keys(config.apps);
+  if (config.plugins) await ensurePlugins(runner, config.plugins);
+  if (config.domains !== void 0) await ensureGlobalDomains(runner, config.domains);
+  if (config.env !== void 0) await ensureGlobalConfig(runner, config.env);
+  if (config.logs !== void 0) await ensureGlobalLogs(runner, config.logs);
+  if (config.nginx !== void 0) await ensureGlobalNginx(runner, config.nginx);
+  if (config.networks) await ensureNetworks(runner, config.networks);
+  if (config.services) await ensureServices(runner, config.services);
+  for (const app of apps) {
+    const appConfig = config.apps[app];
+    if (!appConfig) continue;
+    await ensureApp(runner, app);
+    await ensureAppDomains(runner, app, appConfig.domains);
+    if (config.services) await ensureAppLinks(runner, app, appConfig.links ?? [], config.services);
+    await ensureAppNetworks(runner, app, appConfig.networks);
+    await ensureAppNetwork(runner, app, appConfig.network);
+    if (appConfig.proxy) await ensureAppProxy(runner, app, appConfig.proxy.enabled);
+    if (appConfig.ports) await ensureAppPorts(runner, app, appConfig.ports);
+    if (appConfig.ssl !== void 0) await ensureAppCerts(runner, app, appConfig.ssl);
+    if (appConfig.storage) await ensureAppStorage(runner, app, appConfig.storage);
+    if (appConfig.nginx) await ensureAppNginx(runner, app, appConfig.nginx);
+    if (appConfig.checks !== void 0) await ensureAppChecks(runner, app, appConfig.checks);
+    if (appConfig.logs) await ensureAppLogs(runner, app, appConfig.logs);
+    if (appConfig.registry) await ensureAppRegistry(runner, app, appConfig.registry);
+    if (appConfig.scheduler) await ensureAppScheduler(runner, app, appConfig.scheduler);
+    if (appConfig.env !== void 0) await ensureAppConfig(runner, app, appConfig.env);
+    if (appConfig.build) await ensureAppBuilder(runner, app, appConfig.build);
+    if (appConfig.docker_options) await ensureAppDockerOptions(runner, app, appConfig.docker_options);
+  }
+}
+
+// src/commands/down.ts
+async function runDown(runner, config, appFilter, opts) {
+  const apps = appFilter.length > 0 ? appFilter : Object.keys(config.apps);
+  for (const app of apps) {
+    const appConfig = config.apps[app];
+    if (!appConfig) continue;
+    if (config.services && appConfig.links) {
+      await destroyAppLinks(runner, app, appConfig.links, config.services);
+    }
+    await destroyApp(runner, app);
+  }
+  if (config.services) {
+    await destroyServices(runner, config.services);
+  }
+  if (config.networks) {
+    for (const net of config.networks) {
+      logAction("network", `Destroying ${net}`);
+      const exists = await runner.check("network:exists", net);
+      if (!exists) {
+        logSkip();
+        continue;
+      }
+      await runner.run("network:destroy", net, "--force");
+      logDone();
+    }
+  }
+}
+
+// src/commands/export.ts
+async function runExport(runner, opts) {
+  const config = { apps: {} };
+  const apps = opts.appFilter?.length ? opts.appFilter : await exportApps(runner);
+  const networks = await exportNetworks(runner);
+  if (networks.length > 0) config.networks = networks;
+  const services = await exportServices(runner);
+  if (Object.keys(services).length > 0) config.services = services;
+  for (const app of apps) {
+    const appConfig = {};
+    const domains = await exportAppDomains(runner, app);
+    if (domains !== void 0) appConfig.domains = domains;
+    const links = await exportAppLinks(runner, app, services);
+    if (links.length > 0) appConfig.links = links;
+    const ports = await exportAppPorts(runner, app);
+    if (ports?.length) appConfig.ports = ports;
+    const proxy = await exportAppProxy(runner, app);
+    if (proxy !== void 0) appConfig.proxy = proxy;
+    const ssl = await exportAppCerts(runner, app);
+    if (ssl !== void 0) appConfig.ssl = ssl;
+    const storage = await exportAppStorage(runner, app);
+    if (storage?.length) appConfig.storage = storage;
+    const nginx = await exportAppNginx(runner, app);
+    if (nginx && Object.keys(nginx).length) appConfig.nginx = nginx;
+    const checks = await exportAppChecks(runner, app);
+    if (checks !== void 0) appConfig.checks = checks;
+    const logs = await exportAppLogs(runner, app);
+    if (logs && Object.keys(logs).length) appConfig.logs = logs;
+    const registry = await exportAppRegistry(runner, app);
+    if (registry && Object.keys(registry).length) appConfig.registry = registry;
+    const scheduler = await exportAppScheduler(runner, app);
+    if (scheduler) appConfig.scheduler = scheduler;
+    const networkCfg = await exportAppNetwork(runner, app);
+    if (networkCfg?.networks?.length) appConfig.networks = networkCfg.networks;
+    if (networkCfg?.network) appConfig.network = networkCfg.network;
+    const env = await exportAppConfig(runner, app);
+    if (env && Object.keys(env).length) appConfig.env = env;
+    config.apps[app] = appConfig;
+  }
+  return config;
+}
+
+// src/commands/diff.ts
+import chalk2 from "chalk";
+function computeDiff(desired, current) {
+  const result = { apps: {}, services: {}, inSync: true };
+  for (const [app, desiredApp] of Object.entries(desired.apps)) {
+    const currentApp = current.apps[app] ?? {};
+    const appDiff = {};
+    const features = [
+      "domains",
+      "ports",
+      "env",
+      "ssl",
+      "storage",
+      "nginx",
+      "logs",
+      "registry",
+      "scheduler",
+      "checks",
+      "networks",
+      "proxy",
+      "links"
+    ];
+    for (const feature of features) {
+      const d = desiredApp[feature];
+      const c = currentApp[feature];
+      if (d === void 0) continue;
+      const dStr = JSON.stringify(d);
+      const cStr = JSON.stringify(c);
+      if (c === void 0) {
+        appDiff[feature] = { status: "missing", desired: d, current: void 0 };
+        result.inSync = false;
+      } else if (dStr !== cStr) {
+        appDiff[feature] = { status: "changed", desired: d, current: c };
+        result.inSync = false;
+      } else {
+        appDiff[feature] = { status: "in-sync", desired: d, current: c };
+      }
+    }
+    result.apps[app] = appDiff;
+  }
+  for (const [svc] of Object.entries(desired.services ?? {})) {
+    const exists = current.services?.[svc];
+    if (!exists) {
+      result.services[svc] = { status: "missing" };
+      result.inSync = false;
+    } else {
+      result.services[svc] = { status: "in-sync" };
+    }
+  }
+  return result;
+}
+function formatSummary(diff) {
+  const lines = [""];
+  for (const [app, appDiff] of Object.entries(diff.apps)) {
+    const changes = Object.entries(appDiff).filter(([, d]) => d.status !== "in-sync");
+    if (changes.length === 0) {
+      lines.push(`  app: ${app}`);
+      lines.push(`    (in sync)`);
+    } else {
+      lines.push(`  app: ${chalk2.bold(app)}`);
+      for (const [feature, d] of changes) {
+        const sym = d.status === "missing" ? chalk2.green("+") : chalk2.yellow("~");
+        lines.push(`    ${sym} ${feature}: ${formatFeatureSummary(d)}`);
+      }
+    }
+  }
+  for (const [svc, d] of Object.entries(diff.services)) {
+    if (d.status === "missing") {
+      lines.push(`  services:`);
+      lines.push(`    ${chalk2.green("+")} ${svc}: not provisioned`);
+    }
+  }
+  const total = Object.values(diff.apps).flatMap((a) => Object.values(a)).filter((d) => d.status !== "in-sync").length + Object.values(diff.services).filter((d) => d.status !== "in-sync").length;
+  lines.push("");
+  if (total === 0) {
+    lines.push(chalk2.green("  Everything in sync."));
+  } else {
+    lines.push(chalk2.yellow(`  ${total} resource(s) out of sync.`));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatFeatureSummary(d) {
+  if (d.status === "missing") return "(not set on server)";
+  if (Array.isArray(d.desired) && Array.isArray(d.current)) {
+    return `${d.current.length} \u2192 ${d.desired.length} items`;
+  }
+  return `${JSON.stringify(d.current)} \u2192 ${JSON.stringify(d.desired)}`;
+}
+function formatVerbose(diff) {
+  const lines = [""];
+  for (const [app, appDiff] of Object.entries(diff.apps)) {
+    const changes = Object.entries(appDiff).filter(([, d]) => d.status !== "in-sync");
+    if (changes.length === 0) continue;
+    for (const [feature, d] of changes) {
+      lines.push(`@@ app: ${app} / ${feature} @@`);
+      const currentLines = d.current !== void 0 ? JSON.stringify(d.current, null, 2).split("\n") : [];
+      const desiredLines = JSON.stringify(d.desired, null, 2).split("\n");
+      for (const line of currentLines) lines.push(chalk2.red(`- ${line}`));
+      for (const line of desiredLines) lines.push(chalk2.green(`+ ${line}`));
+    }
+  }
+  for (const [svc, d] of Object.entries(diff.services)) {
+    if (d.status === "missing") {
+      lines.push(`@@ services @@`);
+      lines.push(chalk2.green(`+ ${svc}`));
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/validate.ts
+import * as fs2 from "fs";
+import * as yaml2 from "js-yaml";
+function validate(filePath) {
+  const errors = [];
+  const warnings = [];
+  if (!fs2.existsSync(filePath)) {
+    return { errors: [`File not found: ${filePath}`], warnings };
+  }
+  let raw;
+  try {
+    raw = yaml2.load(fs2.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    return { errors: [`YAML parse error: ${e.message}`], warnings };
+  }
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const issuePath = issue.path.join(".");
+      errors.push(`${issuePath}: ${issue.message}`);
+    }
+  }
+  const data = raw;
+  if (data?.apps && typeof data.apps === "object") {
+    const serviceNames = new Set(
+      data?.services && typeof data.services === "object" ? Object.keys(data.services) : []
+    );
+    for (const [appName, appCfg] of Object.entries(data.apps)) {
+      if (!appCfg?.links) continue;
+      for (const link of appCfg.links) {
+        if (!serviceNames.has(link)) {
+          errors.push(`apps.${appName}.links: service "${link}" not defined in services`);
+        }
+      }
+    }
+  }
+  if (data?.services && data?.plugins) {
+    const pluginNames = new Set(Object.keys(data.plugins));
+    for (const [svcName, svcCfg] of Object.entries(data.services)) {
+      if (svcCfg?.plugin && !pluginNames.has(svcCfg.plugin)) {
+        warnings.push(`services.${svcName}.plugin: "${svcCfg.plugin}" not declared in plugins (may be pre-installed)`);
+      }
+    }
+  }
+  return { errors, warnings };
+}
+
+// src/index.ts
+var program = new Command().name("dokku-compose").version("0.3.0");
+function makeRunner(opts) {
+  return createRunner({
+    host: process.env.DOKKU_HOST,
+    dryRun: opts.dryRun ?? false
+  });
+}
+program.command("up [apps...]").description("Create/update apps and services to match config").option("-f, --file <path>", "Config file", "dokku-compose.yml").option("--dry-run", "Print commands without executing").option("--fail-fast", "Stop on first error").action(async (apps, opts) => {
+  const config = loadConfig(opts.file);
+  const runner = makeRunner(opts);
+  await runUp(runner, config, apps);
+  if (opts.dryRun) {
+    console.log("\n# Commands that would run:");
+    for (const cmd of runner.dryRunLog) console.log(`dokku ${cmd}`);
+  }
+});
+program.command("down [apps...]").description("Destroy apps and services (requires --force)").option("-f, --file <path>", "Config file", "dokku-compose.yml").option("--force", "Required to destroy apps").action(async (apps, opts) => {
+  if (!opts.force) {
+    console.error("--force required");
+    process.exit(1);
+  }
+  const config = loadConfig(opts.file);
+  const runner = makeRunner({});
+  await runDown(runner, config, apps, { force: true });
+});
+program.command("validate [file]").description("Validate dokku-compose.yml without touching the server").action((file = "dokku-compose.yml") => {
+  const result = validate(file);
+  for (const w of result.warnings) console.warn(`WARN:  ${w}`);
+  for (const e of result.errors) console.error(`ERROR: ${e}`);
+  if (result.errors.length > 0) {
+    console.error(`
+${result.errors.length} error(s), ${result.warnings.length} warning(s)`);
+    process.exit(1);
+  }
+  if (result.warnings.length > 0) {
+    console.log(`
+0 errors, ${result.warnings.length} warning(s)`);
+  } else {
+    console.log("Valid.");
+  }
+});
+program.command("export").description("Export server state to dokku-compose.yml format").option("--app <app>", "Export only a specific app").option("-o, --output <path>", "Write to file instead of stdout").action(async (opts) => {
+  const runner = makeRunner({});
+  const result = await runExport(runner, {
+    appFilter: opts.app ? [opts.app] : void 0
+  });
+  const out = yaml3.dump(result, { lineWidth: 120 });
+  if (opts.output) {
+    fs3.writeFileSync(opts.output, out);
+    console.error(`Written to ${opts.output}`);
+  } else {
+    process.stdout.write(out);
+  }
+});
+program.command("diff").description("Show what is out of sync between config and server").option("-f, --file <path>", "Config file", "dokku-compose.yml").option("--verbose", "Show git-style +/- diff").action(async (opts) => {
+  const desired = loadConfig(opts.file);
+  const runner = makeRunner({});
+  const current = await runExport(runner, {
+    appFilter: Object.keys(desired.apps)
+  });
+  const diff = computeDiff(desired, current);
+  const output = opts.verbose ? formatVerbose(diff) : formatSummary(diff);
+  process.stdout.write(output);
+  process.exit(diff.inSync ? 0 : 1);
+});
+program.command("ps [apps...]").description("Show status of configured apps").option("-f, --file <path>", "Config file", "dokku-compose.yml").action(async (apps, opts) => {
+  const config = loadConfig(opts.file);
+  const runner = makeRunner({});
+  const { runPs } = await import("./ps-33II4UU3.js");
+  await runPs(runner, config, apps);
+});
+program.command("init [apps...]").description("Create a starter dokku-compose.yml").option("-f, --file <path>", "Config file", "dokku-compose.yml").action(async (apps, opts) => {
+  const { runInit } = await import("./init-GIXEVLNW.js");
+  runInit(opts.file, apps);
+});
+program.parse();