omnideploy-cli 0.0.0-stage → 0.1.0

package/dist/main.js

@@ -0,0 +1,2943 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { resolve as resolve2 } from "path";
+import { Command } from "commander";
+
+// src/cli/commands/auth.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function registerAuth(program2, env2) {
+  program2.command("login").description("Save an API token for a provider").argument("<provider>").option("-t, --token <token>", "token value (otherwise prompted; prefer the env var in CI)").action(async (provider, opts) => {
+    const c = env2.container();
+    await c.login.execute(provider, opts.token);
+    p.log.success(`Logged in to ${c.providers.get(provider).displayName}.`);
+  });
+  program2.command("logout").description("Remove a saved provider token").argument("<provider>").action(async (provider) => {
+    const c = env2.container();
+    const removed = await c.logout.execute(provider);
+    const name = c.providers.get(provider).displayName;
+    if (removed) p.log.success(`Logged out of ${name}.`);
+    else p.log.info(`No saved token for ${name}.`);
+    p.log.message(pc.dim(`(Tokens set via ${c.providers.get(provider).capabilities.auth.envVar} are not affected.)`));
+  });
+}
+
+// src/cli/commands/deploy.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/cli/presenters/format.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/domain/value-objects/Language.ts
+var LANGUAGE_LABELS = {
+  node: "Node.js",
+  python: "Python",
+  java: "Java",
+  go: "Go",
+  rust: "Rust",
+  ruby: "Ruby",
+  php: "PHP",
+  dotnet: ".NET",
+  static: "Static site",
+  docker: "Docker"
+};
+
+// src/domain/entities/ProjectProfile.ts
+function describeProfile(p11) {
+  const parts = [
+    LANGUAGE_LABELS[p11.language] + (p11.runtimeVersion ? ` ${p11.runtimeVersion}` : ""),
+    p11.framework,
+    p11.kind,
+    p11.kind === "static" ? p11.outputDir ? `output: ${p11.outputDir}` : void 0 : `port ${p11.port}`
+  ];
+  return parts.filter(Boolean).join(" \xB7 ");
+}
+
+// src/domain/entities/ProjectConfig.ts
+var emptyConfig = () => ({ providers: {} });
+function applyConfigOverrides(profile, config) {
+  if (!config) return profile;
+  return {
+    ...profile,
+    buildCommand: config.build?.command ?? profile.buildCommand,
+    outputDir: config.build?.output ?? profile.outputDir,
+    startCommand: config.app?.start ?? profile.startCommand,
+    port: config.app?.port ?? profile.port
+  };
+}
+
+// src/domain/errors/index.ts
+var DomainError = class extends Error {
+  constructor(message, hint, code = "DOMAIN_ERROR") {
+    super(message);
+    this.hint = hint;
+    this.code = code;
+    this.name = new.target.name;
+  }
+  hint;
+  code;
+};
+var UnsupportedProjectError = class extends DomainError {
+  constructor(rootDir) {
+    super(
+      `Could not detect a supported project in ${rootDir}.`,
+      "Add a Dockerfile, or set build/app settings in omnideploy.json.",
+      "UNSUPPORTED_PROJECT"
+    );
+  }
+};
+var IncompatibleProviderError = class extends DomainError {
+  constructor(provider, reason, suggestion) {
+    super(`${provider}: ${reason}`, suggestion, "INCOMPATIBLE_PROVIDER");
+  }
+};
+var UnknownProviderError = class extends DomainError {
+  constructor(id, known) {
+    super(`Unknown provider "${id}".`, `Available providers: ${known.join(", ")}`, "UNKNOWN_PROVIDER");
+  }
+};
+var MissingCredentialError = class extends DomainError {
+  constructor(provider, envVar) {
+    super(
+      `No credentials found for ${provider}.`,
+      `Run \`omnideploy login ${provider}\` or set ${envVar}.`,
+      "MISSING_CREDENTIAL"
+    );
+  }
+};
+var MissingToolError = class extends DomainError {
+  constructor(bin, install) {
+    super(`Required tool "${bin}" is not installed.`, `Install it with: ${install}`, "MISSING_TOOL");
+  }
+};
+var ConfigError = class extends DomainError {
+  constructor(message, hint) {
+    super(message, hint, "CONFIG_ERROR");
+  }
+};
+var BuildError = class extends DomainError {
+  constructor(command, output) {
+    super(
+      `Build failed: \`${command}\``,
+      output ? `Last output:
+${output}` : "Fix the build locally, or override it with build.command in omnideploy.json.",
+      "BUILD_FAILED"
+    );
+  }
+};
+var ProviderApiError = class extends DomainError {
+  constructor(provider, message, status, hint) {
+    super(`${provider} API error${status ? ` (${status})` : ""}: ${message}`, hint, "PROVIDER_API_ERROR");
+    this.status = status;
+  }
+  status;
+};
+var DeploymentFailedError = class extends DomainError {
+  constructor(provider, detail, hint) {
+    super(`${provider} deployment failed: ${detail}`, hint, "DEPLOYMENT_FAILED");
+  }
+};
+var GitError = class extends DomainError {
+  constructor(message, hint) {
+    super(message, hint, "GIT_ERROR");
+  }
+};
+var UserCancelledError = class extends DomainError {
+  constructor() {
+    super("Operation cancelled.", void 0, "CANCELLED");
+  }
+};
+
+// src/domain/services/CompatibilityPolicy.ts
+function checkCompatibility(profile, caps) {
+  if (profile.kind === "static") {
+    return caps.kinds.includes("static") ? { ok: true } : { ok: false, reason: "does not host static sites" };
+  }
+  if (profile.framework && caps.serverlessFrameworks?.includes(profile.framework)) {
+    return { ok: true };
+  }
+  if (!caps.kinds.includes("server")) {
+    const what = profile.framework ?? LANGUAGE_LABELS[profile.language];
+    return {
+      ok: false,
+      reason: !caps.kinds.includes("static") ? `cannot run ${what} apps` : caps.serverlessFrameworks?.length ? `only hosts static sites and ${listOf(caps.serverlessFrameworks)} apps, not ${what} servers` : `only hosts static sites, not ${what} servers`
+    };
+  }
+  if (caps.serverLanguages === "any") return { ok: true };
+  if (caps.serverLanguages.includes(profile.language)) return { ok: true };
+  return { ok: false, reason: `cannot run ${LANGUAGE_LABELS[profile.language]} server apps` };
+}
+function compatibleProviders(profile, providers, exclude) {
+  return providers.filter((p11) => p11.id !== exclude && checkCompatibility(profile, p11.capabilities).ok);
+}
+function suggestAlternatives(profile, providers, exclude) {
+  const alts = compatibleProviders(profile, providers, exclude).map((p11) => p11.displayName);
+  return alts.length > 0 ? `Deploy to ${listOf(alts)} instead.` : "No available provider can host this project yet.";
+}
+function listOf(items) {
+  return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} or ${items.at(-1)}`;
+}
+
+// src/domain/services/naming.ts
+function toServiceName(raw) {
+  const slug = raw.toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  return slug || "app";
+}
+
+// src/domain/services/spa.ts
+var SPA_FRAMEWORKS = /^(vite(-.+)?|create-react-app|angular)$/;
+function isSinglePageApp(profile) {
+  return profile.kind === "static" && SPA_FRAMEWORKS.test(profile.framework ?? "");
+}
+
+// src/cli/presenters/format.ts
+function table(headers, rows) {
+  const visible = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
+  const widths = headers.map((h, i) => Math.max(visible(h), ...rows.map((r) => visible(r[i] ?? ""))));
+  const line = (cells) => cells.map((c, i) => c + " ".repeat(widths[i] - visible(c))).join("  ").trimEnd();
+  return [pc2.bold(line(headers)), ...rows.map(line)].join("\n");
+}
+function presentError(error, debug) {
+  if (error instanceof UserCancelledError) {
+    p2.cancel("Cancelled.");
+    return 130;
+  }
+  if (error instanceof DomainError) {
+    p2.log.error(error.message);
+    if (error.hint) p2.log.message(`${pc2.cyan("Try:")} ${error.hint}`);
+    if (debug && error.stack) p2.log.message(pc2.dim(error.stack));
+    return 1;
+  }
+  p2.log.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+  if (debug && error instanceof Error && error.stack) p2.log.message(pc2.dim(error.stack));
+  else p2.log.message(pc2.dim("Re-run with --debug for details."));
+  return 1;
+}
+function describeError(error) {
+  if (error instanceof DomainError) return error.hint ? `${error.message}
+  ${pc2.cyan("Try:")} ${error.hint}` : error.message;
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli/commands/deploy.ts
+function registerDeploy(program2, env2) {
+  program2.command("deploy").description("Deploy to one or more providers (default: those in omnideploy.json)").argument("[providers...]", "e.g. vercel netlify github-pages railway render").option("--preview", "create a preview/draft deployment instead of production").option("--no-build", "skip the local build step").option("-d, --dir <path>", "deploy this directory as a static site").option("--dry-run", "show what would happen without deploying").option("-y, --yes", "answer yes to every prompt (CI mode)").option("-f, --force", "regenerate deployment files even if they exist").action(async (providers, opts) => {
+    const c = env2.container();
+    p3.intro(pc3.inverse(" omnideploy deploy "));
+    const report = await c.deploy.execute({
+      rootDir: env2.cwd(),
+      providerIds: providers,
+      production: !opts.preview,
+      skipBuild: !opts.build,
+      dir: opts.dir,
+      dryRun: opts.dryRun,
+      yes: opts.yes,
+      force: opts.force
+    });
+    if (report.dryRun) {
+      p3.outro("Dry run complete \u2014 nothing was deployed.");
+      return;
+    }
+    const rows = report.outcomes.map((o) => [
+      o.displayName,
+      o.ok ? o.deployment?.state === "ready" ? pc3.green("\u2714 live") : pc3.yellow("\u2026 building") : pc3.red("\u2716 failed"),
+      o.ok ? pc3.cyan(o.deployment?.url ?? "(no public URL)") : ""
+    ]);
+    p3.note(table(["Provider", "Status", "URL"], rows), "Deployments");
+    for (const o of report.outcomes.filter((o2) => !o2.ok)) p3.log.error(`${o.displayName}: ${describeError(o.error)}`);
+    const failed = report.outcomes.filter((o) => !o.ok).length;
+    if (failed > 0) {
+      process.exitCode = 1;
+      p3.outro(pc3.red(`${failed} of ${report.outcomes.length} deployment(s) failed.`));
+    } else {
+      p3.outro(pc3.green("All deployments finished."));
+    }
+  });
+}
+
+// src/cli/commands/doctor.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+var ICON = { ok: pc4.green("\u2714"), warn: pc4.yellow("\u25B2"), fail: pc4.red("\u2716") };
+function registerDoctor(program2, env2) {
+  program2.command("doctor").description("Check that everything needed to deploy this project is in place").action(async () => {
+    const c = env2.container();
+    p4.intro(pc4.inverse(" omnideploy doctor "));
+    const checks = await c.doctor.execute(env2.cwd(), { nodeVersion: process.version });
+    for (const ch of checks) {
+      p4.log.message(`${ICON[ch.status]} ${pc4.bold(ch.name)}: ${ch.detail}${ch.fix ? ch.fix.split("\n").map((f) => `
+  ${pc4.cyan("Fix:")} ${f}`).join("") : ""}`);
+    }
+    const failed = checks.filter((ch) => ch.status === "fail").length;
+    const warned = checks.filter((ch) => ch.status === "warn").length;
+    if (failed) process.exitCode = 1;
+    p4.outro(
+      failed ? pc4.red(`${failed} problem(s) to fix before deploying.`) : warned ? pc4.yellow(`Ready, with ${warned} warning(s).`) : pc4.green("Everything looks good!")
+    );
+  });
+}
+
+// src/cli/commands/generate.ts
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+function registerGenerate(program2, env2) {
+  program2.command("generate").alias("eject").description("Only write the deployment files (Dockerfile, render.yaml, ...) \u2014 deploy them however you like").argument("<providers...>", "providers to generate files for").option("-f, --force", "overwrite existing files").option("-y, --yes", "write without asking").option("--dry-run", "list the files without writing them").action(async (providerIds, opts) => {
+    const c = env2.container();
+    p5.intro(pc5.inverse(" omnideploy generate "));
+    const { profile, config } = await c.detect.execute(env2.cwd());
+    p5.log.success(`Detected ${describeProfile(profile)}`);
+    for (const id of providerIds) {
+      const provider = c.providers.get(id);
+      const compat = checkCompatibility(profile, provider.capabilities);
+      if (!compat.ok) throw new IncompatibleProviderError(provider.displayName, compat.reason, suggestAlternatives(profile, c.providers.all(), id));
+    }
+    const { planned, written } = await c.generate.execute({ profile, config, providerIds, ...opts });
+    const kept = planned.filter((a) => a.action === "keep").map((a) => a.path);
+    if (kept.length) p5.log.info(`Kept existing: ${kept.join(", ")} (use --force to regenerate)`);
+    p5.outro(written.length ? `Wrote ${written.length} file(s).` : opts.dryRun ? "Dry run \u2014 nothing written." : "Nothing to generate.");
+  });
+}
+
+// src/cli/commands/init.ts
+import * as p6 from "@clack/prompts";
+import pc6 from "picocolors";
+function registerInit(program2, env2) {
+  program2.command("init").description("Detect the project, pick providers, and generate deployment files + omnideploy.json").option("-p, --providers <ids>", "comma-separated providers (skips the prompt)").option("-y, --yes", "accept defaults and write files without asking").option("-f, --force", "overwrite existing deployment files").action(async (opts) => {
+    const c = env2.container();
+    p6.intro(pc6.inverse(" omnideploy init "));
+    const result = await c.init.execute({
+      rootDir: env2.cwd(),
+      providerIds: opts.providers?.split(",").map((s) => s.trim()).filter(Boolean),
+      yes: opts.yes,
+      force: opts.force
+    });
+    p6.outro(`Ready! Deploy with ${pc6.cyan(`omnideploy deploy${result.providerIds.length === 1 ? ` ${result.providerIds[0]}` : ""}`)}`);
+  });
+}
+
+// src/cli/commands/providers.ts
+import * as p7 from "@clack/prompts";
+import pc7 from "picocolors";
+function registerProviders(program2, env2) {
+  program2.command("providers").alias("ls").description("List providers, login state, required tools and compatibility with this project").action(async () => {
+    const c = env2.container();
+    let profile;
+    try {
+      profile = (await c.detect.execute(env2.cwd())).profile;
+    } catch {
+    }
+    const rows = await c.listProviders.execute(profile);
+    p7.log.message(
+      table(
+        ["Provider", "Id", "Hosts", "Auth", "CLI", ...profile ? ["Fits project"] : []],
+        rows.map((r) => [
+          r.displayName,
+          pc7.dim(r.id),
+          r.hosts,
+          r.auth ? pc7.green(`\u2714 ${r.auth}`) : pc7.yellow("login needed"),
+          r.cli ? r.cli.installed ? pc7.green(`\u2714 ${r.cli.bin}`) : pc7.red(`\u2716 ${r.cli.bin}`) : pc7.dim("\u2014"),
+          ...r.compatibility ? [r.compatibility.ok ? pc7.green("\u2714") : pc7.dim(`\u2716 ${r.compatibility.reason}`)] : []
+        ])
+      )
+    );
+    if (rows.some((r) => !r.auth)) p7.log.message(pc7.dim("Log in with `omnideploy login <id>` or set the provider env var."));
+  });
+}
+
+// src/cli/commands/status.ts
+import * as p8 from "@clack/prompts";
+import pc8 from "picocolors";
+function registerStatus(program2, env2) {
+  program2.command("status").description("Show the latest (or a specific) deployment for a provider").argument("<provider>").argument("[deploymentId]").action(async (provider, id) => {
+    const c = env2.container();
+    const s = await c.status.execute(env2.cwd(), provider, id);
+    const color = s.state === "ready" ? pc8.green : s.state === "error" ? pc8.red : pc8.yellow;
+    p8.note(
+      [`State:   ${color(s.state)}`, `ID:      ${s.id}`, s.url && `URL:     ${pc8.cyan(s.url)}`, s.createdAt && `Created: ${s.createdAt}`, s.message && `Info:    ${s.message}`].filter(Boolean).join("\n"),
+      c.providers.get(provider).displayName
+    );
+  });
+}
+
+// src/cli/container.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/application/services/ProviderRegistry.ts
+var ProviderRegistry = class {
+  byId;
+  constructor(providers) {
+    this.byId = new Map(providers.map((p11) => [p11.id, p11]));
+  }
+  all() {
+    return [...this.byId.values()];
+  }
+  ids() {
+    return [...this.byId.keys()];
+  }
+  get(id) {
+    const p11 = this.byId.get(id);
+    if (!p11) throw new UnknownProviderError(id, this.ids());
+    return p11;
+  }
+};
+
+// src/application/services/CredentialResolver.ts
+var CredentialResolver = class {
+  constructor(store, prompt) {
+    this.store = store;
+    this.prompt = prompt;
+  }
+  store;
+  prompt;
+  async resolve(provider, opts) {
+    const { envVar, tokenUrl } = provider.capabilities.auth;
+    const found = await this.store.get(provider.id, envVar);
+    if (found) return found.token;
+    if (!opts.allowPrompt || !this.prompt.interactive) {
+      throw new MissingCredentialError(provider.id, envVar);
+    }
+    this.prompt.note(`Create a token at:
+${tokenUrl}
+
+It will be saved for future deploys (or set ${envVar}).`, `${provider.displayName} login`);
+    const token = (await this.prompt.password(`Paste your ${provider.displayName} token`)).trim();
+    if (!token) throw new MissingCredentialError(provider.id, envVar);
+    await this.store.set(provider.id, token);
+    return token;
+  }
+};
+
+// src/application/services/serviceName.ts
+function resolveServiceName(profile, config) {
+  const raw = config?.name ?? profile.meta?.name ?? profile.rootDir.split(/[\\/]/).filter(Boolean).pop() ?? "app";
+  return toServiceName(raw);
+}
+
+// src/application/use-cases/DetectProject.ts
+var DetectProject = class {
+  constructor(detectors, configRepo) {
+    this.detectors = detectors;
+    this.configRepo = configRepo;
+  }
+  detectors;
+  configRepo;
+  async execute(rootDir) {
+    const [config, results] = await Promise.all([
+      this.configRepo.load(rootDir),
+      Promise.all(this.detectors.map((d) => d.detect(rootDir)))
+    ]);
+    const candidates = results.filter((r) => r !== null).sort((a, b) => b.confidence - a.confidence);
+    const best = candidates[0];
+    if (!best) {
+      if (config?.app?.start || config?.build?.output) {
+        const profile = applyConfigOverrides(
+          { rootDir, language: "docker", kind: config.app?.start ? "server" : "static", port: 8080, hasDockerfile: false },
+          config
+        );
+        return { profile, config, candidates };
+      }
+      throw new UnsupportedProjectError(rootDir);
+    }
+    return { profile: applyConfigOverrides(best.profile, config), config, candidates };
+  }
+};
+
+// src/application/use-cases/GenerateArtifacts.ts
+var GenerateArtifacts = class {
+  constructor(generators, providers, fs, prompt, logger) {
+    this.generators = generators;
+    this.providers = providers;
+    this.fs = fs;
+    this.prompt = prompt;
+    this.logger = logger;
+  }
+  generators;
+  providers;
+  fs;
+  prompt;
+  logger;
+  async plan(req) {
+    const serviceName = resolveServiceName(req.profile, req.config);
+    const byId = /* @__PURE__ */ new Map();
+    for (const providerId of req.providerIds) {
+      const provider = this.providers.get(providerId);
+      for (const id of provider.requiredArtifacts(req.profile)) {
+        const existing = byId.get(id);
+        if (existing) {
+          existing.providers.push(providerId);
+          continue;
+        }
+        const generator = this.generators.find((g) => g.id === id && g.supports(req.profile));
+        const exists = await this.fs.exists(this.fs.join(req.profile.rootDir, generator?.path ?? String(id)));
+        if (!generator) {
+          if (exists) continue;
+          throw new DomainError(
+            `${provider.displayName} needs a ${id} for this ${req.profile.language} project, but omnideploy has no template for it.`,
+            id === "dockerfile" ? "Add a Dockerfile to the project root and run the command again." : void 0,
+            "NO_GENERATOR"
+          );
+        }
+        const artifact = generator.generate(req.profile, {
+          providerId,
+          providerOptions: req.config?.providers[providerId] ?? {},
+          serviceName,
+          healthCheckPath: req.config?.app?.healthCheckPath
+        });
+        byId.set(id, {
+          ...artifact,
+          action: exists ? req.force ? "overwrite" : "keep" : "create",
+          providers: [providerId]
+        });
+      }
+    }
+    return [...byId.values()];
+  }
+  async execute(req) {
+    const planned = await this.plan(req);
+    const toWrite = planned.filter((a) => a.action !== "keep");
+    if (toWrite.length === 0) return { planned, written: [] };
+    this.prompt.note(
+      toWrite.map((a) => `${a.action === "create" ? "+" : "~"} ${a.path}  \u2014 ${a.description} (for ${a.providers.join(", ")})`).join("\n"),
+      req.dryRun ? "Would generate" : "Deployment files to generate"
+    );
+    if (req.dryRun) return { planned, written: [] };
+    if (!req.yes) {
+      if (!this.prompt.interactive) {
+        throw new DomainError(
+          "Deployment files need to be generated, but the terminal is not interactive.",
+          "Re-run with --yes to accept, or run `omnideploy generate <provider>` first.",
+          "CONFIRMATION_REQUIRED"
+        );
+      }
+      const showPreview = await this.prompt.confirm("Preview file contents first?", false);
+      if (showPreview) for (const a of toWrite) this.prompt.note(a.contents, a.path);
+      if (!await this.prompt.confirm("Write these files?", true)) throw new UserCancelledError();
+    }
+    for (const a of toWrite) {
+      await this.fs.writeText(this.fs.join(req.profile.rootDir, a.path), a.contents);
+      this.logger.success(`${a.action === "create" ? "Created" : "Updated"} ${a.path}`);
+    }
+    return { planned, written: toWrite.map((a) => a.path) };
+  }
+};
+
+// src/application/use-cases/InitProject.ts
+var InitProject = class {
+  constructor(detect, providers, generate, configRepo, prompt, logger) {
+    this.detect = detect;
+    this.providers = providers;
+    this.generate = generate;
+    this.configRepo = configRepo;
+    this.prompt = prompt;
+    this.logger = logger;
+  }
+  detect;
+  providers;
+  generate;
+  configRepo;
+  prompt;
+  logger;
+  async execute(req) {
+    const { profile, config: existing } = await this.detect.execute(req.rootDir);
+    this.logger.success(`Detected ${describeProfile(profile)}`);
+    const compatible = this.providers.all().filter((p11) => checkCompatibility(profile, p11.capabilities).ok);
+    const incompatible = this.providers.all().filter((p11) => !compatible.includes(p11));
+    if (compatible.length === 0) {
+      throw new DomainError("None of the available providers can host this project.", void 0, "NO_PROVIDER");
+    }
+    let providerIds = req.providerIds;
+    if (providerIds) {
+      for (const id of providerIds) {
+        const p11 = this.providers.get(id);
+        const c = checkCompatibility(profile, p11.capabilities);
+        if (!c.ok) this.logger.warn(`${p11.displayName} ${c.reason} \u2014 skipping.`);
+      }
+      providerIds = providerIds.filter((id) => compatible.some((p11) => p11.id === id));
+    } else if (req.yes || !this.prompt.interactive) {
+      providerIds = compatible.map((p11) => p11.id);
+    } else {
+      if (incompatible.length > 0) {
+        this.logger.info(
+          `Not offered: ${incompatible.map((p11) => `${p11.displayName} (${checkCompatibility(profile, p11.capabilities).reason})`).join("; ")}`
+        );
+      }
+      providerIds = await this.prompt.multiselect(
+        "Where do you want to deploy?",
+        compatible.map((p11) => ({ value: p11.id, label: p11.displayName, hint: p11.capabilities.kinds.join("/") })),
+        Object.keys(existing?.providers ?? {}).filter((id) => compatible.some((p11) => p11.id === id))
+      );
+    }
+    if (providerIds.length === 0) throw new DomainError("No providers selected.", void 0, "NO_PROVIDER");
+    const config = existing ?? emptyConfig();
+    config.name ??= resolveServiceName(profile, existing);
+    if (profile.kind === "static") {
+      config.build = { command: profile.buildCommand, output: profile.outputDir, ...config.build };
+    } else {
+      config.app = { port: profile.port, start: profile.startCommand, ...config.app };
+    }
+    for (const id of providerIds) config.providers[id] ??= {};
+    const { written } = await this.generate.execute({
+      profile,
+      config,
+      providerIds,
+      yes: req.yes,
+      force: req.force
+    });
+    await this.configRepo.save(req.rootDir, config);
+    this.logger.success(`Saved ${this.configRepo.fileName}`);
+    return { profile, config, providerIds, written };
+  }
+};
+
+// src/application/use-cases/BuildProject.ts
+var BuildProject = class {
+  constructor(process2, fs, logger) {
+    this.process = process2;
+    this.fs = fs;
+    this.logger = logger;
+  }
+  process;
+  fs;
+  logger;
+  async execute(profile, opts) {
+    if (profile.kind !== "static") return profile.rootDir;
+    if (profile.buildCommand && !opts.skipBuild) {
+      opts.spinner?.start(`Building: ${profile.buildCommand}`);
+      const res = await this.process.shell(profile.buildCommand, { cwd: profile.rootDir, env: { CI: "1" } });
+      if (res.exitCode !== 0) {
+        opts.spinner?.stop("Build failed", false);
+        const tail = (res.stderr || res.stdout).trim().split("\n").slice(-15).join("\n");
+        throw new BuildError(profile.buildCommand, tail);
+      }
+      opts.spinner?.stop("Build complete");
+    }
+    const out = this.fs.resolve(profile.rootDir, profile.outputDir ?? ".");
+    if (!await this.fs.exists(out)) {
+      throw new DomainError(
+        `Build output directory "${profile.outputDir}" does not exist.`,
+        profile.buildCommand && opts.skipBuild ? "Run the build first, or drop --no-build." : "Set build.output in omnideploy.json to the folder your build produces.",
+        "MISSING_OUTPUT"
+      );
+    }
+    this.logger.debug(`Deploying files from ${out}`);
+    return out;
+  }
+};
+
+// src/application/use-cases/DeployProject.ts
+var DeployProject = class {
+  constructor(detect, providers, generate, build, credentials, configRepo, git, prompt, logger) {
+    this.detect = detect;
+    this.providers = providers;
+    this.generate = generate;
+    this.build = build;
+    this.credentials = credentials;
+    this.configRepo = configRepo;
+    this.git = git;
+    this.prompt = prompt;
+    this.logger = logger;
+  }
+  detect;
+  providers;
+  generate;
+  build;
+  credentials;
+  configRepo;
+  git;
+  prompt;
+  logger;
+  async execute(req) {
+    const detected = await this.detect.execute(req.rootDir);
+    let profile = detected.profile;
+    if (req.dir) profile = { ...profile, kind: "static", outputDir: req.dir, buildCommand: req.skipBuild ? void 0 : profile.buildCommand };
+    const config = detected.config ?? { providers: {} };
+    this.logger.success(`Detected ${describeProfile(profile)}`);
+    const targets = await this.chooseProviders(req, profile, config);
+    for (const p11 of targets) {
+      const c = checkCompatibility(profile, p11.capabilities);
+      if (!c.ok) throw new IncompatibleProviderError(p11.displayName, c.reason, suggestAlternatives(profile, this.providers.all(), p11.id));
+    }
+    const { planned, written } = await this.generate.execute({
+      profile,
+      config,
+      providerIds: targets.map((p11) => p11.id),
+      yes: req.yes,
+      force: req.force,
+      dryRun: req.dryRun
+    });
+    if (planned.some((a) => a.id === "dockerfile")) profile = { ...profile, hasDockerfile: true };
+    const tokens = /* @__PURE__ */ new Map();
+    for (const p11 of targets) {
+      if (req.dryRun) {
+        await this.credentials.resolve(p11, { allowPrompt: false }).then(
+          (t) => tokens.set(p11.id, t),
+          () => this.logger.warn(`${p11.displayName}: no credentials (run \`omnideploy login ${p11.id}\`)`)
+        );
+        continue;
+      }
+      tokens.set(p11.id, await this.credentials.resolve(p11, { allowPrompt: !req.yes }));
+      await p11.validate({ profile, rootDir: req.rootDir, options: config.providers[p11.id] ?? {}, token: tokens.get(p11.id) });
+    }
+    const gitTargets = targets.filter((p11) => p11.capabilities.buildsFromGit);
+    if (gitTargets.length > 0 && !req.dryRun) await this.syncGitRemote(req, gitTargets, written);
+    if (req.dryRun) {
+      this.logger.info(`Dry run: would deploy to ${targets.map((p11) => p11.displayName).join(", ")}.`);
+      return { profile, dryRun: true, outcomes: [] };
+    }
+    const sourceDir = await this.build.execute(profile, { skipBuild: req.skipBuild, spinner: this.prompt.spinner() });
+    const serviceName = resolveServiceName(profile, config);
+    const outcomes = [];
+    for (const p11 of targets) {
+      const spinner2 = this.prompt.spinner();
+      spinner2.start(`Deploying to ${p11.displayName}`);
+      try {
+        const deployment = await p11.deploy({
+          profile,
+          options: config.providers[p11.id] ?? {},
+          token: tokens.get(p11.id),
+          sourceDir,
+          production: req.production,
+          serviceName,
+          logger: this.logger,
+          progress: (m) => spinner2.message(`${p11.displayName}: ${m}`)
+        });
+        spinner2.stop(`${p11.displayName}: ${deployment.url ?? "deployed"}`, true);
+        outcomes.push({ provider: p11.id, displayName: p11.displayName, ok: true, deployment });
+        config.providers[p11.id] = { ...config.providers[p11.id], ...deployment.configUpdates };
+        await this.configRepo.save(req.rootDir, config);
+      } catch (error) {
+        spinner2.stop(`${p11.displayName}: failed`, false);
+        outcomes.push({ provider: p11.id, displayName: p11.displayName, ok: false, error });
+      }
+    }
+    return { profile, dryRun: false, outcomes };
+  }
+  async chooseProviders(req, profile, config) {
+    let ids = req.providerIds?.length ? req.providerIds : Object.keys(config.providers);
+    if (ids.length === 0) {
+      const compatible = this.providers.all().filter((p11) => checkCompatibility(profile, p11.capabilities).ok);
+      if (!this.prompt.interactive || req.yes) {
+        throw new DomainError(
+          "No provider given.",
+          `Run \`omnideploy deploy <provider>\` (compatible: ${compatible.map((p11) => p11.id).join(", ")}) or \`omnideploy init\`.`,
+          "NO_PROVIDER"
+        );
+      }
+      ids = [
+        await this.prompt.select(
+          "Deploy to which provider?",
+          compatible.map((p11) => ({ value: p11.id, label: p11.displayName }))
+        )
+      ];
+    }
+    return ids.map((id) => this.providers.get(id));
+  }
+  async syncGitRemote(req, targets, generated) {
+    const names = targets.map((p11) => p11.displayName).join(", ");
+    if (!await this.git.isRepo(req.rootDir) || !await this.git.remote(req.rootDir)) {
+      throw new DomainError(
+        `${names} builds from a git repository, but this project has no git remote.`,
+        "Push the project to GitHub/GitLab (git init && git remote add origin <url> && git push -u origin HEAD).",
+        "NO_GIT_REMOTE"
+      );
+    }
+    const dirty = await this.git.dirtyPaths(req.rootDir);
+    if (dirty.length === 0) return;
+    const generatedDirty = dirty.filter((d) => generated.includes(d) || ["Dockerfile", ".dockerignore", "render.yaml", "omnideploy.json"].includes(d));
+    const otherDirty = dirty.filter((d) => !generatedDirty.includes(d));
+    if (otherDirty.length > 0) {
+      this.logger.warn(`${otherDirty.length} other uncommitted change(s) will NOT be deployed by ${names} (it builds from the remote).`);
+    }
+    if (generatedDirty.length === 0) return;
+    const ok = req.yes || this.prompt.interactive && await this.prompt.confirm(`${names} builds from your git remote. Commit and push ${generatedDirty.join(", ")}?`, true);
+    if (!ok) {
+      if (!this.prompt.interactive && !req.yes) {
+        throw new DomainError("Deployment files must be committed and pushed first.", "Commit them yourself, or re-run with --yes.", "GIT_SYNC_REQUIRED");
+      }
+      throw new UserCancelledError();
+    }
+    await this.git.commit(req.rootDir, generatedDirty, "chore: add deployment configuration (omnideploy)");
+    await this.git.push(req.rootDir);
+    this.logger.success("Pushed deployment files");
+  }
+};
+
+// src/application/use-cases/ManageCredentials.ts
+var LoginProvider = class {
+  constructor(providers, store, prompt) {
+    this.providers = providers;
+    this.store = store;
+    this.prompt = prompt;
+  }
+  providers;
+  store;
+  prompt;
+  async execute(providerId, token) {
+    const p11 = this.providers.get(providerId);
+    if (!token) {
+      if (!this.prompt.interactive) {
+        throw new DomainError("No token given.", `Pass --token, or set ${p11.capabilities.auth.envVar}.`, "MISSING_TOKEN");
+      }
+      this.prompt.note(`Create a token at:
+${p11.capabilities.auth.tokenUrl}`, `${p11.displayName} login`);
+      token = await this.prompt.password(`Paste your ${p11.displayName} token`);
+    }
+    token = token.trim();
+    if (!token) throw new DomainError("Empty token.", void 0, "MISSING_TOKEN");
+    await this.store.set(p11.id, token);
+  }
+};
+var LogoutProvider = class {
+  constructor(providers, store) {
+    this.providers = providers;
+    this.store = store;
+  }
+  providers;
+  store;
+  async execute(providerId) {
+    return this.store.delete(this.providers.get(providerId).id);
+  }
+};
+
+// src/application/use-cases/ListProviders.ts
+var ListProviders = class {
+  constructor(providers, store, process2) {
+    this.providers = providers;
+    this.store = store;
+    this.process = process2;
+  }
+  providers;
+  store;
+  process;
+  async execute(profile) {
+    return Promise.all(
+      this.providers.all().map(async (p11) => {
+        const cred = await this.store.get(p11.id, p11.capabilities.auth.envVar);
+        const req = p11.capabilities.requiredCli;
+        const c = profile ? checkCompatibility(profile, p11.capabilities) : void 0;
+        return {
+          id: p11.id,
+          displayName: p11.displayName,
+          hosts: p11.capabilities.kinds.join(", "),
+          auth: cred?.source ?? null,
+          cli: req ? { bin: req.bin, installed: await this.process.has(req.bin), install: req.install } : null,
+          compatibility: c && (c.ok ? { ok: true } : { ok: false, reason: c.reason })
+        };
+      })
+    );
+  }
+};
+
+// src/application/use-cases/DoctorCheck.ts
+var DoctorCheck = class {
+  constructor(detect, listProviders, git) {
+    this.detect = detect;
+    this.listProviders = listProviders;
+    this.git = git;
+  }
+  detect;
+  listProviders;
+  git;
+  async execute(rootDir, runtime) {
+    const checks = [];
+    const major = Number(runtime.nodeVersion.replace(/^v/, "").split(".")[0]);
+    checks.push(
+      major >= 20 ? { name: "Node.js", status: "ok", detail: runtime.nodeVersion } : { name: "Node.js", status: "fail", detail: runtime.nodeVersion, fix: "Install Node.js 20 or newer." }
+    );
+    let profile;
+    let configured = [];
+    try {
+      const r = await this.detect.execute(rootDir);
+      profile = r.profile;
+      configured = Object.keys(r.config?.providers ?? {});
+      checks.push({ name: "Project", status: "ok", detail: describeProfile(r.profile) });
+      checks.push(
+        r.config ? { name: "Config", status: "ok", detail: `omnideploy.json (${configured.join(", ") || "no providers"})` } : { name: "Config", status: "warn", detail: "no omnideploy.json", fix: "Run `omnideploy init`." }
+      );
+    } catch (e) {
+      checks.push({
+        name: "Project",
+        status: "fail",
+        detail: e instanceof Error ? e.message : String(e),
+        fix: e instanceof DomainError ? e.hint : void 0
+      });
+    }
+    if (await this.git.isRepo(rootDir)) {
+      const remote = await this.git.remote(rootDir);
+      checks.push(
+        remote ? { name: "Git remote", status: "ok", detail: remote.url } : { name: "Git remote", status: "warn", detail: "none", fix: "Render and GitHub Pages need a pushed git remote (git remote add origin <url>)." }
+      );
+    } else {
+      checks.push({ name: "Git", status: "warn", detail: "not a git repository", fix: "Render and GitHub Pages need one: git init." });
+    }
+    for (const row of await this.listProviders.execute(profile)) {
+      const relevant = configured.length === 0 || configured.includes(row.id);
+      if (!relevant) continue;
+      const problems = [];
+      const fixes = [];
+      if (!row.auth) {
+        problems.push("not logged in");
+        fixes.push(`omnideploy login ${row.id}`);
+      }
+      if (row.cli && !row.cli.installed) {
+        problems.push(`${row.cli.bin} CLI missing`);
+        fixes.push(row.cli.install);
+      }
+      if (row.compatibility && !row.compatibility.ok) problems.push(row.compatibility.reason ?? "incompatible");
+      checks.push({
+        name: row.displayName,
+        status: problems.length === 0 ? "ok" : configured.includes(row.id) ? "fail" : "warn",
+        detail: problems.length === 0 ? `ready (token from ${row.auth})` : problems.join(", "),
+        fix: fixes.join("\n") || void 0
+      });
+    }
+    return checks;
+  }
+};
+
+// src/application/use-cases/GetDeploymentStatus.ts
+var GetDeploymentStatus = class {
+  constructor(providers, credentials, configRepo) {
+    this.providers = providers;
+    this.credentials = credentials;
+    this.configRepo = configRepo;
+  }
+  providers;
+  credentials;
+  configRepo;
+  async execute(rootDir, providerId, deploymentId) {
+    const p11 = this.providers.get(providerId);
+    if (!p11.status) throw new DomainError(`${p11.displayName} does not support status checks yet.`, void 0, "UNSUPPORTED");
+    const config = await this.configRepo.load(rootDir);
+    const token = await this.credentials.resolve(p11, { allowPrompt: true });
+    return p11.status({ options: config?.providers[p11.id] ?? {}, token }, deploymentId);
+  }
+};
+
+// src/infrastructure/config/JsonConfigRepository.ts
+import { z } from "zod";
+var schema = z.object({
+  $schema: z.string().optional(),
+  name: z.string().min(1).optional(),
+  build: z.object({ command: z.string().optional(), output: z.string().optional() }).optional(),
+  app: z.object({
+    start: z.string().optional(),
+    port: z.number().int().min(1).max(65535).optional(),
+    healthCheckPath: z.string().startsWith("/").optional()
+  }).optional(),
+  providers: z.record(z.string(), z.record(z.string(), z.unknown())).default({})
+});
+var SCHEMA_URL = "https://unpkg.com/omnideploy/schema.json";
+var JsonConfigRepository = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  fileName = "omnideploy.json";
+  async load(rootDir) {
+    const raw = await this.fs.readTextIfExists(this.fs.join(rootDir, this.fileName));
+    if (raw === null) return null;
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch (e) {
+      throw new ConfigError(`${this.fileName} is not valid JSON: ${e.message}`);
+    }
+    const parsed = schema.safeParse(json);
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map((i) => `  \u2022 ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+      throw new ConfigError(`${this.fileName} is invalid:
+${issues}`, "Fix the fields above or delete the file and run `omnideploy init`.");
+    }
+    const { $schema: _ignored, ...config } = parsed.data;
+    return config;
+  }
+  async save(rootDir, config) {
+    const { name, build, app, providers, ...rest } = config;
+    const ordered = { $schema: SCHEMA_URL, name, build, app, ...rest, providers };
+    await this.fs.writeText(this.fs.join(rootDir, this.fileName), JSON.stringify(stripUndefined(ordered), null, 2) + "\n");
+  }
+};
+function stripUndefined(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/infrastructure/credentials/FileCredentialStore.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+var FileCredentialStore = class {
+  constructor(filePath, env2 = process.env) {
+    this.filePath = filePath;
+    this.env = env2;
+  }
+  filePath;
+  env;
+  async get(providerId, envVar) {
+    const fromEnv = this.env[envVar]?.trim();
+    if (fromEnv) return { token: fromEnv, source: "env" };
+    const stored = (await this.read()).providers[providerId];
+    return stored ? { token: stored.token, source: "store" } : null;
+  }
+  async set(providerId, token) {
+    const data = await this.read();
+    data.providers[providerId] = { token, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.write(data);
+  }
+  async delete(providerId) {
+    const data = await this.read();
+    if (!data.providers[providerId]) return false;
+    delete data.providers[providerId];
+    await this.write(data);
+    return true;
+  }
+  async read() {
+    try {
+      const parsed = JSON.parse(await readFile(this.filePath, "utf8"));
+      return { providers: parsed.providers ?? {} };
+    } catch {
+      return { providers: {} };
+    }
+  }
+  async write(data) {
+    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
+    await writeFile(this.filePath, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+    await chmod(this.filePath, 384);
+  }
+};
+
+// src/infrastructure/detectors/DockerDetector.ts
+var DockerDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "docker";
+  async detect(root) {
+    const dockerfile = await this.fs.readTextIfExists(this.fs.join(root, "Dockerfile"));
+    if (dockerfile === null) return null;
+    const port = Number(dockerfile.match(/^\s*EXPOSE\s+(\d+)/im)?.[1] ?? 8080);
+    return {
+      profile: { rootDir: root, language: "docker", kind: "server", port, hasDockerfile: true },
+      confidence: 20
+    };
+  }
+};
+
+// src/infrastructure/detectors/support.ts
+async function readJson(fs, path) {
+  const raw = await fs.readTextIfExists(path);
+  if (raw === null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function firstExisting(fs, root, candidates) {
+  for (const c of candidates) if (await fs.exists(fs.join(root, c))) return c;
+  return void 0;
+}
+function hasDockerfile(fs, root) {
+  return fs.exists(fs.join(root, "Dockerfile"));
+}
+function extractVersion(spec, parts = 2) {
+  if (!spec) return void 0;
+  const m = spec.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!m) return void 0;
+  return [m[1], m[2], m[3]].slice(0, parts).filter((x) => x !== void 0).join(".");
+}
+
+// src/infrastructure/detectors/DotnetDetector.ts
+var DotnetDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "dotnet";
+  async detect(root) {
+    const csproj = (await this.fs.list(root)).find((f) => f.endsWith(".csproj") || f.endsWith(".fsproj"));
+    if (!csproj) return null;
+    const xml = await this.fs.readText(this.fs.join(root, csproj));
+    const assembly = xml.match(/<AssemblyName>([^<]+)</)?.[1] ?? csproj.replace(/\.[cf]sproj$/, "");
+    const version = xml.match(/<TargetFramework>net(\d+\.\d+)</)?.[1] ?? "8.0";
+    const web = /Sdk="Microsoft\.NET\.Sdk\.Web"/.test(xml);
+    return {
+      profile: {
+        rootDir: root,
+        language: "dotnet",
+        framework: web ? "aspnetcore" : void 0,
+        kind: "server",
+        packageManager: "dotnet",
+        runtimeVersion: version,
+        buildCommand: "dotnet publish -c Release -o out",
+        startCommand: `dotnet ${assembly}.dll`,
+        port: 8080,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: { name: assembly, assembly, projectFile: csproj }
+      },
+      confidence: web ? 85 : 70
+    };
+  }
+};
+
+// src/infrastructure/detectors/GoDetector.ts
+var GoDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "go";
+  async detect(root) {
+    const gomod = await this.fs.readTextIfExists(this.fs.join(root, "go.mod"));
+    if (gomod === null) return null;
+    const module = gomod.match(/^module\s+(\S+)/m)?.[1] ?? "";
+    const framework = [
+      ["github.com/gin-gonic/gin", "gin"],
+      ["github.com/labstack/echo", "echo"],
+      ["github.com/gofiber/fiber", "fiber"],
+      ["github.com/go-chi/chi", "chi"]
+    ].find(([mod]) => gomod.includes(mod))?.[1];
+    let mainPath = ".";
+    if (!await this.fs.exists(this.fs.join(root, "main.go"))) {
+      const cmds = await this.fs.list(this.fs.join(root, "cmd"));
+      for (const c of cmds) {
+        if (await this.fs.exists(this.fs.join(root, "cmd", c, "main.go"))) {
+          mainPath = `./cmd/${c}`;
+          break;
+        }
+      }
+    }
+    return {
+      profile: {
+        rootDir: root,
+        language: "go",
+        framework,
+        kind: "server",
+        packageManager: "go",
+        runtimeVersion: extractVersion(gomod.match(/^go\s+([\d.]+)/m)?.[1]) ?? "1.23",
+        buildCommand: `go build -o app ${mainPath}`,
+        startCommand: "./app",
+        port: 8080,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: { name: module.split("/").pop() ?? "", mainPath }
+      },
+      confidence: 85
+    };
+  }
+};
+
+// src/infrastructure/detectors/JavaDetector.ts
+import { XMLParser } from "fast-xml-parser";
+var JVM_FRAMEWORKS = [
+  [/spring-boot|org\.springframework\.boot/, "spring-boot"],
+  [/io\.quarkus/, "quarkus"],
+  [/io\.micronaut/, "micronaut"]
+];
+var PORT_PROPERTY = {
+  "spring-boot": "server.port",
+  quarkus: "quarkus.http.port",
+  micronaut: "micronaut.server.port"
+};
+var JavaDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "java";
+  async detect(root) {
+    const read = (f) => this.fs.readTextIfExists(this.fs.join(root, f));
+    const pom = await read("pom.xml");
+    const gradle = await read("build.gradle.kts") ?? await read("build.gradle");
+    if (pom === null && gradle === null) return null;
+    const buildTool = pom !== null ? "maven" : "gradle";
+    const source = pom ?? gradle;
+    const framework = JVM_FRAMEWORKS.find(([re]) => re.test(source))?.[1];
+    const hasWrapper = await this.fs.exists(this.fs.join(root, buildTool === "maven" ? "mvnw" : "gradlew"));
+    let name = "";
+    let javaVersion;
+    if (pom !== null) {
+      const project = new XMLParser({ ignoreAttributes: true }).parse(pom)?.project ?? {};
+      name = String(project.artifactId ?? "");
+      const props = project.properties ?? {};
+      javaVersion = extractVersion(String(props["java.version"] ?? props["maven.compiler.release"] ?? props["maven.compiler.source"] ?? ""), 1);
+    } else {
+      javaVersion = extractVersion(gradle.match(/JavaLanguageVersion\.of\((\d+)\)/)?.[1], 1) ?? extractVersion(gradle.match(/VERSION_(\d+)/)?.[1], 1) ?? extractVersion(gradle.match(/sourceCompatibility\s*=\s*['"]?([\d.]+)/)?.[1], 1);
+      const settings = await read("settings.gradle.kts") ?? await read("settings.gradle");
+      name = settings?.match(/rootProject\.name\s*=\s*['"]([^'"]+)/)?.[1] ?? "";
+    }
+    if (javaVersion === "1") javaVersion = "8";
+    const runtimeVersion = javaVersion ?? "21";
+    const tool = buildTool === "maven" ? hasWrapper ? "./mvnw" : "mvn" : hasWrapper ? "./gradlew" : "gradle";
+    const buildCommand = buildTool === "maven" ? `${tool} -B -DskipTests package` : `${tool} ${framework === "spring-boot" ? "bootJar" : "build"} -x test --no-daemon`;
+    const portProp = framework ? PORT_PROPERTY[framework] : void 0;
+    return {
+      profile: {
+        rootDir: root,
+        language: "java",
+        framework,
+        kind: "server",
+        runtimeVersion,
+        packageManager: buildTool,
+        buildCommand,
+        startCommand: `java ${portProp ? `-D${portProp}=$PORT ` : ""}-jar app.jar`,
+        port: 8080,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: {
+          name,
+          buildTool,
+          wrapper: String(hasWrapper),
+          jarDir: buildTool === "maven" ? "target" : "build/libs",
+          portProperty: portProp ?? "",
+          quarkus: String(framework === "quarkus")
+        }
+      },
+      confidence: 85
+    };
+  }
+};
+
+// src/infrastructure/detectors/NodeDetector.ts
+var NodeDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "node";
+  async detect(root) {
+    const pkg = await readJson(this.fs, this.fs.join(root, "package.json"));
+    if (!pkg) return null;
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const has = (name) => name in deps;
+    const scripts = pkg.scripts ?? {};
+    const pm = await this.packageManager(root);
+    const run = (script) => pm === "npm" ? `npm run ${script}` : `${pm} run ${script}`;
+    const install = { npm: "npm ci", pnpm: "pnpm install --frozen-lockfile", yarn: "yarn install --frozen-lockfile", bun: "bun install" }[pm];
+    const nvmrc = await this.fs.readTextIfExists(this.fs.join(root, ".nvmrc"));
+    const base = {
+      rootDir: root,
+      language: "node",
+      kind: "server",
+      packageManager: pm,
+      runtimeVersion: extractVersion(pkg.engines?.node, 1) ?? extractVersion(nvmrc, 1) ?? "22",
+      port: 3e3,
+      hasDockerfile: await hasDockerfile(this.fs, root),
+      meta: { name: pkg.name ?? "", install, lockfile: await this.lockfile(root) ?? "" }
+    };
+    const build = scripts.build ? run("build") : void 0;
+    const start = scripts.start ? pm === "npm" ? "npm start" : `${pm} start` : void 0;
+    const staticSite2 = (framework, outputDir) => ({
+      profile: { ...base, framework, kind: "static", buildCommand: build, outputDir },
+      confidence: 90
+    });
+    const server = (framework, startCommand, port = 3e3) => ({
+      profile: { ...base, framework, kind: "server", buildCommand: build, startCommand, port },
+      confidence: 90
+    });
+    if (has("next")) {
+      const nextConfig = await this.readFirst(root, ["next.config.js", "next.config.mjs", "next.config.ts"]);
+      if (nextConfig && /output\s*:\s*['"]export['"]/.test(nextConfig)) return staticSite2("nextjs", "out");
+      return { profile: { ...base, framework: "nextjs", kind: "serverless", buildCommand: build, startCommand: start ?? "npx next start" }, confidence: 90 };
+    }
+    if (has("nuxt")) return server("nuxt", "node .output/server/index.mjs");
+    if (has("@sveltejs/kit")) {
+      return has("@sveltejs/adapter-static") ? staticSite2("sveltekit", "build") : server("sveltekit", "node build");
+    }
+    if (has("@remix-run/node") || has("@remix-run/serve")) return server("remix", start);
+    if (has("astro")) return has("@astrojs/node") ? server("astro", "node ./dist/server/entry.mjs", 4321) : staticSite2("astro", "dist");
+    if (has("gatsby")) return staticSite2("gatsby", "public");
+    if (has("@angular/core")) return staticSite2("angular", `dist/${pkg.name ?? "app"}/browser`);
+    if (has("react-scripts")) return staticSite2("create-react-app", "build");
+    if (has("@nestjs/core")) return server("nestjs", scripts["start:prod"] ? run("start:prod") : "node dist/main");
+    for (const fw of ["express", "fastify", "koa", "hono", "@hapi/hapi"]) {
+      if (has(fw)) return server(fw.replace("@hapi/", ""), start ?? `node ${pkg.main ?? "index.js"}`);
+    }
+    if (has("vite")) {
+      const viteFw = ["react", "vue", "svelte", "solid-js", "preact"].find(has);
+      return staticSite2(viteFw ? `vite-${viteFw.replace("-js", "")}` : "vite", "dist");
+    }
+    if (start) return server(void 0, start);
+    if (build) return { ...staticSite2("node-static", "dist"), confidence: 60 };
+    return null;
+  }
+  async packageManager(root) {
+    const lock = await this.lockfile(root);
+    if (lock === "pnpm-lock.yaml") return "pnpm";
+    if (lock === "yarn.lock") return "yarn";
+    if (lock?.startsWith("bun.lock")) return "bun";
+    return "npm";
+  }
+  lockfile(root) {
+    return firstExisting(this.fs, root, ["pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock", "package-lock.json"]);
+  }
+  async readFirst(root, files) {
+    const f = await firstExisting(this.fs, root, files);
+    return f ? this.fs.readText(this.fs.join(root, f)) : null;
+  }
+};
+
+// src/infrastructure/detectors/PhpDetector.ts
+var PhpDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "php";
+  async detect(root) {
+    const composer = await readJson(this.fs, this.fs.join(root, "composer.json"));
+    const hasIndex = await this.fs.exists(this.fs.join(root, "index.php"));
+    const hasPublicIndex = await this.fs.exists(this.fs.join(root, "public", "index.php"));
+    if (!composer && !hasIndex && !hasPublicIndex) return null;
+    const req = composer?.require ?? {};
+    const framework = "laravel/framework" in req ? "laravel" : "symfony/framework-bundle" in req ? "symfony" : void 0;
+    const docroot = hasPublicIndex || framework ? "public" : ".";
+    return {
+      profile: {
+        rootDir: root,
+        language: "php",
+        framework,
+        kind: "server",
+        packageManager: composer ? "composer" : void 0,
+        runtimeVersion: extractVersion(req.php) ?? "8.3",
+        startCommand: framework === "laravel" ? "php artisan serve --host=0.0.0.0 --port=$PORT" : `php -S 0.0.0.0:$PORT -t ${docroot}`,
+        port: 8080,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: { name: composer?.name?.split("/").pop() ?? "", docroot, composer: String(Boolean(composer)) }
+      },
+      confidence: composer ? 80 : 50
+    };
+  }
+};
+
+// src/infrastructure/detectors/PythonDetector.ts
+import { parse as parseToml } from "smol-toml";
+var PythonDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "python";
+  async detect(root) {
+    const read = (f) => this.fs.readTextIfExists(this.fs.join(root, f));
+    const [requirements, pyprojectRaw, pipfile, hasManage] = await Promise.all([
+      read("requirements.txt"),
+      read("pyproject.toml"),
+      read("Pipfile"),
+      this.fs.exists(this.fs.join(root, "manage.py"))
+    ]);
+    if (requirements === null && pyprojectRaw === null && pipfile === null && !hasManage) return null;
+    let pyproject = {};
+    try {
+      pyproject = pyprojectRaw ? parseToml(pyprojectRaw) : {};
+    } catch {
+    }
+    const depsText = [requirements, pyprojectRaw, pipfile].filter(Boolean).join("\n").toLowerCase();
+    const has = (name2) => new RegExp(`(^|[\\s"'\\[,])${name2}([\\s"'<>=~!\\[,;]|$)`, "m").test(depsText);
+    const packageManager = await this.fs.exists(this.fs.join(root, "uv.lock")) ? "uv" : await this.fs.exists(this.fs.join(root, "poetry.lock")) || pyproject.tool?.poetry ? "poetry" : "pip";
+    const runtimeVersion = extractVersion(await read(".python-version")) ?? extractVersion((await read("runtime.txt"))?.replace("python-", "")) ?? extractVersion(pyproject.project?.["requires-python"]) ?? "3.12";
+    const name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? "";
+    const base = {
+      rootDir: root,
+      language: "python",
+      kind: "server",
+      packageManager,
+      runtimeVersion,
+      hasDockerfile: await hasDockerfile(this.fs, root)
+    };
+    const requirementsMeta = { requirements: String(requirements !== null) };
+    if (hasManage || has("django")) {
+      const project = await this.findDjangoProject(root);
+      return {
+        profile: {
+          ...base,
+          framework: "django",
+          port: 8e3,
+          startCommand: `gunicorn ${project}.wsgi:application --bind 0.0.0.0:$PORT`,
+          buildCommand: "python manage.py collectstatic --noinput",
+          meta: { ...requirementsMeta, name, extraPackages: has("gunicorn") ? "" : "gunicorn" }
+        },
+        confidence: 85
+      };
+    }
+    if (has("fastapi")) {
+      const mod = await this.findAppModule(root, "FastAPI(") ?? "main:app";
+      return {
+        profile: { ...base, framework: "fastapi", port: 8e3, startCommand: `uvicorn ${mod} --host 0.0.0.0 --port $PORT`, meta: { ...requirementsMeta, name, extraPackages: has("uvicorn") ? "" : "uvicorn" } },
+        confidence: 85
+      };
+    }
+    if (has("flask")) {
+      const mod = await this.findAppModule(root, "Flask(") ?? "app:app";
+      return {
+        profile: { ...base, framework: "flask", port: 5e3, startCommand: `gunicorn ${mod} --bind 0.0.0.0:$PORT`, meta: { ...requirementsMeta, name, extraPackages: has("gunicorn") ? "" : "gunicorn" } },
+        confidence: 85
+      };
+    }
+    if (has("streamlit")) {
+      const entry2 = await firstExisting(this.fs, root, ["streamlit_app.py", "app.py", "main.py"]) ?? "app.py";
+      return {
+        profile: { ...base, framework: "streamlit", port: 8501, startCommand: `streamlit run ${entry2} --server.port $PORT --server.address 0.0.0.0`, meta: { ...requirementsMeta, name } },
+        confidence: 85
+      };
+    }
+    const entry = await firstExisting(this.fs, root, ["main.py", "app.py", "server.py"]);
+    return {
+      profile: { ...base, port: 8e3, startCommand: entry ? `python ${entry}` : void 0, meta: { ...requirementsMeta, name } },
+      confidence: 60
+    };
+  }
+  async findDjangoProject(root) {
+    for (const entry of await this.fs.list(root)) {
+      if (await this.fs.exists(this.fs.join(root, entry, "wsgi.py"))) return entry;
+    }
+    return "config";
+  }
+  /** Finds "module:app" for the file that instantiates the framework app. */
+  async findAppModule(root, marker) {
+    for (const file of ["main.py", "app.py", "server.py", "app/main.py", "src/main.py", "api/main.py", "app/__init__.py"]) {
+      const src = await this.fs.readTextIfExists(this.fs.join(root, file));
+      if (!src?.includes(marker)) continue;
+      const varName = src.match(new RegExp(`^(\\w+)\\s*=\\s*${marker.replace("(", "\\(")}`, "m"))?.[1] ?? "app";
+      const mod = file.replace(/\/__init__\.py$/, "").replace(/\.py$/, "").replace(/\//g, ".");
+      return `${mod}:${varName}`;
+    }
+    return void 0;
+  }
+};
+
+// src/infrastructure/detectors/RubyDetector.ts
+var RubyDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "ruby";
+  async detect(root) {
+    const gemfile = await this.fs.readTextIfExists(this.fs.join(root, "Gemfile"));
+    if (gemfile === null) return null;
+    const has = (gem) => new RegExp(`^\\s*gem\\s+['"]${gem}['"]`, "m").test(gemfile);
+    const version = extractVersion(await this.fs.readTextIfExists(this.fs.join(root, ".ruby-version"))) ?? extractVersion(gemfile.match(/^\s*ruby\s+['"]([^'"]+)/m)?.[1]) ?? "3.3";
+    const rails = has("rails");
+    return {
+      profile: {
+        rootDir: root,
+        language: "ruby",
+        framework: rails ? "rails" : has("sinatra") ? "sinatra" : void 0,
+        kind: "server",
+        packageManager: "bundler",
+        runtimeVersion: version,
+        buildCommand: rails ? "bundle exec rails assets:precompile" : void 0,
+        startCommand: rails ? "bundle exec rails server -b 0.0.0.0 -p $PORT" : "bundle exec rackup -o 0.0.0.0 -p $PORT",
+        port: 3e3,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: { name: "" }
+      },
+      confidence: 80
+    };
+  }
+};
+
+// src/infrastructure/detectors/RustDetector.ts
+import { parse as parseToml2 } from "smol-toml";
+var RustDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "rust";
+  async detect(root) {
+    const raw = await this.fs.readTextIfExists(this.fs.join(root, "Cargo.toml"));
+    if (raw === null) return null;
+    let cargo = {};
+    try {
+      cargo = parseToml2(raw);
+    } catch {
+    }
+    const deps = Object.keys(cargo.dependencies ?? {});
+    const framework = ["actix-web", "axum", "rocket", "warp", "poem"].find((f) => deps.includes(f));
+    const binName = cargo.bin?.[0]?.name ?? cargo.package?.name ?? "app";
+    const toolchain = await this.fs.readTextIfExists(this.fs.join(root, "rust-toolchain")) ?? await this.fs.readTextIfExists(this.fs.join(root, "rust-toolchain.toml"));
+    return {
+      profile: {
+        rootDir: root,
+        language: "rust",
+        framework,
+        kind: "server",
+        packageManager: "cargo",
+        runtimeVersion: extractVersion(toolchain) ?? "1",
+        buildCommand: "cargo build --release",
+        startCommand: `./${binName}`,
+        port: 8080,
+        hasDockerfile: await hasDockerfile(this.fs, root),
+        meta: { name: cargo.package?.name ?? "", binName }
+      },
+      confidence: framework ? 85 : 70
+    };
+  }
+};
+
+// src/infrastructure/detectors/StaticDetector.ts
+var StaticDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  id = "static";
+  async detect(root) {
+    for (const dir of [".", "public", "docs", "site"]) {
+      if (await this.fs.exists(this.fs.join(root, dir, "index.html"))) {
+        return {
+          profile: {
+            rootDir: root,
+            language: "static",
+            framework: "html",
+            kind: "static",
+            outputDir: dir,
+            port: 8080,
+            hasDockerfile: await hasDockerfile(this.fs, root)
+          },
+          confidence: 40
+        };
+      }
+    }
+    return null;
+  }
+};
+
+// src/infrastructure/detectors/index.ts
+function builtInDetectors(fs) {
+  return [
+    new NodeDetector(fs),
+    new PythonDetector(fs),
+    new JavaDetector(fs),
+    new GoDetector(fs),
+    new RustDetector(fs),
+    new RubyDetector(fs),
+    new PhpDetector(fs),
+    new DotnetDetector(fs),
+    new StaticDetector(fs),
+    new DockerDetector(fs)
+  ];
+}
+
+// src/infrastructure/fs/NodeFileSystem.ts
+import { constants } from "fs";
+import { access, cp, mkdir as mkdir2, mkdtemp, readdir, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, join, resolve } from "path";
+import fg from "fast-glob";
+import ignore from "ignore";
+var ALWAYS_IGNORED = ["**/node_modules/**", "**/.git/**", "**/.DS_Store"];
+var NodeFileSystem = class {
+  async exists(path) {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  readText(path) {
+    return readFile2(path, "utf8");
+  }
+  async readTextIfExists(path) {
+    try {
+      return await readFile2(path, "utf8");
+    } catch (e) {
+      if (e.code === "ENOENT" || e.code === "EISDIR") return null;
+      throw e;
+    }
+  }
+  async readBytes(path) {
+    return new Uint8Array(await readFile2(path));
+  }
+  async writeText(path, contents) {
+    await mkdir2(dirname2(path), { recursive: true });
+    await writeFile2(path, contents, "utf8");
+  }
+  async list(dir) {
+    try {
+      return await readdir(dir);
+    } catch {
+      return [];
+    }
+  }
+  async collectFiles(dir, opts = {}) {
+    const files = await fg("**/*", {
+      cwd: dir,
+      dot: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: [...ALWAYS_IGNORED, ...opts.ignore ?? []]
+    });
+    if (!opts.respectGitignore) return files.sort();
+    const gitignore = await this.readTextIfExists(join(dir, ".gitignore"));
+    if (!gitignore) return files.sort();
+    const ig = ignore().add(gitignore);
+    return files.filter((f) => !ig.ignores(f)).sort();
+  }
+  async copyDir(from, to) {
+    await cp(from, to, {
+      recursive: true,
+      filter: (src) => !/[\\/](node_modules|\.git)([\\/]|$)/.test(src.slice(from.length))
+    });
+  }
+  makeTempDir(prefix) {
+    return mkdtemp(join(tmpdir(), `${prefix}-`));
+  }
+  async remove(path) {
+    await rm(path, { recursive: true, force: true });
+  }
+  join(...parts) {
+    return join(...parts);
+  }
+  resolve(...parts) {
+    return resolve(...parts);
+  }
+};
+
+// src/infrastructure/generators/dockerfile/templates.ts
+var HEADER = "# syntax=docker/dockerfile:1\n# Generated by omnideploy \u2014 safe to edit; omnideploy will not overwrite it without --force.\n";
+var shCmd = (cmd) => `CMD ["sh", "-c", ${JSON.stringify(`exec ${cmd}`)}]`;
+var lines = (...l) => l.filter((x) => typeof x === "string").join("\n") + "\n";
+var nginxStage = (from, port) => lines(
+  "FROM nginxinc/nginx-unprivileged:1.27-alpine",
+  `ENV PORT=${port}`,
+  "USER root",
+  `RUN mkdir -p /etc/nginx/templates && printf 'server {\\n  listen \${PORT};\\n  root /usr/share/nginx/html;\\n  location / { try_files $uri $uri/ /index.html; }\\n}\\n' > /etc/nginx/templates/default.conf.template`,
+  "RUN rm -f /etc/nginx/conf.d/default.conf && chown -R 101:101 /etc/nginx/conf.d /etc/nginx/templates",
+  `COPY --from=${from} --chown=101:101 /out /usr/share/nginx/html`,
+  "USER 101",
+  `EXPOSE ${port}`
+);
+function nodeImage(p11) {
+  if (p11.packageManager === "bun") return { image: "oven/bun:1-alpine", user: "bun" };
+  const setup = p11.packageManager === "pnpm" || p11.packageManager === "yarn" ? "RUN corepack enable" : void 0;
+  return { image: `node:${p11.runtimeVersion ?? "22"}-alpine`, user: "node", setup };
+}
+function nodeInstall(p11) {
+  const lock = p11.meta?.lockfile;
+  const copy = `COPY package.json ${lock ? `${lock} ` : ""}./`;
+  if (!lock) return { copy, run: p11.packageManager === "npm" || !p11.packageManager ? "npm install" : `${p11.packageManager} install` };
+  return { copy, run: p11.meta?.install || "npm ci" };
+}
+var node = (p11) => {
+  const { image, user, setup } = nodeImage(p11);
+  const install = nodeInstall(p11);
+  const build = lines(
+    `FROM ${image} AS build`,
+    "WORKDIR /app",
+    setup,
+    install.copy,
+    `RUN ${install.run}`,
+    "COPY . .",
+    p11.buildCommand && `RUN ${p11.buildCommand}`
+  );
+  if (p11.kind === "static") {
+    return HEADER + build + `RUN cp -r ${p11.outputDir ?? "dist"} /out
+
+` + nginxStage("build", p11.port === 3e3 ? 8080 : p11.port);
+  }
+  return HEADER + build + "\n" + lines(
+    `FROM ${image}`,
+    "WORKDIR /app",
+    setup,
+    `ENV NODE_ENV=production PORT=${p11.port}`,
+    `COPY --from=build --chown=${user}:${user} /app ./`,
+    `USER ${user}`,
+    `EXPOSE ${p11.port}`,
+    shCmd(p11.startCommand ?? "npm start")
+  );
+};
+var staticSite = (p11) => HEADER + lines("FROM busybox:1.36 AS files", "WORKDIR /src", "COPY . .", `RUN cp -r ${p11.outputDir ?? "."} /out`) + "\n" + nginxStage("files", 8080);
+var python = (p11) => {
+  const v = p11.runtimeVersion ?? "3.12";
+  const extra = p11.meta?.extraPackages ? ` ${p11.meta.extraPackages}` : "";
+  let deps;
+  if (p11.packageManager === "uv") {
+    deps = lines("COPY pyproject.toml uv.lock ./", `RUN pip install uv && uv export --frozen --no-dev --no-hashes --no-emit-project -o requirements.txt && /venv/bin/pip install -r requirements.txt${extra}`);
+  } else if (p11.packageManager === "poetry") {
+    deps = lines(
+      "COPY pyproject.toml poetry.lock* ./",
+      `RUN pip install poetry poetry-plugin-export && poetry export --without-hashes --only main -f requirements.txt -o requirements.txt && /venv/bin/pip install -r requirements.txt${extra}`
+    );
+  } else {
+    deps = p11.meta?.requirements === "true" ? lines("COPY requirements.txt ./", `RUN /venv/bin/pip install -r requirements.txt${extra}`) : lines("COPY . .", `RUN /venv/bin/pip install .${extra ? ` && /venv/bin/pip install${extra}` : ""}`);
+  }
+  return HEADER + lines(
+    `FROM python:${v}-slim AS deps`,
+    "ENV PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1",
+    "WORKDIR /app",
+    "RUN python -m venv /venv"
+  ) + deps + "\n" + lines(
+    `FROM python:${v}-slim`,
+    `ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PATH=/venv/bin:$PATH PORT=${p11.port}`,
+    "RUN useradd --create-home --uid 10001 app",
+    "WORKDIR /app",
+    "COPY --from=deps /venv /venv",
+    "COPY --chown=app:app . .",
+    "USER app",
+    p11.buildCommand && `RUN ${p11.buildCommand} || echo "omnideploy: build step '${p11.buildCommand}' skipped (needs runtime config)"`,
+    `EXPOSE ${p11.port}`,
+    shCmd(p11.startCommand ?? "python main.py")
+  );
+};
+var java = (p11) => {
+  const v = p11.runtimeVersion ?? "21";
+  const maven = p11.meta?.buildTool !== "gradle";
+  const quarkus = p11.meta?.quarkus === "true";
+  const buildImage = maven ? `maven:3.9-eclipse-temurin-${v}` : `gradle:jdk${v}`;
+  const build = maven ? "mvn -B -q -DskipTests package" : `gradle ${p11.framework === "spring-boot" ? "bootJar" : "build"} -x test --no-daemon -q`;
+  const jarDir = p11.meta?.jarDir ?? (maven ? "target" : "build/libs");
+  const portProp = p11.meta?.portProperty;
+  const collect = quarkus ? `RUN cp -r ${jarDir}/quarkus-app /out` : `RUN mkdir /out && cp "$(ls ${jarDir}/*.jar | grep -v -e '-plain.jar$' -e '-sources.jar$' -e '-javadoc.jar$' -e '/original-' | head -n 1)" /out/app.jar`;
+  const jar = quarkus ? "quarkus-run.jar" : "app.jar";
+  return HEADER + lines(
+    `FROM ${buildImage} AS build`,
+    "WORKDIR /src",
+    maven ? "COPY pom.xml ./" : "COPY build.gradle* settings.gradle* gradle.properties* ./",
+    maven ? "RUN mvn -B -q dependency:go-offline || true" : "RUN gradle dependencies --no-daemon -q || true",
+    "COPY . .",
+    `RUN ${build}`,
+    collect
+  ) + "\n" + lines(
+    `FROM eclipse-temurin:${v}-jre`,
+    "RUN useradd --system --create-home --uid 10001 app",
+    "WORKDIR /app",
+    "COPY --from=build --chown=app:app /out ./",
+    "USER app",
+    `ENV PORT=${p11.port} JAVA_OPTS="-XX:MaxRAMPercentage=75"`,
+    `EXPOSE ${p11.port}`,
+    shCmd(`java $JAVA_OPTS ${portProp ? `-D${portProp}=$PORT ` : ""}-jar ${jar}`)
+  );
+};
+var go = (p11) => HEADER + lines(
+  `FROM golang:${p11.runtimeVersion ?? "1.23"}-alpine AS build`,
+  "WORKDIR /src",
+  "COPY go.mod go.su[m] ./",
+  "RUN go mod download",
+  "COPY . .",
+  `RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/app ${p11.meta?.mainPath ?? "."}`
+) + "\n" + lines(
+  "FROM gcr.io/distroless/static-debian12:nonroot",
+  "COPY --from=build /out/app /app",
+  `ENV PORT=${p11.port}`,
+  `EXPOSE ${p11.port}`,
+  "USER nonroot:nonroot",
+  'ENTRYPOINT ["/app"]'
+);
+var rust = (p11) => {
+  const bin = p11.meta?.binName ?? "app";
+  return HEADER + lines(`FROM rust:${p11.runtimeVersion ?? "1"}-slim AS build`, "WORKDIR /src", "COPY . .", `RUN cargo build --release --bin ${bin} && cp target/release/${bin} /out-app`) + "\n" + lines(
+    "FROM debian:bookworm-slim",
+    "RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/* \\",
+    "  && useradd --system --uid 10001 app",
+    "COPY --from=build /out-app /usr/local/bin/app",
+    `ENV PORT=${p11.port}`,
+    "USER app",
+    `EXPOSE ${p11.port}`,
+    'CMD ["app"]'
+  );
+};
+var ruby = (p11) => {
+  const v = p11.runtimeVersion ?? "3.3";
+  const rails = p11.framework === "rails";
+  return HEADER + lines(
+    `FROM ruby:${v}-slim AS build`,
+    "RUN apt-get update && apt-get install -y --no-install-recommends build-essential git libpq-dev libyaml-dev pkg-config && rm -rf /var/lib/apt/lists/*",
+    "WORKDIR /app",
+    'ENV BUNDLE_WITHOUT="development:test" RAILS_ENV=production RACK_ENV=production',
+    "COPY Gemfile Gemfile.loc[k] ./",
+    "RUN bundle install --jobs 4",
+    "COPY . .",
+    rails && "RUN SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile"
+  ) + "\n" + lines(
+    `FROM ruby:${v}-slim`,
+    "RUN apt-get update && apt-get install -y --no-install-recommends libpq5 libyaml-0-2 && rm -rf /var/lib/apt/lists/* \\",
+    "  && useradd --create-home --uid 10001 app",
+    "WORKDIR /app",
+    `ENV BUNDLE_WITHOUT="development:test" RAILS_ENV=production RACK_ENV=production RAILS_LOG_TO_STDOUT=1 RAILS_SERVE_STATIC_FILES=1 PORT=${p11.port}`,
+    "COPY --from=build /usr/local/bundle /usr/local/bundle",
+    "COPY --from=build --chown=app:app /app /app",
+    "USER app",
+    `EXPOSE ${p11.port}`,
+    shCmd(p11.startCommand ?? "bundle exec rackup -o 0.0.0.0 -p $PORT")
+  );
+};
+var php = (p11) => {
+  const v = p11.runtimeVersion ?? "8.3";
+  const composer = p11.meta?.composer === "true";
+  return HEADER + (composer ? lines(
+    "FROM composer:2 AS vendor",
+    "WORKDIR /app",
+    "COPY composer.json composer.loc[k] ./",
+    "RUN composer install --no-dev --no-scripts --no-interaction --prefer-dist --ignore-platform-reqs --optimize-autoloader"
+  ) + "\n" : "") + lines(
+    `FROM php:${v}-cli`,
+    "RUN docker-php-ext-install pdo pdo_mysql opcache && useradd --create-home --uid 10001 app",
+    "WORKDIR /app",
+    composer && "COPY --from=vendor --chown=app:app /app/vendor ./vendor",
+    "COPY --chown=app:app . .",
+    "USER app",
+    `ENV PORT=${p11.port}`,
+    `EXPOSE ${p11.port}`,
+    shCmd(p11.startCommand ?? `php -S 0.0.0.0:$PORT -t ${p11.meta?.docroot ?? "."}`)
+  );
+};
+var dotnet = (p11) => {
+  const v = p11.runtimeVersion ?? "8.0";
+  const hasAppUser = Number(v.split(".")[0]) >= 8;
+  return HEADER + lines(
+    `FROM mcr.microsoft.com/dotnet/sdk:${v} AS build`,
+    "WORKDIR /src",
+    `COPY ${p11.meta?.projectFile ?? "*.csproj"} ./`,
+    "RUN dotnet restore",
+    "COPY . .",
+    "RUN dotnet publish -c Release -o /out --no-restore"
+  ) + "\n" + lines(
+    `FROM mcr.microsoft.com/dotnet/aspnet:${v}`,
+    "WORKDIR /app",
+    "COPY --from=build /out .",
+    hasAppUser ? "USER app" : "RUN useradd --system --uid 10001 app\nUSER app",
+    `ENV PORT=${p11.port}`,
+    `EXPOSE ${p11.port}`,
+    shCmd(`env ASPNETCORE_URLS=http://+:$PORT ${p11.startCommand ?? "dotnet app.dll"}`)
+  );
+};
+var DOCKER_TEMPLATES = {
+  node,
+  static: staticSite,
+  python,
+  java,
+  go,
+  rust,
+  ruby,
+  php,
+  dotnet
+};
+var IGNORES = {
+  node: ["node_modules", "npm-debug.log*", ".next", ".nuxt", ".output", "coverage"],
+  python: ["__pycache__", "*.pyc", ".venv", "venv", ".pytest_cache", ".mypy_cache"],
+  java: ["target", "build", ".gradle", "*.iml", ".idea"],
+  go: ["bin", "vendor"],
+  rust: ["target"],
+  ruby: ["log/*", "tmp/*", "vendor/bundle", ".bundle"],
+  php: ["vendor", "storage/logs/*"],
+  dotnet: ["bin", "obj", "out"]
+};
+function dockerignoreFor(p11) {
+  return ["# Generated by omnideploy", ".git", ".gitignore", "Dockerfile", ".dockerignore", ".env", ".env.*", "*.log", ".DS_Store", ...IGNORES[p11.language] ?? []].join("\n") + "\n";
+}
+
+// src/infrastructure/generators/dockerfile/DockerfileGenerator.ts
+var DockerfileGenerator = class {
+  id = "dockerfile";
+  path = "Dockerfile";
+  supports(profile) {
+    return profile.language in DOCKER_TEMPLATES;
+  }
+  generate(profile) {
+    const template = DOCKER_TEMPLATES[profile.language];
+    return {
+      id: this.id,
+      path: this.path,
+      contents: template(profile),
+      description: `multi-stage ${LANGUAGE_LABELS[profile.language]}${profile.framework ? ` (${profile.framework})` : ""} image`
+    };
+  }
+};
+var DockerignoreGenerator = class {
+  id = "dockerignore";
+  path = ".dockerignore";
+  supports() {
+    return true;
+  }
+  generate(profile) {
+    return { id: this.id, path: this.path, contents: dockerignoreFor(profile), description: "keeps the Docker build context small" };
+  }
+};
+
+// src/infrastructure/generators/provider-config/netlify.ts
+import { stringify } from "smol-toml";
+var NetlifyTomlGenerator = class {
+  id = "netlify-toml";
+  path = "netlify.toml";
+  supports(profile) {
+    return profile.kind === "static";
+  }
+  generate(p11) {
+    const config = {
+      build: { publish: p11.outputDir ?? ".", ...p11.buildCommand ? { command: p11.buildCommand } : {} }
+    };
+    if (p11.language === "node" && p11.runtimeVersion) config.build = { ...config.build, environment: { NODE_VERSION: p11.runtimeVersion } };
+    if (isSinglePageApp(p11)) config.redirects = [{ from: "/*", to: "/index.html", status: 200 }];
+    return {
+      id: this.id,
+      path: this.path,
+      contents: "# Generated by omnideploy. https://docs.netlify.com/configure-builds/file-based-configuration/\n" + stringify(config) + "\n",
+      description: "Netlify build settings" + (isSinglePageApp(p11) ? " + SPA redirect" : "")
+    };
+  }
+};
+
+// src/infrastructure/generators/provider-config/railway.ts
+var RailwayJsonGenerator = class {
+  id = "railway-json";
+  path = "railway.json";
+  supports() {
+    return true;
+  }
+  generate(p11, opts) {
+    const config = {
+      $schema: "https://railway.com/railway.schema.json",
+      build: { builder: "DOCKERFILE", dockerfilePath: "Dockerfile" },
+      deploy: {
+        healthcheckPath: opts.healthCheckPath ?? "/",
+        healthcheckTimeout: 300,
+        restartPolicyType: "ON_FAILURE",
+        restartPolicyMaxRetries: 5
+      }
+    };
+    return {
+      id: this.id,
+      path: this.path,
+      contents: JSON.stringify(config, null, 2) + "\n",
+      description: "Railway config (build from Dockerfile, health check, restart policy)"
+    };
+  }
+};
+
+// src/infrastructure/generators/provider-config/render.ts
+import { stringify as stringify2 } from "yaml";
+var RENDER_NATIVE = { node: "node", python: "python", ruby: "ruby", go: "go" };
+function renderUsesDocker(profile) {
+  return profile.kind !== "static" && (profile.hasDockerfile || !(profile.language in RENDER_NATIVE));
+}
+function renderNativeBuild(p11) {
+  switch (p11.language) {
+    case "node":
+      return [p11.meta?.install || "npm install", p11.buildCommand].filter(Boolean).join(" && ");
+    case "python": {
+      const install = p11.packageManager === "poetry" ? "pip install poetry && poetry install --no-root --only main" : p11.packageManager === "uv" ? "pip install uv && uv sync --frozen --no-dev" : "pip install -r requirements.txt";
+      return [install, p11.meta?.extraPackages && `pip install ${p11.meta.extraPackages}`, p11.buildCommand].filter(Boolean).join(" && ");
+    }
+    case "ruby":
+      return ["bundle install", p11.buildCommand].filter(Boolean).join(" && ");
+    case "go":
+      return p11.buildCommand ?? "go build -o app .";
+    default:
+      return p11.buildCommand ?? "";
+  }
+}
+function renderRuntime(p11) {
+  if (p11.kind === "static") return "static";
+  return renderUsesDocker(p11) ? "docker" : RENDER_NATIVE[p11.language];
+}
+var RenderYamlGenerator = class {
+  id = "render-yaml";
+  path = "render.yaml";
+  supports() {
+    return true;
+  }
+  generate(p11, opts) {
+    const runtime = renderRuntime(p11);
+    const service = {
+      type: "web",
+      name: opts.providerOptions.serviceName ?? opts.serviceName,
+      runtime,
+      plan: opts.providerOptions.plan ?? "free",
+      region: opts.providerOptions.region ?? "oregon"
+    };
+    if (runtime === "static") {
+      if (p11.buildCommand) service.buildCommand = p11.buildCommand;
+      service.staticPublishPath = `./${p11.outputDir ?? "."}`;
+      delete service.plan;
+      delete service.region;
+    } else if (runtime === "docker") {
+      service.dockerfilePath = "./Dockerfile";
+      service.dockerContext = ".";
+    } else {
+      service.buildCommand = renderNativeBuild(p11);
+      service.startCommand = p11.startCommand;
+    }
+    if (runtime !== "static") {
+      service.healthCheckPath = opts.healthCheckPath ?? "/";
+      service.autoDeploy = true;
+    }
+    if (p11.kind === "static" && /^(vite|create-react-app|angular)/.test(p11.framework ?? "")) {
+      service.routes = [{ type: "rewrite", source: "/*", destination: "/index.html" }];
+    }
+    return {
+      id: this.id,
+      path: this.path,
+      contents: "# Render Blueprint \u2014 generated by omnideploy. https://render.com/docs/blueprint-spec\n" + stringify2({ services: [service] }),
+      description: `Render Blueprint (${runtime} runtime)`
+    };
+  }
+};
+
+// src/infrastructure/generators/provider-config/vercel.ts
+var VercelJsonGenerator = class {
+  id = "vercel-json";
+  path = "vercel.json";
+  supports(profile) {
+    return isSinglePageApp(profile);
+  }
+  generate() {
+    const config = {
+      $schema: "https://openapi.vercel.sh/vercel.json",
+      rewrites: [{ source: "/(.*)", destination: "/index.html" }]
+    };
+    return { id: this.id, path: this.path, contents: JSON.stringify(config, null, 2) + "\n", description: "SPA rewrite so client-side routes work on refresh" };
+  }
+};
+
+// src/infrastructure/generators/index.ts
+function builtInGenerators() {
+  return [
+    new DockerfileGenerator(),
+    new DockerignoreGenerator(),
+    new RenderYamlGenerator(),
+    new RailwayJsonGenerator(),
+    new VercelJsonGenerator(),
+    new NetlifyTomlGenerator()
+  ];
+}
+
+// src/infrastructure/git/CliGit.ts
+function parseGitHubRemote(url) {
+  const m = url.match(/github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  return m ? { owner: m[1], repo: m[2] } : void 0;
+}
+var CliGit = class {
+  constructor(proc) {
+    this.proc = proc;
+  }
+  proc;
+  async git(dir, args, what) {
+    const r = await this.proc.run("git", args, { cwd: dir });
+    if (r.exitCode !== 0) throw new GitError(`git ${what} failed: ${(r.stderr || r.stdout).trim()}`);
+    return r.stdout.trim();
+  }
+  async isRepo(dir) {
+    const r = await this.proc.run("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir });
+    return r.exitCode === 0 && r.stdout.trim() === "true";
+  }
+  async remote(dir, name = "origin") {
+    const r = await this.proc.run("git", ["remote", "get-url", name], { cwd: dir });
+    if (r.exitCode !== 0) return null;
+    const url = r.stdout.trim();
+    return { url, github: parseGitHubRemote(url) };
+  }
+  async currentBranch(dir) {
+    const r = await this.proc.run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir });
+    return r.exitCode === 0 ? r.stdout.trim() : null;
+  }
+  async dirtyPaths(dir, paths = []) {
+    const out = await this.git(dir, ["status", "--porcelain", "--untracked-files=all", "--", ...paths], "status");
+    return out.split("\n").filter(Boolean).map((line) => line.slice(3).split(" -> ").pop().replace(/^"|"$/g, ""));
+  }
+  async commit(dir, paths, message) {
+    await this.git(dir, ["add", "--", ...paths], "add");
+    await this.git(dir, [...await this.identityArgs(dir), "commit", "-m", message, "--", ...paths], "commit");
+  }
+  async push(dir, remote = "origin", branch) {
+    const target = branch ?? await this.currentBranch(dir) ?? "HEAD";
+    await this.git(dir, ["push", "-u", remote, target], "push");
+  }
+  async publishDirectory(sourceDir, remoteUrl, branch, message) {
+    await this.git(sourceDir, ["init", "-q"], "init");
+    await this.git(sourceDir, ["checkout", "-q", "-b", branch], "checkout");
+    await this.git(sourceDir, ["add", "-A"], "add");
+    await this.git(sourceDir, [...await this.identityArgs(sourceDir), "commit", "-q", "-m", message], "commit");
+    await this.git(sourceDir, ["push", "--force", remoteUrl, `HEAD:${branch}`], "push");
+  }
+  /** Lets commits succeed on machines without a configured git identity. */
+  async identityArgs(dir) {
+    const r = await this.proc.run("git", ["config", "user.email"], { cwd: dir });
+    return r.exitCode === 0 && r.stdout.trim() ? [] : ["-c", "user.name=omnideploy", "-c", "user.email=omnideploy@users.noreply.github.com"];
+  }
+};
+
+// src/infrastructure/http/FetchHttpClient.ts
+var RETRYABLE = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var FetchHttpClient = class {
+  retries;
+  backoffMs;
+  userAgent;
+  fetchImpl;
+  constructor(opts = {}) {
+    this.retries = opts.retries ?? 3;
+    this.backoffMs = opts.backoffMs ?? 500;
+    this.userAgent = opts.userAgent ?? "omnideploy-cli";
+    this.fetchImpl = opts.fetchImpl;
+  }
+  async request(req, opts = {}) {
+    const url = new URL(req.url);
+    for (const [k, v] of Object.entries(req.query ?? {})) if (v !== void 0) url.searchParams.set(k, String(v));
+    const headers = { "user-agent": this.userAgent, accept: "application/json", ...req.headers };
+    let body;
+    if (req.json !== void 0) {
+      headers["content-type"] ??= "application/json";
+      body = JSON.stringify(req.json);
+    } else if (req.body !== void 0) {
+      body = req.body;
+    }
+    const provider = opts.provider ?? url.hostname;
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      if (attempt > 0) await sleep(this.backoffMs * 2 ** (attempt - 1));
+      let res;
+      try {
+        res = await (this.fetchImpl ?? globalThis.fetch)(url, { method: req.method ?? "GET", headers, body });
+      } catch (e) {
+        lastError = e;
+        continue;
+      }
+      const data = await parseBody(res);
+      if (res.ok || opts.allowStatus?.includes(res.status)) {
+        return { status: res.status, headers: Object.fromEntries(res.headers.entries()), data };
+      }
+      lastError = new ProviderApiError(provider, extractMessage(data, res.statusText), res.status, hintFor(res.status));
+      if (!RETRYABLE.has(res.status)) break;
+    }
+    if (lastError instanceof ProviderApiError) throw lastError;
+    throw new ProviderApiError(provider, `request to ${url.host} failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`, void 0, "Check your network connection.");
+  }
+};
+async function parseBody(res) {
+  const text2 = await res.text();
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function extractMessage(data, fallback) {
+  if (typeof data === "string") return data.slice(0, 300) || fallback;
+  if (data && typeof data === "object") {
+    const d = data;
+    const err = d.error;
+    if (err && typeof err === "object" && typeof err.message === "string") {
+      return err.message;
+    }
+    if (typeof err === "string") return err;
+    if (typeof d.message === "string") return d.message;
+    if (Array.isArray(d.errors) && d.errors.length) return JSON.stringify(d.errors).slice(0, 300);
+  }
+  return fallback || "unknown error";
+}
+function hintFor(status) {
+  if (status === 401 || status === 403) return "Your token may be invalid or expired. Run `omnideploy login <provider>` again.";
+  if (status === 404) return "The resource was not found \u2014 check the IDs in omnideploy.json.";
+  if (status === 429) return "Rate limited by the provider. Wait a moment and retry.";
+  return void 0;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/infrastructure/process/ExecaProcessRunner.ts
+import { execa } from "execa";
+var ExecaProcessRunner = class {
+  async run(bin, args, opts = {}) {
+    try {
+      const r = await execa(bin, args, {
+        cwd: opts.cwd,
+        env: opts.env,
+        input: opts.input,
+        reject: false,
+        stdio: opts.inherit ? "inherit" : "pipe"
+      });
+      return { exitCode: r.exitCode ?? 1, stdout: String(r.stdout ?? ""), stderr: String(r.stderr ?? "") };
+    } catch (e) {
+      return { exitCode: 127, stdout: "", stderr: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async shell(command, opts = {}) {
+    try {
+      const r = await execa(command, {
+        shell: true,
+        cwd: opts.cwd,
+        env: opts.env,
+        input: opts.input,
+        reject: false,
+        stdio: opts.inherit ? "inherit" : "pipe"
+      });
+      return { exitCode: r.exitCode ?? 1, stdout: String(r.stdout ?? ""), stderr: String(r.stderr ?? "") };
+    } catch (e) {
+      return { exitCode: 127, stdout: "", stderr: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async has(bin) {
+    const probe = process.platform === "win32" ? await this.run("where", [bin]) : await this.run("which", [bin]);
+    return probe.exitCode === 0;
+  }
+};
+
+// src/infrastructure/providers/support.ts
+import { createHash } from "crypto";
+import { PassThrough } from "stream";
+import { ZipArchive } from "archiver";
+var DEFAULT_POLL = { intervalMs: 3e3, timeoutMs: 20 * 6e4 };
+async function poll(fn, done, opts) {
+  const deadline = Date.now() + opts.timeoutMs;
+  for (; ; ) {
+    const value = await fn();
+    if (done(value)) return { value, timedOut: false };
+    if (Date.now() >= deadline) return { value, timedOut: true };
+    await new Promise((r) => setTimeout(r, opts.intervalMs));
+  }
+}
+var sha1 = (data) => createHash("sha1").update(data).digest("hex");
+async function zip(files) {
+  const archive = new ZipArchive({ zlib: { level: 9 } });
+  const sink = new PassThrough();
+  const chunks = [];
+  sink.on("data", (c) => chunks.push(c));
+  const finished = new Promise((resolve3, reject) => {
+    sink.on("end", resolve3);
+    archive.on("error", reject);
+  });
+  archive.pipe(sink);
+  for (const f of files) archive.append(Buffer.from(f.data), { name: f.path });
+  await archive.finalize();
+  await finished;
+  return new Uint8Array(Buffer.concat(chunks));
+}
+var textFile = (path, text2) => ({ path, data: new TextEncoder().encode(text2) });
+var redact = (text2, secret) => secret ? text2.split(secret).join("***") : text2;
+
+// src/infrastructure/providers/GitHubPagesProvider.ts
+var API = "https://api.github.com";
+var GitHubPagesProvider = class {
+  constructor(http, fs, git, pollOpts = { ...DEFAULT_POLL, timeoutMs: 3 * 6e4 }) {
+    this.http = http;
+    this.fs = fs;
+    this.git = git;
+    this.pollOpts = pollOpts;
+  }
+  http;
+  fs;
+  git;
+  pollOpts;
+  id = "github-pages";
+  displayName = "GitHub Pages";
+  capabilities = {
+    kinds: ["static"],
+    serverLanguages: [],
+    buildsFromGit: false,
+    auth: { envVar: "GITHUB_TOKEN", tokenUrl: "https://github.com/settings/tokens/new?scopes=repo&description=omnideploy" }
+  };
+  requiredArtifacts() {
+    return [];
+  }
+  async validate(ctx) {
+    await this.repo(ctx.rootDir, ctx.options);
+  }
+  async deploy(ctx) {
+    const { owner, repo } = await this.repo(ctx.profile.rootDir, ctx.options);
+    const branch = ctx.options.branch ?? "gh-pages";
+    const cname = ctx.options.cname;
+    const userSite = repo.toLowerCase() === `${owner.toLowerCase()}.github.io`;
+    if (!cname && !userSite && /^(vite|create-react-app|angular)/.test(ctx.profile.framework ?? "")) {
+      ctx.logger.warn(`GitHub Pages serves this site under /${repo}/. If assets 404, set the base path (Vite: base: '/${repo}/', CRA: "homepage").`);
+    }
+    ctx.progress("preparing files");
+    const tmp = await this.fs.makeTempDir("omnideploy-pages");
+    try {
+      await this.fs.copyDir(ctx.sourceDir, tmp);
+      await this.fs.writeText(this.fs.join(tmp, ".nojekyll"), "");
+      if (cname) await this.fs.writeText(this.fs.join(tmp, "CNAME"), cname + "\n");
+      if (isSinglePageApp(ctx.profile)) {
+        const index = await this.fs.readTextIfExists(this.fs.join(tmp, "index.html"));
+        if (index && !await this.fs.exists(this.fs.join(tmp, "404.html"))) await this.fs.writeText(this.fs.join(tmp, "404.html"), index);
+      }
+      ctx.progress(`pushing to ${branch}`);
+      const remoteUrl = `https://x-access-token:${ctx.token}@github.com/${owner}/${repo}.git`;
+      try {
+        await this.git.publishDirectory(tmp, remoteUrl, branch, `Deploy to GitHub Pages (omnideploy) ${(/* @__PURE__ */ new Date()).toISOString()}`);
+      } catch (e) {
+        throw new GitError(redact(e instanceof Error ? e.message : String(e), ctx.token), 'Check that the token has the "repo" scope and push access.');
+      }
+    } finally {
+      await this.fs.remove(tmp);
+    }
+    ctx.progress("enabling GitHub Pages");
+    const pages = await this.ensurePages(ctx.token, owner, repo, branch);
+    ctx.progress("waiting for Pages build");
+    const { value: build, timedOut } = await poll(
+      () => this.latestBuild(ctx.token, owner, repo),
+      (b) => b?.status === "built" || b?.status === "errored",
+      this.pollOpts
+    );
+    if (build?.status === "errored") {
+      throw new DomainError(`GitHub Pages build failed: ${build.error?.message ?? "unknown error"}`, `See https://github.com/${owner}/${repo}/actions`, "DEPLOYMENT_FAILED");
+    }
+    const url = cname ? `https://${cname}/` : pages.html_url ?? (userSite ? `https://${repo}/` : `https://${owner}.github.io/${repo}/`);
+    return {
+      provider: this.id,
+      id: build?.commit ?? "latest",
+      url,
+      state: timedOut || !build ? "building" : "ready",
+      dashboardUrl: `https://github.com/${owner}/${repo}/settings/pages`,
+      configUpdates: { repo: `${owner}/${repo}`, branch }
+    };
+  }
+  async status(ctx) {
+    const [owner, repo] = String(ctx.options.repo ?? "").split("/");
+    if (!owner || !repo) return { id: "-", state: "unknown", message: "Deploy once first (repo is stored in omnideploy.json)." };
+    const b = await this.latestBuild(ctx.token, owner, repo);
+    if (!b) return { id: "-", state: "unknown", message: "No Pages builds yet." };
+    return {
+      id: b.commit ?? "latest",
+      state: b.status === "built" ? "ready" : b.status === "errored" ? "error" : "building",
+      createdAt: b.created_at,
+      message: b.error?.message ?? void 0
+    };
+  }
+  async repo(rootDir, options) {
+    if (typeof options.repo === "string" && options.repo.includes("/")) {
+      const [owner, repo] = options.repo.split("/");
+      return { owner, repo };
+    }
+    const remote = await this.git.remote(rootDir);
+    if (!remote?.github) {
+      throw new DomainError(
+        "GitHub Pages needs a GitHub repository.",
+        'Add a GitHub remote (git remote add origin https://github.com/<you>/<repo>.git) or set providers["github-pages"].repo = "owner/repo".',
+        "NO_GITHUB_REMOTE"
+      );
+    }
+    return remote.github;
+  }
+  async ensurePages(token, owner, repo, branch) {
+    const headers = this.headers(token);
+    const url = `${API}/repos/${owner}/${repo}/pages`;
+    const existing = await this.http.request({ url, headers }, { provider: "GitHub", allowStatus: [404] });
+    const source = { branch, path: "/" };
+    if (existing.status === 404) {
+      return (await this.http.request({ method: "POST", url, headers, json: { source } }, { provider: "GitHub", allowStatus: [409] })).data;
+    }
+    if (existing.data.source?.branch !== branch) {
+      await this.http.request({ method: "PUT", url, headers, json: { source } }, { provider: "GitHub" });
+    }
+    return existing.data;
+  }
+  async latestBuild(token, owner, repo) {
+    const r = await this.http.request(
+      { url: `${API}/repos/${owner}/${repo}/pages/builds/latest`, headers: this.headers(token) },
+      { provider: "GitHub", allowStatus: [404] }
+    );
+    return r.status === 404 ? null : r.data;
+  }
+  headers(token) {
+    return { authorization: `Bearer ${token}`, accept: "application/vnd.github+json", "x-github-api-version": "2022-11-28" };
+  }
+};
+
+// src/infrastructure/providers/NetlifyProvider.ts
+var API2 = "https://api.netlify.com/api/v1";
+var STATE = {
+  new: "queued",
+  uploading: "building",
+  uploaded: "building",
+  preparing: "building",
+  prepared: "building",
+  processing: "building",
+  processed: "building",
+  ready: "ready",
+  error: "error"
+};
+var NetlifyProvider = class {
+  constructor(http, fs, pollOpts = DEFAULT_POLL) {
+    this.http = http;
+    this.fs = fs;
+    this.pollOpts = pollOpts;
+  }
+  http;
+  fs;
+  pollOpts;
+  id = "netlify";
+  displayName = "Netlify";
+  capabilities = {
+    kinds: ["static"],
+    serverLanguages: [],
+    buildsFromGit: false,
+    auth: { envVar: "NETLIFY_AUTH_TOKEN", tokenUrl: "https://app.netlify.com/user/applications#personal-access-tokens" }
+  };
+  requiredArtifacts() {
+    return ["netlify-toml"];
+  }
+  async validate() {
+  }
+  async deploy(ctx) {
+    const site = await this.ensureSite(ctx);
+    ctx.progress("packaging files");
+    const paths = await this.fs.collectFiles(ctx.sourceDir);
+    const files = await Promise.all(paths.map(async (p11) => ({ path: p11, data: await this.fs.readBytes(this.fs.join(ctx.sourceDir, p11)) })));
+    if (isSinglePageApp(ctx.profile) && !paths.includes("_redirects")) files.push(textFile("_redirects", "/*  /index.html  200\n"));
+    const archive = await zip(files);
+    ctx.progress(`uploading ${files.length} files`);
+    const created = await this.http.request(
+      {
+        method: "POST",
+        url: `${API2}/sites/${site.id}/deploys`,
+        headers: { ...this.auth(ctx.token), "content-type": "application/zip" },
+        query: { draft: ctx.production ? void 0 : true },
+        body: archive
+      },
+      { provider: "Netlify" }
+    );
+    ctx.progress("processing");
+    const { value: d, timedOut } = await poll(
+      () => this.getDeploy(ctx.token, created.data.id),
+      (d2) => d2.state === "ready" || d2.state === "error",
+      this.pollOpts
+    );
+    if (d.state === "error") throw new DeploymentFailedError("Netlify", d.error_message ?? "unknown error", d.admin_url);
+    return {
+      provider: this.id,
+      id: d.id,
+      url: ctx.production ? site.ssl_url ?? d.ssl_url ?? site.url : d.deploy_ssl_url ?? d.ssl_url,
+      state: timedOut ? "building" : "ready",
+      dashboardUrl: site.admin_url,
+      configUpdates: { siteId: site.id, siteName: site.name }
+    };
+  }
+  async status(ctx, deploymentId) {
+    let d;
+    if (deploymentId) d = await this.getDeploy(ctx.token, deploymentId);
+    else {
+      const siteId = ctx.options.siteId;
+      if (!siteId) return { id: "-", state: "unknown", message: "No Netlify site yet \u2014 deploy first." };
+      const r = await this.http.request({ url: `${API2}/sites/${siteId}/deploys`, headers: this.auth(ctx.token), query: { per_page: 1 } }, { provider: "Netlify" });
+      d = r.data[0];
+    }
+    if (!d) return { id: "-", state: "unknown", message: "No deployments yet." };
+    return { id: d.id, state: STATE[d.state] ?? "unknown", url: d.deploy_ssl_url ?? d.ssl_url, createdAt: d.created_at, message: d.error_message };
+  }
+  async ensureSite(ctx) {
+    const siteId = ctx.options.siteId;
+    if (siteId) {
+      return (await this.http.request({ url: `${API2}/sites/${siteId}`, headers: this.auth(ctx.token) }, { provider: "Netlify" })).data;
+    }
+    ctx.progress("creating site");
+    const base = ctx.options.siteName ?? ctx.serviceName;
+    for (const name of [base, `${base}-${randomSuffix()}`, `${base}-${randomSuffix()}`]) {
+      const r = await this.http.request(
+        { method: "POST", url: `${API2}/sites`, headers: this.auth(ctx.token), json: { name } },
+        { provider: "Netlify", allowStatus: [422] }
+      );
+      if (r.status !== 422) return r.data;
+    }
+    throw new DeploymentFailedError("Netlify", `could not create a site named "${base}"`, "Set providers.netlify.siteName in omnideploy.json.");
+  }
+  async getDeploy(token, id) {
+    return (await this.http.request({ url: `${API2}/deploys/${id}`, headers: this.auth(token) }, { provider: "Netlify" })).data;
+  }
+  auth(token) {
+    return { authorization: `Bearer ${token}` };
+  }
+};
+var randomSuffix = () => Math.random().toString(36).slice(2, 7);
+
+// src/infrastructure/providers/RailwayProvider.ts
+var INSTALL = "npm i -g @railway/cli   (or: brew install railway)";
+var RailwayProvider = class {
+  constructor(proc) {
+    this.proc = proc;
+  }
+  proc;
+  id = "railway";
+  displayName = "Railway";
+  capabilities = {
+    kinds: ["static", "server", "serverless"],
+    serverLanguages: "any",
+    buildsFromGit: false,
+    requiredCli: { bin: "railway", install: INSTALL },
+    auth: { envVar: "RAILWAY_TOKEN", tokenUrl: "https://railway.com/account/tokens  (create a *project* token: Project \u2192 Settings \u2192 Tokens)" }
+  };
+  requiredArtifacts() {
+    return ["dockerfile", "dockerignore", "railway-json"];
+  }
+  async validate() {
+    if (!await this.proc.has("railway")) throw new MissingToolError("railway", INSTALL);
+  }
+  async deploy(ctx) {
+    const env2 = { RAILWAY_TOKEN: ctx.token };
+    const scope = [
+      ...ctx.options.service ? ["--service", String(ctx.options.service)] : [],
+      ...ctx.options.environment ? ["--environment", String(ctx.options.environment)] : []
+    ];
+    ctx.progress("uploading and building (this can take a few minutes)");
+    const up = await this.proc.run("railway", ["up", "--ci", ...scope], { cwd: ctx.profile.rootDir, env: env2 });
+    const output = redact(`${up.stdout}
+${up.stderr}`, ctx.token);
+    const logsUrl = output.match(/https:\/\/railway\.(?:com|app)\/project\/\S+/)?.[0];
+    if (up.exitCode !== 0) {
+      const tail = output.trim().split("\n").slice(-12).join("\n");
+      throw new DeploymentFailedError("Railway", tail || `railway up exited with ${up.exitCode}`, logsUrl ? `Build logs: ${logsUrl}` : void 0);
+    }
+    ctx.progress("fetching public URL");
+    const domain = await this.proc.run("railway", ["domain", ...scope], { cwd: ctx.profile.rootDir, env: env2 });
+    const url = `${domain.stdout}
+${domain.stderr}`.match(/https:\/\/[a-z0-9.-]+\.(?:up\.railway\.app|railway\.app|[a-z]{2,})/i)?.[0];
+    return {
+      provider: this.id,
+      id: logsUrl?.match(/[?&]id=([\w-]+)/)?.[1] ?? "latest",
+      url,
+      state: "ready",
+      dashboardUrl: logsUrl
+    };
+  }
+};
+
+// src/infrastructure/providers/RenderProvider.ts
+var API3 = "https://api.render.com/v1";
+var STATE2 = {
+  created: "queued",
+  queued: "queued",
+  build_in_progress: "building",
+  update_in_progress: "building",
+  pre_deploy_in_progress: "building",
+  live: "ready",
+  deactivated: "ready",
+  build_failed: "error",
+  update_failed: "error",
+  pre_deploy_failed: "error",
+  canceled: "canceled"
+};
+var FINAL = /* @__PURE__ */ new Set(["live", "deactivated", "build_failed", "update_failed", "pre_deploy_failed", "canceled"]);
+var RenderProvider = class {
+  constructor(http, git, pollOpts = DEFAULT_POLL) {
+    this.http = http;
+    this.git = git;
+    this.pollOpts = pollOpts;
+  }
+  http;
+  git;
+  pollOpts;
+  id = "render";
+  displayName = "Render";
+  capabilities = {
+    kinds: ["static", "server", "serverless"],
+    serverLanguages: "any",
+    buildsFromGit: true,
+    auth: { envVar: "RENDER_API_KEY", tokenUrl: "https://dashboard.render.com/u/settings#api-keys" }
+  };
+  requiredArtifacts(profile) {
+    return renderUsesDocker(profile) ? ["dockerfile", "dockerignore", "render-yaml"] : ["render-yaml"];
+  }
+  async validate(ctx) {
+    if (ctx.options.serviceId) return;
+    const remote = await this.git.remote(ctx.rootDir);
+    if (remote && !toHttpsRepo(remote.url)) {
+      throw new DomainError(`Render cannot use the git remote "${remote.url}".`, "Use a GitHub, GitLab or Bitbucket remote.", "UNSUPPORTED_REMOTE");
+    }
+  }
+  async deploy(ctx) {
+    let serviceId = ctx.options.serviceId;
+    let ownerId = ctx.options.ownerId;
+    let deployId;
+    if (!serviceId) {
+      ownerId ??= await this.ownerId(ctx);
+      ctx.progress("creating service");
+      const created = await this.createService(ctx, ownerId);
+      serviceId = created.service.id;
+      deployId = created.deployId;
+    } else {
+      ctx.progress("triggering deploy");
+      const r = await this.http.request(
+        { method: "POST", url: `${API3}/services/${serviceId}/deploys`, headers: this.auth(ctx.token), json: { clearCache: "do_not_clear" } },
+        { provider: "Render" }
+      );
+      deployId = r.data.id;
+    }
+    const { value: d, timedOut } = await poll(
+      () => this.getDeploy(ctx.token, serviceId, deployId),
+      (d2) => {
+        ctx.progress(`${d2.status.replace(/_/g, " ")} (Render builds can take several minutes)`);
+        return FINAL.has(d2.status);
+      },
+      this.pollOpts
+    );
+    const service = await this.getService(ctx.token, serviceId);
+    const state = STATE2[d.status] ?? "unknown";
+    if (state === "error" || state === "canceled") {
+      throw new DeploymentFailedError("Render", d.status.replace(/_/g, " "), service.dashboardUrl ? `Logs: ${service.dashboardUrl}/deploys/${d.id}` : void 0);
+    }
+    return {
+      provider: this.id,
+      id: d.id,
+      url: service.serviceDetails?.url,
+      state: timedOut ? "building" : state,
+      dashboardUrl: service.dashboardUrl,
+      configUpdates: { serviceId, ownerId }
+    };
+  }
+  async status(ctx, deploymentId) {
+    const serviceId = ctx.options.serviceId;
+    if (!serviceId) return { id: "-", state: "unknown", message: "No Render service yet \u2014 deploy first." };
+    let d;
+    if (deploymentId) d = await this.getDeploy(ctx.token, serviceId, deploymentId);
+    else {
+      const r = await this.http.request({ url: `${API3}/services/${serviceId}/deploys`, headers: this.auth(ctx.token), query: { limit: 1 } }, { provider: "Render" });
+      d = r.data[0]?.deploy;
+    }
+    if (!d) return { id: "-", state: "unknown", message: "No deploys yet." };
+    const service = await this.getService(ctx.token, serviceId);
+    return { id: d.id, state: STATE2[d.status] ?? "unknown", url: service.serviceDetails?.url, createdAt: d.createdAt, message: d.status };
+  }
+  async ownerId(ctx) {
+    const r = await this.http.request(
+      { url: `${API3}/owners`, headers: this.auth(ctx.token), query: { limit: 20 } },
+      { provider: "Render" }
+    );
+    const owners = r.data.map((o) => o.owner);
+    if (owners.length === 0) throw new DomainError("Your Render account has no workspace.", "Create one at https://dashboard.render.com.", "RENDER_NO_OWNER");
+    if (owners.length > 1) ctx.logger.warn(`Using Render workspace "${owners[0].name}". Set providers.render.ownerId to choose another.`);
+    return owners[0].id;
+  }
+  async createService(ctx, ownerId) {
+    const p11 = ctx.profile;
+    const remote = await this.git.remote(p11.rootDir);
+    const repo = remote && toHttpsRepo(remote.url);
+    if (!repo) throw new DomainError("Render needs a git remote to build from.", "git remote add origin <url> && git push -u origin HEAD", "NO_GIT_REMOTE");
+    const branch = ctx.options.branch ?? await this.git.currentBranch(p11.rootDir) ?? "main";
+    const runtime = renderRuntime(p11);
+    const serviceDetails = runtime === "static" ? { buildCommand: p11.buildCommand ?? "", publishPath: p11.outputDir ?? "." } : {
+      runtime,
+      plan: ctx.options.plan ?? "free",
+      region: ctx.options.region ?? "oregon",
+      healthCheckPath: ctx.options.healthCheckPath ?? "/",
+      envSpecificDetails: runtime === "docker" ? { dockerfilePath: "./Dockerfile", dockerContext: "." } : { buildCommand: renderNativeBuild(p11), startCommand: p11.startCommand ?? "" }
+    };
+    try {
+      const r = await this.http.request(
+        {
+          method: "POST",
+          url: `${API3}/services`,
+          headers: this.auth(ctx.token),
+          json: {
+            type: runtime === "static" ? "static_site" : "web_service",
+            name: ctx.options.serviceName ?? ctx.serviceName,
+            ownerId,
+            repo,
+            branch,
+            autoDeploy: "yes",
+            serviceDetails
+          }
+        },
+        { provider: "Render" }
+      );
+      return r.data;
+    } catch (e) {
+      if (e instanceof ProviderApiError && e.status && e.status < 500 && /repo/i.test(e.message)) {
+        throw new ProviderApiError("Render", e.message, e.status, "Connect your Git provider to Render (Account settings \u2192 Git) and grant access to this repository.");
+      }
+      throw e;
+    }
+  }
+  async getDeploy(token, serviceId, deployId) {
+    return (await this.http.request({ url: `${API3}/services/${serviceId}/deploys/${deployId}`, headers: this.auth(token) }, { provider: "Render" })).data;
+  }
+  async getService(token, serviceId) {
+    return (await this.http.request({ url: `${API3}/services/${serviceId}`, headers: this.auth(token) }, { provider: "Render" })).data;
+  }
+  auth(token) {
+    return { authorization: `Bearer ${token}` };
+  }
+};
+function toHttpsRepo(url) {
+  const m = url.match(/^(?:git@|ssh:\/\/git@|https?:\/\/(?:[^@/]+@)?)(github\.com|gitlab\.com|bitbucket\.org)[:/](.+?)(?:\.git)?\/?$/);
+  return m ? `https://${m[1]}/${m[2]}` : null;
+}
+
+// src/infrastructure/providers/VercelProvider.ts
+var API4 = "https://api.vercel.com";
+var STATE3 = {
+  QUEUED: "queued",
+  INITIALIZING: "building",
+  BUILDING: "building",
+  READY: "ready",
+  ERROR: "error",
+  CANCELED: "canceled"
+};
+var SOURCE_IGNORES = [".vercel/**", ".next/**", ".nuxt/**", ".output/**", ".svelte-kit/**", "dist/**", ".env", ".env.*"];
+var VercelProvider = class {
+  constructor(http, fs, pollOpts = DEFAULT_POLL) {
+    this.http = http;
+    this.fs = fs;
+    this.pollOpts = pollOpts;
+  }
+  http;
+  fs;
+  pollOpts;
+  id = "vercel";
+  displayName = "Vercel";
+  capabilities = {
+    kinds: ["static", "serverless"],
+    serverLanguages: [],
+    serverlessFrameworks: ["nextjs", "nuxt", "sveltekit", "remix", "astro"],
+    buildsFromGit: false,
+    auth: { envVar: "VERCEL_TOKEN", tokenUrl: "https://vercel.com/account/tokens" }
+  };
+  requiredArtifacts(profile) {
+    return isSinglePageApp(profile) ? ["vercel-json"] : [];
+  }
+  async validate() {
+  }
+  async deploy(ctx) {
+    const isStatic = ctx.profile.kind === "static";
+    const files = await this.collect(ctx, isStatic);
+    const name = ctx.options.project ?? ctx.serviceName;
+    const query = { teamId: ctx.options.teamId, skipAutoDetectionConfirmation: 1 };
+    const manifest = files.map((f) => ({ file: f.path, sha: sha1(f.data), size: f.data.byteLength }));
+    const body = {
+      name,
+      files: manifest,
+      target: ctx.production ? "production" : void 0,
+      projectSettings: isStatic ? { framework: null } : { framework: ctx.profile.framework === "nextjs" ? "nextjs" : ctx.profile.framework }
+    };
+    ctx.progress(`creating deployment (${files.length} files)`);
+    let created = await this.http.request(
+      { method: "POST", url: `${API4}/v13/deployments`, headers: this.auth(ctx.token), query, json: body },
+      { provider: "Vercel", allowStatus: [400] }
+    );
+    if (created.status === 400) {
+      const missing = new Set(created.data.error?.missing ?? []);
+      if (created.data.error?.code !== "missing_files" || missing.size === 0) {
+        throw new ProviderApiError("Vercel", JSON.stringify(created.data.error), 400);
+      }
+      await this.upload(ctx, files.filter((f) => missing.has(sha1(f.data))), query.teamId);
+      ctx.progress("creating deployment");
+      created = await this.http.request({ method: "POST", url: `${API4}/v13/deployments`, headers: this.auth(ctx.token), query, json: body }, { provider: "Vercel" });
+    }
+    ctx.progress("building");
+    const { value: d, timedOut } = await poll(
+      () => this.get(ctx.token, created.data.id, query.teamId),
+      (d2) => ["READY", "ERROR", "CANCELED"].includes(d2.readyState ?? d2.status ?? ""),
+      this.pollOpts
+    );
+    const state = STATE3[d.readyState ?? d.status ?? ""] ?? "unknown";
+    if (state === "error" || state === "canceled") {
+      throw new DeploymentFailedError("Vercel", d.errorMessage ?? state, d.inspectorUrl ? `Build logs: ${d.inspectorUrl}` : void 0);
+    }
+    const host = ctx.production ? d.alias?.[0] ?? d.url : d.url;
+    return {
+      provider: this.id,
+      id: d.id,
+      url: `https://${host}`,
+      state: timedOut ? "building" : state,
+      dashboardUrl: d.inspectorUrl,
+      configUpdates: { project: name, projectId: d.projectId }
+    };
+  }
+  async status(ctx, deploymentId) {
+    const teamId = ctx.options.teamId;
+    let id = deploymentId;
+    if (!id) {
+      const list = await this.http.request(
+        { url: `${API4}/v6/deployments`, headers: this.auth(ctx.token), query: { projectId: ctx.options.projectId, limit: 1, teamId } },
+        { provider: "Vercel" }
+      );
+      id = list.data.deployments[0]?.uid;
+      if (!id) return { id: "-", state: "unknown", message: "No deployments yet." };
+    }
+    const d = await this.get(ctx.token, id, teamId);
+    return {
+      id: d.id,
+      state: STATE3[d.readyState ?? d.status ?? ""] ?? "unknown",
+      url: `https://${d.url}`,
+      createdAt: d.createdAt ? new Date(d.createdAt).toISOString() : void 0,
+      message: d.errorMessage
+    };
+  }
+  async collect(ctx, isStatic) {
+    const root = ctx.profile.rootDir;
+    const paths = isStatic ? await this.fs.collectFiles(ctx.sourceDir) : await this.fs.collectFiles(root, { respectGitignore: true, ignore: SOURCE_IGNORES });
+    const base = isStatic ? ctx.sourceDir : root;
+    const files = await Promise.all(paths.map(async (p11) => ({ path: p11, data: await this.fs.readBytes(this.fs.join(base, p11)) })));
+    if (isStatic && !paths.includes("vercel.json")) {
+      const cfg = await this.fs.readTextIfExists(this.fs.join(root, "vercel.json"));
+      if (cfg) files.push({ path: "vercel.json", data: new TextEncoder().encode(cfg) });
+    }
+    return files;
+  }
+  async upload(ctx, files, teamId) {
+    let done = 0;
+    const queue = [...files];
+    const worker = async () => {
+      for (let f = queue.shift(); f; f = queue.shift()) {
+        await this.http.request(
+          {
+            method: "POST",
+            url: `${API4}/v2/files`,
+            query: { teamId },
+            headers: { ...this.auth(ctx.token), "content-type": "application/octet-stream", "x-vercel-digest": sha1(f.data) },
+            body: f.data
+          },
+          { provider: "Vercel" }
+        );
+        ctx.progress(`uploading files ${++done}/${files.length}`);
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(8, files.length) }, worker));
+  }
+  async get(token, id, teamId) {
+    const r = await this.http.request({ url: `${API4}/v13/deployments/${id}`, headers: this.auth(token), query: { teamId } }, { provider: "Vercel" });
+    return r.data;
+  }
+  auth(token) {
+    return { authorization: `Bearer ${token}` };
+  }
+};
+
+// src/infrastructure/providers/index.ts
+function builtInProviders({ http, fs, git, proc }) {
+  return [
+    new VercelProvider(http, fs),
+    new NetlifyProvider(http, fs),
+    new GitHubPagesProvider(http, fs, git),
+    new RailwayProvider(proc),
+    new RenderProvider(http, git)
+  ];
+}
+
+// src/cli/presenters/ClackPrompt.ts
+import * as p9 from "@clack/prompts";
+function unwrap(value) {
+  if (p9.isCancel(value)) throw new UserCancelledError();
+  return value;
+}
+var ClackPrompt = class {
+  constructor(interactive) {
+    this.interactive = interactive;
+  }
+  interactive;
+  async confirm(message, initial = true) {
+    return unwrap(await p9.confirm({ message, initialValue: initial }));
+  }
+  async select(message, choices) {
+    return unwrap(await p9.select({ message, options: choices }));
+  }
+  async multiselect(message, choices, initial = []) {
+    return unwrap(await p9.multiselect({ message, options: choices, initialValues: initial, required: true }));
+  }
+  async text(message, opts = {}) {
+    return unwrap(await p9.text({ message, placeholder: opts.placeholder, initialValue: opts.initial }));
+  }
+  async password(message) {
+    return unwrap(await p9.password({ message }));
+  }
+  note(body, title) {
+    p9.note(body, title);
+  }
+  spinner() {
+    if (!this.interactive) {
+      return {
+        start: (m) => p9.log.step(m),
+        message: () => {
+        },
+        stop: (m, ok = true) => ok ? p9.log.success(m) : p9.log.error(m)
+      };
+    }
+    const s = p9.spinner();
+    return {
+      start: (m) => s.start(m),
+      message: (m) => s.message(m),
+      stop: (m, ok = true) => ok ? s.stop(m) : s.error(m)
+    };
+  }
+};
+
+// src/cli/presenters/ConsoleLogger.ts
+import * as p10 from "@clack/prompts";
+import pc9 from "picocolors";
+var ConsoleLogger = class {
+  constructor(debugEnabled = false) {
+    this.debugEnabled = debugEnabled;
+  }
+  debugEnabled;
+  info(message) {
+    p10.log.info(message);
+  }
+  step(message) {
+    p10.log.step(message);
+  }
+  success(message) {
+    p10.log.success(message);
+  }
+  warn(message) {
+    p10.log.warn(message);
+  }
+  error(message) {
+    p10.log.error(message);
+  }
+  debug(message) {
+    if (this.debugEnabled) p10.log.message(pc9.dim(message));
+  }
+};
+
+// src/cli/container.ts
+function credentialsPath() {
+  const base = process.env.OMNIDEPLOY_CONFIG_DIR ?? (process.platform === "win32" ? join2(process.env.APPDATA ?? join2(homedir(), "AppData", "Roaming"), "omnideploy") : join2(process.env.XDG_CONFIG_HOME ?? join2(homedir(), ".config"), "omnideploy"));
+  return join2(base, "credentials.json");
+}
+function createContainer(opts) {
+  const fs = new NodeFileSystem();
+  const proc = new ExecaProcessRunner();
+  const http = new FetchHttpClient({ userAgent: `omnideploy/${opts.version}` });
+  const git = new CliGit(proc);
+  const store = new FileCredentialStore(credentialsPath());
+  const configRepo = new JsonConfigRepository(fs);
+  const prompt = new ClackPrompt(opts.interactive);
+  const logger = new ConsoleLogger(opts.debug);
+  const providers = new ProviderRegistry(builtInProviders({ http, fs, git, proc }));
+  const credentials = new CredentialResolver(store, prompt);
+  const detect = new DetectProject(builtInDetectors(fs), configRepo);
+  const generate = new GenerateArtifacts(builtInGenerators(), providers, fs, prompt, logger);
+  const build = new BuildProject(proc, fs, logger);
+  const listProviders = new ListProviders(providers, store, proc);
+  return {
+    prompt,
+    logger,
+    providers,
+    detect,
+    generate,
+    listProviders,
+    init: new InitProject(detect, providers, generate, configRepo, prompt, logger),
+    deploy: new DeployProject(detect, providers, generate, build, credentials, configRepo, git, prompt, logger),
+    login: new LoginProvider(providers, store, prompt),
+    logout: new LogoutProvider(providers, store),
+    doctor: new DoctorCheck(detect, listProviders, git),
+    status: new GetDeploymentStatus(providers, credentials, configRepo)
+  };
+}
+
+// src/cli/main.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var program = new Command().name("omnideploy").description("Detect, containerize and deploy any project to Vercel, Netlify, GitHub Pages, Railway, Render \u2014 with one CLI.").version(VERSION).option("-C, --cwd <dir>", "project directory", process.cwd()).option("--debug", "show stack traces and debug output").option("--no-interactive", "never prompt (also implied by CI=true or a non-TTY stdin)").showHelpAfterError();
+var container;
+var globals = () => program.opts();
+var env = {
+  cwd: () => resolve2(globals().cwd),
+  debug: () => Boolean(globals().debug),
+  container: () => container ??= createContainer({
+    debug: Boolean(globals().debug),
+    interactive: globals().interactive && Boolean(process.stdin.isTTY) && !process.env.CI,
+    version: VERSION
+  })
+};
+for (const register of [registerInit, registerDeploy, registerGenerate, registerAuth, registerProviders, registerDoctor, registerStatus]) {
+  register(program, env);
+}
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  process.exitCode = presentError(error, env.debug());
+}
+//# sourceMappingURL=main.js.map