@kaupang/cli 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# @kaupang/cli
+
+[![npm](https://img.shields.io/npm/v/@kaupang/cli.svg)](https://www.npmjs.com/package/@kaupang/cli)
+[![CI](https://github.com/kaupang-dev/kaupang/actions/workflows/ci.yml/badge.svg)](https://github.com/kaupang-dev/kaupang/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/@kaupang/cli.svg)](https://github.com/kaupang-dev/kaupang/blob/main/LICENSE)
+
+> The **`kaupang`** CLI — spin up environments on Docker Compose, Docker Swarm, or
+> Kubernetes from a single config, the same command on your laptop and in CI.
+
+kaupang is an imperative, push-based deploy tool — an *environment maker*, not a
+reconciler. You run it, it makes a target match your config, records exactly what it
+did, and lets you replay or roll back. No control loop, no cluster agent.
+
+## Install
+
+```bash
+npm install -g @kaupang/cli          # installs the `kaupang` command
+# or run without installing:
+npx @kaupang/cli up api --target staging
+```
+
+## Quick start
+
+Create a `kaupang.config.ts` at your repo root and an `environments/` folder:
+
+```ts
+// kaupang.config.ts
+import { defineConfig } from "@kaupang/core";
+
+export default defineConfig({
+  environments: "./environments",
+  project: "shop",
+  dockerRepository: "ghcr.io/acme",
+});
+```
+
+```ts
+// environments/api.ts
+import { defineEnvironment } from "@kaupang/core";
+
+export default defineEnvironment({
+  services: {
+    web: { image: "shop-api", ports: ["8080:3000"] },
+  },
+});
+```
+
+Then:
+
+```bash
+kaupang up api               # resolve images → pin digests → deploy → record
+kaupang up api --dry-run     # show the dependency graph + commands, run nothing
+kaupang down api             # tear it down
+kaupang rollback api         # re-apply the previous good deployment
+```
+
+The authoring helpers (`defineConfig`, `defineEnvironment`, `secret`, `use`, …) come
+from [`@kaupang/core`](https://www.npmjs.com/package/@kaupang/core), which this package
+depends on.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `kaupang up <env \| --solution \| --bundle>` | Deploy to a target |
+| `kaupang down <env>` | Tear down (optionally `--with-deps`) |
+| `kaupang build <env> [--push]` | Build (and push) images |
+| `kaupang bundle <solution> [--push oci://…]` | Pack a portable, pinned bundle |
+| `kaupang rollback <env> [--to <id>]` | Re-apply a recorded deployment |
+| `kaupang run <pipeline>` | Run a pipeline (run / up / down / build / wait steps) |
+
+Add `--dry-run` to preview without touching anything, and `-v` / `--verbose` to print the
+underlying `docker`/`kubectl` commands.
+
+## Docs
+
+Full documentation — config, catalog presets, targets, solutions & bundles, pipelines,
+secrets, backends, Azure DevOps — lives in the
+[project README](https://github.com/kaupang-dev/kaupang#readme).
+
+## License
+
+MIT © Andreas Quist Batista

package/dist/cli.js

@@ -0,0 +1,668 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { defineCommand as defineCommand7, runMain } from "citty";
+
+// src/commands/build.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { backendNames, getBackend } from "@kaupang/core/internal";
+import { loadConfig } from "@kaupang/core/internal";
+import { makeContext } from "@kaupang/core/internal";
+import { resolvePlan } from "@kaupang/core/internal";
+import { run } from "@kaupang/core/internal";
+
+// src/commands/shared.ts
+import { setVerbose } from "@kaupang/core/internal";
+var verboseArg = {
+  verbose: {
+    type: "boolean",
+    alias: "v",
+    description: "Print each underlying command ($ docker \u2026) as it runs."
+  }
+};
+function applyVerbose(args) {
+  setVerbose(Boolean(args.verbose));
+}
+
+// src/commands/build.ts
+var buildCommand = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build images for services that declare a build context."
+  },
+  args: {
+    environment: {
+      type: "positional",
+      description: "Environment whose services to build.",
+      required: true
+    },
+    backend: { type: "string", alias: "b", description: backendNames.join(" | ") },
+    push: { type: "boolean", description: "Push built images to the registry after building." },
+    "dry-run": { type: "boolean", description: "Print build commands without running them." },
+    ...verboseArg,
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    applyVerbose(args);
+    const loaded = await loadConfig(args.cwd);
+    const backendName = args.backend ?? loaded.config.defaultBackend ?? "compose";
+    if (backendName === "kubernetes") {
+      consola.warn(
+        "The kubernetes backend does not build images \u2014 build + push with your CI, then deploy by image."
+      );
+      return;
+    }
+    const plan = resolvePlan(args.environment, loaded.environments, backendName);
+    const ctx = makeContext(loaded);
+    const backend = getBackend(backendName);
+    const env = plan.environments.find((e) => e.name === plan.target);
+    const hasBuild = Object.values(env.services).some((s) => s.build);
+    if (!hasBuild) {
+      consola.info(`No services in "${env.name}" declare a build context \u2014 nothing to build.`);
+      return;
+    }
+    const m = backend.materialize(env, ctx);
+    if (!args["dry-run"]) {
+      for (const f of m.files) {
+        mkdirSync(dirname(f.path), { recursive: true });
+        writeFileSync(f.path, f.content);
+      }
+    }
+    consola.start(`\u2692\uFE0F  forging ${env.name}`);
+    for (const action of m.build) {
+      await run(action.file, action.args, { cwd: ctx.rootDir, dryRun: args["dry-run"] });
+    }
+    if (args.push) {
+      const pushActions = m.push ?? [];
+      if (pushActions.length === 0) {
+        consola.warn(`The ${backendName} backend can't push \u2014 build + push with your CI instead.`);
+      } else {
+        consola.start(`\u26F5 shipping ${env.name}`);
+        for (const action of pushActions) {
+          await run(action.file, action.args, { cwd: ctx.rootDir, dryRun: args["dry-run"] });
+        }
+      }
+    }
+    consola.success(`\u2692\uFE0F  Forged "${env.name}"${args.push ? " and shipped" : ""}.`);
+  }
+});
+
+// src/commands/bundle.ts
+import { basename, join, resolve } from "node:path";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { defineCommand as defineCommand2 } from "citty";
+import { consola as consola2 } from "consola";
+import { getBackend as getBackend2 } from "@kaupang/core/internal";
+import { loadConfig as loadConfig2 } from "@kaupang/core/internal";
+import { makeContext as makeContext2 } from "@kaupang/core/internal";
+import { resolveMultiPlan } from "@kaupang/core/internal";
+import { resolveEnvironmentImages } from "@kaupang/core/internal";
+import { applyPins, resolveSolution } from "@kaupang/core/internal";
+import {
+  pushBundle,
+  rewriteActionPath,
+  writeBundle
+} from "@kaupang/core/internal";
+import { resolveTarget } from "@kaupang/core/internal";
+import { stackName } from "@kaupang/core/internal";
+import { mergeEnv } from "@kaupang/core/internal";
+import { hasBinary, run as run2 } from "@kaupang/core/internal";
+var bundleCommand = defineCommand2({
+  meta: {
+    name: "bundle",
+    description: "Materialize a solution into a portable, pinned bundle."
+  },
+  args: {
+    solution: { type: "positional", description: "Solution name.", required: true },
+    target: { type: "string", description: 'Target the bundle is built for (default "local").' },
+    output: { type: "string", alias: "o", description: "Output directory for the bundle." },
+    "with-images": {
+      type: "boolean",
+      description: "docker save each pinned image into the bundle (for airgapped transfer)."
+    },
+    push: {
+      type: "string",
+      description: "Also push the bundle to an OCI registry, e.g. oci://acmeregistry.azurecr.io/bundles/x:1."
+    },
+    resolve: {
+      type: "boolean",
+      default: true,
+      description: "Resolve images to digests (--no-resolve to keep tags as-is)."
+    },
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    const loaded = await loadConfig2(args.cwd);
+    const sol = await resolveSolution(loaded.config, loaded.catalog, args.solution);
+    const targetName = args.target ?? sol.target ?? "local";
+    const rt = resolveTarget(loaded.config, targetName, loaded.rootDir);
+    const backendName = rt.backend ?? loaded.config.defaultBackend ?? "compose";
+    const plan = resolveMultiPlan(sol.environments, sol.name, loaded.environments, backendName);
+    applyPins(plan, sol.pins);
+    const ctx = makeContext2(loaded, { targetEnv: mergeEnv(rt.env, sol.env) });
+    const backend = getBackend2(backendName);
+    const outDir = resolve(loaded.rootDir, args.output ?? `${sol.name}-bundle`);
+    const tars = [];
+    const environments = [];
+    consola2.info(
+      `\u{1F4E6} Packing cargo "${sol.name}"${sol.version ? `@${sol.version}` : ""} for ${targetName} (${backendName})`
+    );
+    for (const env of plan.environments) {
+      let deployEnv = env;
+      let images = [];
+      if (args.resolve) {
+        const r = await resolveEnvironmentImages(env);
+        deployEnv = r.env;
+        images = r.images;
+      }
+      const m = backend.materialize(deployEnv, ctx);
+      const file = m.files[0];
+      const relPath = join("artifacts", stackName(loaded.project, env.name), basename(file.path));
+      environments.push({
+        name: env.name,
+        backend: backendName,
+        images,
+        artifact: { relPath, content: file.content },
+        up: m.up.map((a) => rewriteActionPath(a, file.path, relPath)),
+        down: m.down.map((a) => rewriteActionPath(a, file.path, relPath))
+      });
+    }
+    if (args["with-images"]) {
+      if (!await hasBinary("docker")) {
+        consola2.warn("docker not found \u2014 skipping image export (bundle has no tars).");
+      } else {
+        mkdirSync2(join(outDir, "images"), { recursive: true });
+        const unique = [...new Set(environments.flatMap((e) => e.images.map((i) => i.pinned)))];
+        for (const ref of unique) {
+          const tar = join("images", `${ref.replace(/[^a-zA-Z0-9]+/g, "_")}.tar`);
+          consola2.start(`\u{1F4E6} stowing image ${ref}`);
+          await run2("docker", ["save", "-o", join(outDir, tar), ref], { cwd: loaded.rootDir });
+          tars.push(tar);
+        }
+      }
+    }
+    const manifest = {
+      kaupang: "0.1.0",
+      solution: sol.name,
+      version: sol.version,
+      target: targetName,
+      project: loaded.project,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      images: { included: tars.length > 0, tars },
+      environments
+    };
+    writeBundle(outDir, manifest);
+    consola2.success(
+      `\u{1F4E6} Cargo packed at ${outDir} (${environments.length} environment(s)${manifest.images.included ? `, ${tars.length} image tar(s)` : ", no images"}).`
+    );
+    if (args.push) {
+      consola2.start(`\u26F5 ferrying cargo \u2192 ${args.push}`);
+      await pushBundle(outDir, args.push);
+      consola2.success(`cargo delivered to ${args.push}`);
+    }
+  }
+});
+
+// src/commands/down.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { defineCommand as defineCommand3 } from "citty";
+import { consola as consola3 } from "consola";
+import { backendNames as backendNames2, getBackend as getBackend3 } from "@kaupang/core/internal";
+import { loadConfig as loadConfig3 } from "@kaupang/core/internal";
+import { makeContext as makeContext3 } from "@kaupang/core/internal";
+import { resolvePlan as resolvePlan2 } from "@kaupang/core/internal";
+import { latestSuccessful } from "@kaupang/core/internal";
+import { applyTarget, resolveTarget as resolveTarget2 } from "@kaupang/core/internal";
+import { run as run3 } from "@kaupang/core/internal";
+import { runHooks } from "@kaupang/core/internal";
+var downCommand = defineCommand3({
+  meta: {
+    name: "down",
+    description: "Tear down an environment (optionally its dependencies too)."
+  },
+  args: {
+    environment: {
+      type: "positional",
+      description: "Environment to tear down.",
+      required: true
+    },
+    backend: {
+      type: "string",
+      alias: "b",
+      description: `Backend: ${backendNames2.join(" | ")}. Defaults to the cached run's backend.`
+    },
+    "with-deps": {
+      type: "boolean",
+      description: "Also tear down dependencies (reverse start order). Off by default."
+    },
+    target: { type: "string", description: 'Deployment target (default "local").' },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the teardown commands without running them."
+    },
+    ...verboseArg,
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    applyVerbose(args);
+    const loaded = await loadConfig3(args.cwd);
+    const target = args.target ?? process.env.KAUPANG_TARGET ?? "local";
+    const rt = resolveTarget2(loaded.config, target, loaded.rootDir);
+    const cached = latestSuccessful(loaded.cacheDir, args.environment, target);
+    const backendName = args.backend ?? cached?.backend ?? rt.backend ?? loaded.config.defaultBackend ?? "compose";
+    const plan = resolvePlan2(args.environment, loaded.environments, backendName);
+    const ctx = makeContext3(loaded, { targetEnv: rt.env });
+    const backend = getBackend3(backendName);
+    const targets = args["with-deps"] ? [...plan.environments].reverse() : plan.environments.filter((e) => e.name === plan.target);
+    consola3.info(
+      `\u{1F525} Striking camp: ${targets.map((e) => e.name).join(", ")} via ${backendName}` + (args["dry-run"] ? " (dry-run)" : "")
+    );
+    for (const env of targets) {
+      const m = backend.materialize(env, ctx);
+      consola3.start(`\u{1F525} striking ${env.name}`);
+      await runHooks(env.hooks?.beforeDown, {
+        rootDir: ctx.rootDir,
+        dryRun: args["dry-run"]
+      });
+      if (!args["dry-run"]) {
+        for (const f of m.files) {
+          mkdirSync3(dirname2(f.path), { recursive: true });
+          writeFileSync2(f.path, f.content);
+        }
+      }
+      for (const action of m.down) {
+        const a = applyTarget(action, rt);
+        await run3(a.file, a.args, {
+          cwd: ctx.rootDir,
+          dryRun: args["dry-run"],
+          input: a.input,
+          env: a.env
+        });
+      }
+      await runHooks(env.hooks?.afterDown, {
+        rootDir: ctx.rootDir,
+        dryRun: args["dry-run"]
+      });
+      consola3.success(env.name);
+    }
+  }
+});
+
+// src/commands/rollback.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { defineCommand as defineCommand4 } from "citty";
+import { consola as consola4 } from "consola";
+import { loadConfig as loadConfig4 } from "@kaupang/core/internal";
+import {
+  appendDeployment,
+  history,
+  newDeploymentId,
+  rollbackTarget
+} from "@kaupang/core/internal";
+import { applyTarget as applyTarget2, resolveTarget as resolveTarget3 } from "@kaupang/core/internal";
+import { run as run4 } from "@kaupang/core/internal";
+var rollbackCommand = defineCommand4({
+  meta: {
+    name: "rollback",
+    description: "Re-apply a previously recorded deployment of an environment."
+  },
+  args: {
+    environment: {
+      type: "positional",
+      description: "Environment to roll back.",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Deployment id to roll back to (see --list). Defaults to the previous one."
+    },
+    target: { type: "string", description: 'Deployment target (default "local").' },
+    list: { type: "boolean", description: "Show deployment history and exit." },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the commands that would replay, without running them."
+    },
+    ...verboseArg,
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    applyVerbose(args);
+    const loaded = await loadConfig4(args.cwd);
+    const target = args.target ?? process.env.KAUPANG_TARGET ?? "local";
+    const rt = resolveTarget3(loaded.config, target, loaded.rootDir);
+    const records = history(loaded.cacheDir, args.environment, target);
+    if (records.length === 0) {
+      consola4.warn(`No deployment history for "${args.environment}@${target}".`);
+      return;
+    }
+    if (args.list) {
+      consola4.log(`
+Deployments for ${args.environment}@${target} (newest first):
+`);
+      for (const d of [...records].reverse()) {
+        const imgs = d.images.map((i) => `${i.service}=${i.digest.slice(0, 19)}\u2026`).join("  ");
+        const tag = d.rollbackOf ? ` (rollback of ${d.rollbackOf})` : "";
+        consola4.log(
+          `  ${d.id}  ${pad(d.status, 9)} ${d.backend}  ${d.ranAt}${tag}
+` + (imgs ? `    ${imgs}
+` : "")
+        );
+      }
+      return;
+    }
+    const restore = rollbackTarget(loaded.cacheDir, args.environment, target, args.to);
+    if (!restore) {
+      consola4.error(
+        args.to ? `No successful deployment with id "${args.to}".` : "No previous successful deployment to roll back to (need at least two)."
+      );
+      return;
+    }
+    consola4.info(
+      `\u21A9\uFE0F  Sailing back "${args.environment}@${target}" to ${restore.id} (${restore.ranAt})`
+    );
+    for (const i of restore.images) {
+      consola4.log(`  ${i.service} \u2190 ${i.digest.slice(0, 19)}\u2026`);
+    }
+    if (!args["dry-run"]) {
+      for (const f of restore.files) {
+        mkdirSync4(dirname3(f.path), { recursive: true });
+        writeFileSync3(f.path, f.content);
+      }
+    }
+    for (const action of restore.up) {
+      const a = applyTarget2(action, rt);
+      await run4(a.file, a.args, {
+        cwd: loaded.rootDir,
+        dryRun: args["dry-run"],
+        input: a.input,
+        env: a.env
+      });
+    }
+    if (!args["dry-run"]) {
+      const record = {
+        ...restore,
+        id: newDeploymentId(),
+        ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "succeeded",
+        rollbackOf: restore.id
+      };
+      appendDeployment(loaded.cacheDir, record);
+    }
+    consola4.success(`\u21A9\uFE0F  Sailed back "${args.environment}" to ${restore.id}.`);
+  }
+});
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
+// src/commands/run.ts
+import { defineCommand as defineCommand5 } from "citty";
+import { loadConfig as loadConfig5 } from "@kaupang/core/internal";
+import { runPipeline } from "@kaupang/core/internal";
+var runCommand = defineCommand5({
+  meta: {
+    name: "run",
+    description: "Run a named pipeline (ordered run / up / down / build / wait steps)."
+  },
+  args: {
+    pipeline: { type: "positional", description: "Pipeline name.", required: true },
+    target: { type: "string", description: 'Default target for up/down/build steps (default "local").' },
+    "dry-run": { type: "boolean", description: "Print the step graph without running anything." },
+    ...verboseArg,
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    applyVerbose(args);
+    const loaded = await loadConfig5(args.cwd);
+    await runPipeline(loaded, args.pipeline, {
+      target: args.target,
+      dryRun: Boolean(args["dry-run"])
+    });
+  }
+});
+
+// src/commands/up.ts
+import { join as join2, resolve as resolvePath } from "node:path";
+import { defineCommand as defineCommand6 } from "citty";
+import { consola as consola5 } from "consola";
+import { backendNames as backendNames3 } from "@kaupang/core/internal";
+import { loadConfig as loadConfig6 } from "@kaupang/core/internal";
+import { makeContext as makeContext4 } from "@kaupang/core/internal";
+import { resolveMultiPlan as resolveMultiPlan2, resolvePlan as resolvePlan3 } from "@kaupang/core/internal";
+import { appendDeployment as appendDeployment2, newDeploymentId as newDeploymentId2 } from "@kaupang/core/internal";
+import { renderPlan } from "@kaupang/core/internal";
+import { deployPlan } from "@kaupang/core/internal";
+import { applyPins as applyPins2, resolveSolution as resolveSolution2 } from "@kaupang/core/internal";
+import { isOciRef, pullBundle, readBundle } from "@kaupang/core/internal";
+import { applyTarget as applyTarget3, resolveTarget as resolveTarget4 } from "@kaupang/core/internal";
+import { mergeEnv as mergeEnv2 } from "@kaupang/core/internal";
+import { run as run5 } from "@kaupang/core/internal";
+var PULL_POLICIES = ["always", "missing", "never"];
+var upCommand = defineCommand6({
+  meta: {
+    name: "up",
+    description: "Deploy an environment, a solution, or a pre-built bundle to a target."
+  },
+  args: {
+    environment: { type: "positional", description: "Environment to bring up.", required: false },
+    solution: { type: "string", description: "Deploy a solution (composed environments) instead." },
+    bundle: { type: "string", description: "Deploy a pre-built bundle directory (offline)." },
+    target: { type: "string", description: 'Deployment target (default "local").' },
+    backend: { type: "string", alias: "b", description: `Backend: ${backendNames3.join(" | ")}.` },
+    pull: { type: "string", description: `Force pull policy: ${PULL_POLICIES.join(" | ")}.` },
+    resolve: {
+      type: "boolean",
+      default: true,
+      description: "Resolve image references to digests (pass --no-resolve to skip)."
+    },
+    "dry-run": { type: "boolean", description: "Print the plan and commands without running anything." },
+    output: { type: "string", description: 'Output format: "text" (default) or "json".' },
+    ...verboseArg,
+    cwd: { type: "string", description: "Directory to resolve the config from." }
+  },
+  async run({ args }) {
+    applyVerbose(args);
+    const json = parseOutput(args.output);
+    if (json) consola5.level = -999;
+    const loaded = await loadConfig6(args.cwd);
+    if (args.bundle) {
+      await deployBundle(loaded, args.bundle, {
+        target: args.target,
+        dryRun: Boolean(args["dry-run"]),
+        json
+      });
+      return;
+    }
+    const targetName = args.target ?? process.env.KAUPANG_TARGET ?? "local";
+    const rt = resolveTarget4(loaded.config, targetName, loaded.rootDir);
+    let plan;
+    let targetEnv = rt.env;
+    if (args.solution) {
+      const sol = await resolveSolution2(loaded.config, loaded.catalog, args.solution);
+      const backendName2 = resolveBackend(args.backend, rt.backend, loaded.config.defaultBackend);
+      plan = resolveMultiPlan2(sol.environments, sol.name, loaded.environments, backendName2);
+      applyPins2(plan, sol.pins);
+      targetEnv = mergeEnv2(rt.env, sol.env);
+    } else if (args.environment) {
+      const backendName2 = resolveBackend(args.backend, rt.backend, loaded.config.defaultBackend);
+      plan = resolvePlan3(args.environment, loaded.environments, backendName2);
+    } else {
+      throw new Error("Specify an environment, --solution <name>, or --bundle <dir>.");
+    }
+    const backendName = plan.backend;
+    const pull = resolvePull(args.pull) ?? rt.pull ?? loaded.config.defaultPull;
+    const ctx = makeContext4(loaded, { pull, targetEnv });
+    if (args["dry-run"]) {
+      if (json) {
+        emitJson({
+          dryRun: true,
+          project: loaded.project,
+          target: targetName,
+          backend: backendName,
+          willResolve: Boolean(args.resolve),
+          environments: plan.environments.map((e) => ({
+            name: e.name,
+            services: Object.entries(e.services).map(([service, s]) => ({
+              service,
+              image: s.image ?? null
+            }))
+          }))
+        });
+        return;
+      }
+      renderPlan(plan, ctx, rt);
+      if (args.resolve) {
+        consola5.info("Images will be resolved to digests at deploy time (--no-resolve to skip).");
+      }
+      return;
+    }
+    const records = await deployPlan(loaded, plan, rt, {
+      targetName,
+      targetEnv,
+      pull,
+      resolve: Boolean(args.resolve)
+    });
+    if (json) {
+      emitJson({
+        project: loaded.project,
+        target: targetName,
+        backend: backendName,
+        deployments: records.map((r) => ({
+          environment: r.environment,
+          deploymentId: r.id,
+          ranAt: r.ranAt,
+          images: r.images.map((i) => ({
+            service: i.service,
+            ref: i.ref,
+            digest: i.digest ?? null,
+            pinned: i.pinned
+          }))
+        }))
+      });
+      return;
+    }
+  }
+});
+function parseOutput(value) {
+  if (value === void 0 || value === "text") return false;
+  if (value === "json") return true;
+  throw new Error(`Unknown --output "${value}" (use "text" or "json").`);
+}
+function emitJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function deployBundle(loaded, bundleArg, opts) {
+  let dir;
+  if (isOciRef(bundleArg)) {
+    consola5.start(`\u26F5 ferrying cargo \u2190 ${bundleArg}`);
+    dir = await pullBundle(bundleArg, join2(loaded.cacheDir, "pulled"));
+    consola5.success(`cargo ashore at ${dir}`);
+  } else {
+    dir = resolvePath(loaded.rootDir, bundleArg);
+  }
+  const manifest = readBundle(dir);
+  const targetName = opts.target ?? manifest.target ?? "local";
+  const rt = resolveTarget4(loaded.config, targetName, loaded.rootDir);
+  consola5.info(
+    `\u{1F4E6} Unpacking cargo "${manifest.solution}"${manifest.version ? `@${manifest.version}` : ""} \u2192 ${targetName} (${manifest.environments.map((e) => e.name).join(" \u2192 ")})`
+  );
+  if (manifest.images.included && manifest.images.tars.length) {
+    for (const tar of manifest.images.tars) {
+      await run5("docker", ["load", "-i", join2(dir, tar)], { cwd: dir, dryRun: opts.dryRun });
+    }
+  }
+  const deployed = [];
+  for (const env of manifest.environments) {
+    consola5.start(`\u{1FA93} raising ${env.name}`);
+    const absArtifact = join2(dir, env.artifact.relPath);
+    for (const action of env.up) {
+      const abs = {
+        ...action,
+        args: action.args.map(
+          (x, i, arr) => x === env.artifact.relPath ? absArtifact : arr[i - 1] === "--project-directory" ? dir : x
+        )
+      };
+      const a = applyTarget3(abs, rt);
+      await run5(a.file, a.args, { cwd: dir, dryRun: opts.dryRun, input: a.input, env: a.env });
+    }
+    if (!opts.dryRun) {
+      const id = newDeploymentId2();
+      const ranAt = (/* @__PURE__ */ new Date()).toISOString();
+      appendDeployment2(loaded.cacheDir, {
+        id,
+        environment: env.name,
+        target: targetName,
+        backend: env.backend,
+        project: manifest.project,
+        ranAt,
+        status: "succeeded",
+        images: env.images,
+        files: [{ path: absArtifact, content: env.artifact.content }],
+        up: env.up,
+        down: env.down
+      });
+      deployed.push({ environment: env.name, deploymentId: id, ranAt, images: env.images });
+    }
+    consola5.success(env.name);
+  }
+  if (opts.json) {
+    emitJson({
+      project: manifest.project,
+      solution: manifest.solution,
+      version: manifest.version ?? null,
+      target: targetName,
+      bundle: dir,
+      deployments: deployed.map((d) => ({
+        environment: d.environment,
+        deploymentId: d.deploymentId,
+        ranAt: d.ranAt,
+        images: d.images.map((i) => ({
+          service: i.service,
+          ref: i.ref,
+          digest: i.digest ?? null,
+          pinned: i.pinned
+        }))
+      }))
+    });
+    return;
+  }
+  consola5.success(`\u{1F6D6} Cargo "${manifest.solution}" landed on ${targetName}.`);
+}
+function resolveBackend(flag, fromTarget, fallback) {
+  const name = flag ?? fromTarget ?? fallback ?? "compose";
+  if (!backendNames3.includes(name)) {
+    throw new Error(`Unknown backend "${name}". Use one of: ${backendNames3.join(", ")}.`);
+  }
+  return name;
+}
+function resolvePull(flag) {
+  if (!flag) return void 0;
+  if (!PULL_POLICIES.includes(flag)) {
+    throw new Error(`Unknown pull policy "${flag}". Use one of: ${PULL_POLICIES.join(", ")}.`);
+  }
+  return flag;
+}
+
+// src/cli.ts
+var main = defineCommand7({
+  meta: {
+    name: "kaupang",
+    version: "0.1.0",
+    description: "The trading hub for your deploys \u2014 gather your services, pin them into portable cargo, and ship them to any target (Compose, Swarm, or Kubernetes) from one config."
+  },
+  subCommands: {
+    up: upCommand,
+    down: downCommand,
+    build: buildCommand,
+    bundle: bundleCommand,
+    rollback: rollbackCommand,
+    run: runCommand
+  }
+});
+runMain(main);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@kaupang/cli",
+  "version": "0.1.0",
+  "description": "The kaupang CLI — the `kaupang` binary. Deploy the same definitions to Docker Compose, Swarm, or Kubernetes from one config.",
+  "license": "MIT",
+  "author": "Andreas Quist Batista",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaupang-dev/kaupang.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/kaupang-dev/kaupang/issues"
+  },
+  "homepage": "https://github.com/kaupang-dev/kaupang#readme",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "kaupang": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@kaupang/core": "^0.1.0",
+    "citty": "0.1.6",
+    "consola": "3.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}