@getmonoceros/workbench 1.13.2 → 1.14.0

package/dist/bin.js

@@ -129,19 +129,19 @@ function wrapText(text, width, continuationIndent) {
   if (current.length > 0) lines.push(current.replace(/\s+$/, ""));
   return lines.map((l, i) => i === 0 ? l : continuationIndent + l).join("\n");
 }
-function alignTable(rows, indent) {
+function alignTable(rows, indent, opts = {}) {
   if (rows.length === 0) return "";
-  const labelWidth = Math.max(...rows.map((r) => visibleLen(r[0])));
+  const labelWidth = opts.fixedLabelWidth ?? Math.max(...rows.map((r) => visibleLen(r[0])));
   const gutter = "    ";
   const descWidth = terminalWidth() - indent.length - labelWidth - gutter.length;
   const continuationIndent = " ".repeat(
     indent.length + labelWidth + gutter.length
   );
   return rows.map(([left, right]) => {
-    const pad = " ".repeat(labelWidth - visibleLen(left));
+    const pad = " ".repeat(Math.max(0, labelWidth - visibleLen(left)));
     const wrapped = wrapText(right, descWidth, continuationIndent);
     return `${indent}${left}${pad}${gutter}${wrapped}`;
-  }).join("\n");
+  }).join(opts.rowGap ? "\n\n" : "\n");
 }
 function collectSubCommands(cmd) {
   const subs = cmd.subCommands ?? {};
@@ -167,6 +167,7 @@ function renderCommandsBlock(entries) {
     arr.push(entry2);
     byGroup.set(entry2.group, arr);
   }
+  const labelWidth = Math.max(...entries.map((e) => visibleLen(cyan(e.name))));
   const renderSection = (label, items) => {
     if (items.length === 0) return;
     lines.push("");
@@ -176,7 +177,9 @@ function renderCommandsBlock(entries) {
       cyan(e.name),
       e.description
     ]);
-    lines.push(alignTable(rows, ""));
+    lines.push(
+      alignTable(rows, "", { fixedLabelWidth: labelWidth, rowGap: true })
+    );
   };
   for (const { key, label } of GROUPS) {
     renderSection(label, byGroup.get(key) ?? []);
@@ -619,6 +622,9 @@ function containersDir(home = monocerosHome()) {
 function containerDir(name, home = monocerosHome()) {
   return path.join(containersDir(home), name);
 }
+function containerLogsDir(name, home = monocerosHome()) {
+  return path.join(containerDir(name, home), "logs");
+}
 function monocerosConfigPath(home = monocerosHome()) {
   return path.join(home, "monoceros-config.yml");
 }
@@ -982,6 +988,10 @@ var ANSI_UNDERLINE2 = `${ESC}4m`;
 var ANSI_CYAN2 = `${ESC}36m`;
 var ANSI_GREY2 = `${ESC}90m`;
 var ANSI_RESET2 = `${ESC}0m`;
+var ANSI_RE2 = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE2, "");
+}
 function makeWrap(isTty2) {
   return (s, ...codes) => isTty2 ? codes.join("") + s + ANSI_RESET2 : s;
 }
@@ -4137,7 +4147,7 @@ var addServiceCommand = defineCommand7({
 import { defineCommand as defineCommand8 } from "citty";
 
 // src/apply/index.ts
-import { existsSync as existsSync8, promises as fs12 } from "fs";
+import { existsSync as existsSync7, promises as fs11 } from "fs";
 import { consola as consola11 } from "consola";
 
 // src/config/state.ts
@@ -4237,10 +4247,292 @@ function solutionConfigToCreateOptions(config, featureDefaults = {}) {
   return result;
 }
 
+// src/apply/apply-log.ts
+import { createWriteStream, mkdirSync } from "fs";
+import path11 from "path";
+import { Writable } from "stream";
+function safeIsoStamp(d) {
+  return d.toISOString().replace(/[:.]/g, "-");
+}
+function createApplyLog(opts) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const dir = containerLogsDir(opts.name, opts.home);
+  mkdirSync(dir, { recursive: true });
+  const file = `apply-${opts.name}-${safeIsoStamp(now)}.log`;
+  const fullPath = path11.join(dir, file);
+  const stream = createWriteStream(fullPath, { flags: "w" });
+  const header = [
+    `# monoceros apply log`,
+    `# command:     monoceros apply ${opts.name}`,
+    `# started:     ${now.toISOString()}`,
+    `# cli-version: ${opts.cliVersion}`,
+    `# config:      ${opts.configPath}`,
+    `# host:        ${process.platform}/${process.arch} node ${process.version}`,
+    ``,
+    ``
+  ].join("\n");
+  stream.write(header);
+  const sink = new Writable({
+    write(chunk, _enc, cb) {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stream.write(stripAnsi(text), cb);
+    }
+  });
+  let closed = false;
+  return {
+    path: fullPath,
+    stream,
+    sink,
+    close: () => new Promise((resolve) => {
+      if (closed) {
+        resolve();
+        return;
+      }
+      closed = true;
+      sink.end(() => {
+        stream.end(() => resolve());
+      });
+    })
+  };
+}
+function teeApplyLogger(base, sink) {
+  const write = (level, msg) => {
+    sink.write(`[${level}] ${msg}
+`);
+  };
+  const wrapped = {
+    info: (msg) => {
+      base.info(msg);
+      write("info", msg);
+    },
+    success: (msg) => {
+      base.success(msg);
+      write("ok", msg);
+    },
+    warn: (msg) => {
+      (base.warn ?? base.info)(msg);
+      write("warn", msg);
+    }
+  };
+  if (base.section) wrapped.section = base.section.bind(base);
+  return wrapped;
+}
+
+// src/apply/apply-progress.ts
+import { Writable as Writable2 } from "stream";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_INTERVAL_MS = 80;
+var TAIL_LINES = 15;
+var PHASE_TRIGGERS = [
+  // Compose mode triggers a feature/layer build before the container
+  // is created — distinct phase, often the longest single step.
+  { pattern: /Start: Run: docker build/i, label: "building feature layers\u2026" },
+  // Image mode jumps straight from "preparing…" into the docker run
+  // that pulls (if needed) + creates + starts the container.
+  { pattern: /Start: Run: docker run/i, label: "starting container\u2026" },
+  { pattern: /Running the postCreateCommand/i, label: "running postCreate\u2026" }
+];
+function createApplyProgress(opts) {
+  const out = opts.out;
+  const now = opts.now ?? (() => Date.now());
+  const startedAt = now();
+  let phase = "preparing\u2026";
+  let frameIdx = 0;
+  let timer = null;
+  let stopped = false;
+  const tail = [];
+  let lineBuf = "";
+  const writeSpinner = () => {
+    if (!opts.interactive || stopped) return;
+    out.write(`\r\x1B[K${FRAMES[frameIdx]} ${phase}`);
+  };
+  const clearLine = () => {
+    if (!opts.interactive) return;
+    out.write("\r\x1B[K");
+  };
+  const setPhase = (label) => {
+    if (phase === label) return;
+    phase = label;
+    if (opts.interactive) {
+      writeSpinner();
+    } else {
+      out.write(`> ${label}
+`);
+    }
+  };
+  const println = (line) => {
+    clearLine();
+    const withNewline = line.endsWith("\n") ? line : `${line}
+`;
+    out.write(withNewline);
+    writeSpinner();
+  };
+  const fmtElapsed = () => {
+    const ms = now() - startedAt;
+    const totalSec = Math.max(0, Math.round(ms / 1e3));
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return m > 0 ? `${m}m ${s}s` : `${s}s`;
+  };
+  const stop = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    if (!stopped) {
+      stopped = true;
+      clearLine();
+    }
+  };
+  const succeed = (label) => {
+    stop();
+    const text = label ?? `container ready (${fmtElapsed()})`;
+    out.write(`\u2714 ${text}
+`);
+  };
+  const fail = () => {
+    stop();
+    return { tailLines: [...tail] };
+  };
+  const streamSink = new Writable2({
+    write(chunk, _enc, cb) {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      lineBuf += stripAnsi(text);
+      let nl;
+      while ((nl = lineBuf.indexOf("\n")) !== -1) {
+        const line = lineBuf.slice(0, nl);
+        lineBuf = lineBuf.slice(nl + 1);
+        if (line.length === 0) continue;
+        tail.push(line);
+        if (tail.length > TAIL_LINES) tail.shift();
+        for (const trig of PHASE_TRIGGERS) {
+          if (trig.pattern.test(line)) {
+            setPhase(trig.label);
+            break;
+          }
+        }
+      }
+      cb();
+    }
+  });
+  if (opts.interactive) {
+    writeSpinner();
+    timer = setInterval(() => {
+      frameIdx = (frameIdx + 1) % FRAMES.length;
+      writeSpinner();
+    }, FRAME_INTERVAL_MS);
+    timer.unref?.();
+  }
+  return {
+    setPhase,
+    println,
+    succeed,
+    fail,
+    streamSink
+  };
+}
+function progressTeeLogger(progress, sink) {
+  const fileLine = (level, msg) => {
+    sink.write(`[${level}] ${msg}
+`);
+  };
+  return {
+    info: (msg) => {
+      progress.println(msg);
+      fileLine("info", msg);
+    },
+    success: (msg) => {
+      progress.println(`\u2714 ${msg}`);
+      fileLine("ok", msg);
+    },
+    warn: (msg) => {
+      progress.println(`! ${msg}`);
+      fileLine("warn", msg);
+    }
+  };
+}
+function logFileOnlyLogger(sink) {
+  const fileLine = (level, msg) => {
+    sink.write(`[${level}] ${msg}
+`);
+  };
+  return {
+    info: (msg) => fileLine("info", msg),
+    success: (msg) => fileLine("ok", msg),
+    warn: (msg) => fileLine("warn", msg)
+  };
+}
+function createSigintAbort(deps) {
+  let aborted = false;
+  return () => {
+    if (aborted) return;
+    aborted = true;
+    if (deps.progress) deps.progress.fail();
+    deps.out.write("\n\u23F9 aborted\n");
+    deps.log.stream.write("\n[abort] SIGINT received\n");
+    void deps.log.close().finally(() => {
+      deps.out.write(`
+  ${deps.formatLogPointer(deps.log.path)}
+`);
+      deps.onExit();
+    });
+  };
+}
+
+// src/apply/apply-summary.ts
+function shortFeatureName(ref) {
+  const withoutTag = ref.replace(/:[^:/@]+$/, "");
+  const idx = withoutTag.lastIndexOf("/");
+  return idx >= 0 ? withoutTag.slice(idx + 1) : withoutTag;
+}
+function shortRepoName(repo) {
+  const last = repo.path.split("/").filter(Boolean).pop();
+  return last && last.length > 0 ? last : repo.url;
+}
+function buildApplySummary(opts) {
+  const lines = [];
+  if (opts.languages.length > 0) {
+    lines.push({ label: "Languages", values: opts.languages });
+  }
+  if (opts.services.length > 0) {
+    lines.push({
+      label: "Services",
+      values: opts.services.map((s) => s.name)
+    });
+  }
+  if (opts.features && Object.keys(opts.features).length > 0) {
+    lines.push({
+      label: "Features",
+      values: Object.keys(opts.features).map(shortFeatureName)
+    });
+  }
+  if (opts.repos && opts.repos.length > 0) {
+    lines.push({
+      label: "Repositories",
+      values: opts.repos.map(shortRepoName)
+    });
+  }
+  if (opts.ports && opts.ports.length > 0) {
+    lines.push({ label: "Ports", values: opts.ports.map(String) });
+  }
+  if (opts.aptPackages && opts.aptPackages.length > 0) {
+    lines.push({ label: "APT packages", values: opts.aptPackages });
+  }
+  if (opts.installUrls && opts.installUrls.length > 0) {
+    lines.push({ label: "Install URLs", values: opts.installUrls });
+  }
+  return lines;
+}
+function formatApplySummary(lines) {
+  if (lines.length === 0) return "";
+  const labelWidth = Math.max(...lines.map((l) => l.label.length));
+  return lines.map((l) => `  ${l.label.padEnd(labelWidth)}  ${cyan2(l.values.join(", "))}`).join("\n");
+}
+
 // src/devcontainer/compose.ts
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
-import path12 from "path";
+import path13 from "path";
 import { consola as consola9 } from "consola";
 
 // src/util/mask-secrets.ts
@@ -4303,7 +4595,7 @@ function createSecretMaskStream() {
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync4 } from "fs";
 import { createRequire } from "module";
-import path11 from "path";
+import path12 from "path";
 
 // src/devcontainer/runtime-pull-hint.ts
 import { Transform as Transform2 } from "stream";
@@ -4354,7 +4646,7 @@ function devcontainerCliPath() {
   if (!binEntry) {
     throw new Error("Could not resolve @devcontainers/cli bin entry.");
   }
-  cachedBinaryPath = path11.resolve(path11.dirname(pkgJsonPath), binEntry);
+  cachedBinaryPath = path12.resolve(path12.dirname(pkgJsonPath), binEntry);
   return cachedBinaryPath;
 }
 var spawnDevcontainer = (args, cwd, options = {}) => {
@@ -4394,8 +4686,20 @@ var spawnDevcontainer = (args, cwd, options = {}) => {
       return;
     }
     const pullHint = { hinted: false };
-    child.stdout?.pipe(createSecretMaskStream()).pipe(createRuntimePullHintStream(pullHint)).pipe(process.stdout);
-    child.stderr?.pipe(createSecretMaskStream()).pipe(createRuntimePullHintStream(pullHint)).pipe(process.stderr);
+    const stdoutPipe = child.stdout?.pipe(createSecretMaskStream()).pipe(createRuntimePullHintStream(pullHint));
+    const stderrPipe = child.stderr?.pipe(createSecretMaskStream()).pipe(createRuntimePullHintStream(pullHint));
+    if (!options.silent) {
+      stdoutPipe?.pipe(process.stdout);
+      stderrPipe?.pipe(process.stderr);
+    }
+    if (options.logSink) {
+      stdoutPipe?.pipe(options.logSink, { end: false });
+      stderrPipe?.pipe(options.logSink, { end: false });
+    }
+    if (options.progressSink) {
+      stdoutPipe?.pipe(options.progressSink, { end: false });
+      stderrPipe?.pipe(options.progressSink, { end: false });
+    }
     child.on("error", reject);
     child.on("exit", (code) => resolve(code ?? 0));
   });
@@ -4472,15 +4776,15 @@ async function cleanupDockerObjects(opts) {
   return { exitCode: rmExit, removedIds: ids };
 }
 function composeProjectName(root) {
-  return `${path12.basename(root)}_devcontainer`;
+  return `${path13.basename(root)}_devcontainer`;
 }
 function resolveCompose(root) {
-  if (!existsSync6(path12.join(root, ".devcontainer"))) {
+  if (!existsSync6(path13.join(root, ".devcontainer"))) {
     throw new Error(
       `No .devcontainer/ at ${root}. Run \`monoceros apply <name>\` first.`
     );
   }
-  const composeFile = path12.join(root, ".devcontainer", "compose.yaml");
+  const composeFile = path13.join(root, ".devcontainer", "compose.yaml");
   if (!existsSync6(composeFile)) {
     throw new Error(
       `No compose.yaml at ${composeFile}. \`start\` / \`stop\` / \`status\` / \`logs\` require services configured via \`monoceros add-service <name> <svc>\`. Use \`monoceros shell <name>\` to enter the container directly.`
@@ -4501,9 +4805,17 @@ async function runStart(opts) {
   logger.info(`Bringing devcontainer up at ${opts.root}\u2026`);
   return spawnFn(
     ["up", "--workspace-folder", opts.root, "--mount-workspace-git-root=false"],
-    opts.root
+    opts.root,
+    buildSpawnOptions(opts)
   );
 }
+function buildSpawnOptions(opts) {
+  const out = {};
+  if (opts.logSink) out.logSink = opts.logSink;
+  if (opts.progressSink) out.progressSink = opts.progressSink;
+  if (opts.silent) out.silent = true;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 async function runContainerCycle(root, opts) {
   const { hasCompose, logger } = opts;
   if (hasCompose) {
@@ -4539,6 +4851,9 @@ and retry \`monoceros apply\`.`
     return runStart({
       root,
       ...opts.devcontainerSpawn ? { spawn: opts.devcontainerSpawn } : {},
+      ...opts.logSink ? { logSink: opts.logSink } : {},
+      ...opts.progressSink ? { progressSink: opts.progressSink } : {},
+      ...opts.silent ? { silent: true } : {},
       logger
     });
   }
@@ -4552,7 +4867,8 @@ and retry \`monoceros apply\`.`
       "--mount-workspace-git-root=false",
       "--remove-existing-container"
     ],
-    root
+    root,
+    buildSpawnOptions(opts)
   );
 }
 function runStop(opts) {
@@ -4579,230 +4895,11 @@ function runLogs(opts) {
   );
 }
 
-// src/devcontainer/repo-reachability.ts
-import { spawn as spawn6 } from "child_process";
-var realGitLsRemote = (url) => {
-  return new Promise((resolve, reject) => {
-    const child = spawn6("git", ["ls-remote", "--heads", "--", url], {
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        GIT_TERMINAL_PROMPT: "0"
-      }
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on(
-      "exit",
-      (code) => resolve({ stdout, stderr, exitCode: code ?? 0 })
-    );
-  });
-};
-function classifyStderr(stderr) {
-  const s = stderr.toLowerCase();
-  if (s.includes("could not resolve host") || s.includes("name or service not known") || s.includes("temporary failure in name resolution") || s.includes("no address associated with hostname")) {
-    return "dns";
-  }
-  if (s.includes("repository not found") || s.includes("may not have access") || s.includes("no longer exists") || s.includes("don't have permission") || s.includes("could not be found") || s.includes("the requested url returned error: 404")) {
-    return "not-found-or-no-access";
-  }
-  if (s.includes("authentication failed") || s.includes("could not read username") || s.includes("incorrect username or password") || s.includes("the requested url returned error: 401") || s.includes("the requested url returned error: 403")) {
-    return "auth-failed";
-  }
-  return "unknown";
-}
-async function checkRepoReachability(repos, options = {}) {
-  const spawnFn = options.spawn ?? realGitLsRemote;
-  const results = [];
-  for (const repo of repos) {
-    let result;
-    try {
-      result = await spawnFn(repo.url);
-    } catch (err) {
-      results.push({
-        url: repo.url,
-        ok: false,
-        kind: "unknown",
-        detail: err instanceof Error ? err.message : String(err)
-      });
-      continue;
-    }
-    if (result.exitCode === 0) {
-      results.push({ url: repo.url, ok: true, detail: "" });
-      continue;
-    }
-    results.push({
-      url: repo.url,
-      ok: false,
-      kind: classifyStderr(result.stderr),
-      detail: result.stderr.trim()
-    });
-  }
-  return results;
-}
-function formatUnreachableReposError(failures) {
-  const byKind = /* @__PURE__ */ new Map();
-  for (const f of failures) {
-    const kind = f.kind ?? "unknown";
-    const list = byKind.get(kind) ?? [];
-    list.push(f);
-    byKind.set(kind, list);
-  }
-  const totalUrls = failures.length;
-  const lines = [
-    totalUrls === 1 ? `Cannot reach declared repo: ${failures[0].url}` : `Cannot reach ${totalUrls} declared repos:`,
-    ""
-  ];
-  const sectionOrder = [
-    "not-found-or-no-access",
-    "auth-failed",
-    "dns",
-    "unknown"
-  ];
-  for (const kind of sectionOrder) {
-    const entries = byKind.get(kind);
-    if (!entries || entries.length === 0) continue;
-    lines.push(headerForKind(kind));
-    for (const e of entries) {
-      lines.push(`  \u2022 ${e.url}`);
-      if (e.detail) {
-        for (const detailLine of e.detail.split("\n")) {
-          const trimmed = detailLine.trim();
-          if (trimmed) lines.push(`      git: ${trimmed}`);
-        }
-      }
-    }
-    for (const advice of adviceForKind(kind)) {
-      lines.push(`    - ${advice}`);
-    }
-    lines.push("");
-  }
-  lines.push(`Then re-run ${cyan2("monoceros apply")}.`);
-  return lines.join("\n");
-}
-function headerForKind(kind) {
-  switch (kind) {
-    case "not-found-or-no-access":
-      return "Repository not found (or your credentials don't grant access):";
-    case "auth-failed":
-      return "Authentication failed (credentials are present but rejected):";
-    case "dns":
-      return "Host unreachable (DNS / VPN / offline \u2014 git couldn't resolve the hostname):";
-    case "unknown":
-      return "Unrecognised git error:";
-  }
-}
-function adviceForKind(kind) {
-  switch (kind) {
-    case "not-found-or-no-access":
-      return [
-        "Re-check the URL for typos (case-sensitive on most hosts).",
-        "Verify the repo still exists / is not archived in a way that hides it.",
-        "Ensure your token covers this org / workspace and has read scope (GitHub: `repo`; GitLab: `read_repository`; Bitbucket: repo read)."
-      ];
-    case "auth-failed":
-      return [
-        "Token may be expired or revoked \u2014 regenerate it from the provider UI.",
-        "Re-run the provider CLI login (gh auth login / glab auth login) \u2014 Monoceros picks up the refreshed token on the next apply."
-      ];
-    case "dns":
-      return [
-        "Check your internet / VPN \u2014 corporate Git hosts often require VPN.",
-        "Verify the hostname spelling in the yml."
-      ];
-    case "unknown":
-      return [
-        "Run `git ls-remote <url>` manually on the host to see the raw error."
-      ];
-  }
-}
-
-// src/devcontainer/repo-clone.ts
-import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync7, promises as fs10 } from "fs";
-import path13 from "path";
-var realGitClone = (url, dest) => {
-  return new Promise((resolve, reject) => {
-    const child = spawn7("git", ["clone", "--", url, dest], {
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (c) => {
-      stdout += c.toString();
-    });
-    child.stderr.on("data", (c) => {
-      stderr += c.toString();
-    });
-    child.on("error", reject);
-    child.on(
-      "exit",
-      (code) => resolve({ stdout, stderr, exitCode: code ?? 0 })
-    );
-  });
-};
-async function cloneReposHostSide(containerRoot, repos, options = {}) {
-  const spawnFn = options.spawn ?? realGitClone;
-  const results = [];
-  for (const repo of repos) {
-    const dest = path13.join(containerRoot, "projects", repo.path);
-    if (existsSync7(dest)) {
-      results.push({ path: repo.path, url: repo.url, status: "skipped" });
-      continue;
-    }
-    await fs10.mkdir(path13.dirname(dest), { recursive: true });
-    let r;
-    try {
-      r = await spawnFn(repo.url, dest);
-    } catch (err) {
-      results.push({
-        path: repo.path,
-        url: repo.url,
-        status: "failed",
-        detail: err instanceof Error ? err.message : String(err)
-      });
-      continue;
-    }
-    results.push(
-      r.exitCode === 0 ? { path: repo.path, url: repo.url, status: "cloned" } : {
-        path: repo.path,
-        url: repo.url,
-        status: "failed",
-        detail: r.stderr.trim()
-      }
-    );
-  }
-  return results;
-}
-function formatCloneFailuresError(failures) {
-  const lines = failures.length === 1 ? [`Failed to clone declared repo: ${failures[0].url}`, ""] : [`Failed to clone ${failures.length} declared repos:`, ""];
-  for (const f of failures) {
-    lines.push(`  \u2022 ${f.url} \u2192 projects/${f.path}`);
-    if (f.detail) lines.push(`    ${f.detail}`);
-  }
-  lines.push("");
-  lines.push(
-    "Reachability was confirmed earlier, so this is usually a local issue"
-  );
-  lines.push(
-    "(disk space, a leftover non-empty target dir). Fix it and re-run " + cyan2("monoceros apply") + "."
-  );
-  return lines.join("\n");
-}
-
 // src/devcontainer/docker-mode.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 var realDockerInfo = () => {
   return new Promise((resolve, reject) => {
-    const child = spawn8(
+    const child = spawn6(
       "docker",
       ["info", "--format", "{{json .SecurityOptions}}"],
       {
@@ -4861,13 +4958,13 @@ function formatRootlessNotSupportedError() {
 }
 
 // src/devcontainer/identity.ts
-import { spawn as spawn9 } from "child_process";
-import { promises as fs11 } from "fs";
+import { spawn as spawn7 } from "child_process";
+import { promises as fs10 } from "fs";
 import path14 from "path";
 import { consola as consola10 } from "consola";
 var realGitConfigGet = (key) => {
   return new Promise((resolve, reject) => {
-    const child = spawn9("git", ["config", "--global", "--get", key], {
+    const child = spawn7("git", ["config", "--global", "--get", key], {
       stdio: ["ignore", "pipe", "inherit"]
     });
     let stdout = "";
@@ -4991,8 +5088,8 @@ async function collectGitIdentity(devContainerRoot, options = {}) {
   const lines = ["[user]"];
   if (resolved.name !== void 0) lines.push(`	name = ${resolved.name}`);
   if (resolved.email !== void 0) lines.push(`	email = ${resolved.email}`);
-  await fs11.mkdir(gitconfigDir, { recursive: true });
-  await fs11.writeFile(gitconfigPath, lines.join("\n") + "\n");
+  await fs10.mkdir(gitconfigDir, { recursive: true });
+  await fs10.writeFile(gitconfigPath, lines.join("\n") + "\n");
   return {
     ...resolved.name !== void 0 ? { name: resolved.name } : {},
     ...resolved.email !== void 0 ? { email: resolved.email } : {},
@@ -5035,7 +5132,7 @@ async function readKeyFromHost(spawnFn, key, logger) {
 }
 async function readExistingGitconfig(filePath) {
   try {
-    const content = await fs11.readFile(filePath, "utf8");
+    const content = await fs10.readFile(filePath, "utf8");
     const result = {};
     const nameMatch = /^\s*name\s*=\s*(.+?)\s*$/m.exec(content);
     const emailMatch = /^\s*email\s*=\s*(.+?)\s*$/m.exec(content);
@@ -5068,7 +5165,7 @@ ${sectionLine(label)}
     );
   }
   const ymlPath = containerConfigPath(opts.name, home);
-  if (!existsSync8(ymlPath)) {
+  if (!existsSync7(ymlPath)) {
     throw new Error(
       `No such config: ${ymlPath}. Run \`monoceros init <template> ${opts.name}\` first.`
     );
@@ -5174,16 +5271,6 @@ Fix the value in the env file (or the yml).`
       throw new Error(formatMissingCredentialsError(missing));
     }
   }
-  const declaredRepos = createOpts.repos ?? [];
-  if (declaredRepos.length > 0) {
-    const reachability = await checkRepoReachability(declaredRepos, {
-      ...opts.reachabilitySpawn ? { spawn: opts.reachabilitySpawn } : {}
-    });
-    const unreachable = reachability.filter((r) => !r.ok);
-    if (unreachable.length > 0) {
-      throw new Error(formatUnreachableReposError(unreachable));
-    }
-  }
   section("Scaffold");
   const dockerMode = await detectDockerMode({
     ...opts.dockerInfoSpawn ? { spawn: opts.dockerInfoSpawn } : {}
@@ -5191,7 +5278,7 @@ Fix the value in the env file (or the yml).`
   if (dockerMode === "rootless") {
     throw new Error(formatRootlessNotSupportedError());
   }
-  await fs12.mkdir(targetDir, { recursive: true });
+  await fs11.mkdir(targetDir, { recursive: true });
   await writeScaffold(createOpts, targetDir, { dockerMode });
   await writeStateFile(
     targetDir,
@@ -5202,72 +5289,118 @@ Fix the value in the env file (or the yml).`
     })
   );
   logger.success(`materialized into ${prettyPath(targetDir)}`);
-  const reposToClone = createOpts.repos ?? [];
-  if (reposToClone.length > 0) {
-    const cloneResults = await cloneReposHostSide(targetDir, reposToClone, {
-      ...opts.cloneSpawn ? { spawn: opts.cloneSpawn } : {}
-    });
-    for (const r of cloneResults) {
-      if (r.status === "cloned") {
-        logger.success(`cloned ${cyan2(r.path)} ${dim(`(${r.url})`)}`);
-      } else if (r.status === "skipped") {
-        logger.info(`projects/${r.path} already present \u2014 skipped clone`);
-      }
-    }
-    const cloneFailures = cloneResults.filter((r) => r.status === "failed");
-    if (cloneFailures.length > 0) {
-      throw new Error(formatCloneFailuresError(cloneFailures));
-    }
-  }
   section("Container");
-  const featureRefs = parsed.config.features.map((f) => f.ref);
-  if (featureRefs.length > 0) {
-    logger.info(`Features: ${featureRefs.map((r) => cyan2(r)).join(", ")}`);
-  }
-  logger.info(
-    dim(
-      'Pulling runtime image and building feature layers. First apply takes ~1\u20132 min (Docker downloads the multi-arch base); subsequent applies are cached and fast. devcontainer-cli may log a "No manifest found" line \u2014 harmless, the pull continues.'
-    )
-  );
-  const ports = createOpts.ports ?? [];
-  const hasPorts = ports.length > 0;
-  if (hasPorts) {
-    await preflightHostPort(proxyHostPort(globalConfig), {
-      ...opts.proxyDocker ? { docker: opts.proxyDocker } : {}
-    });
-  }
+  const applyLog = createApplyLog({
+    name: opts.name,
+    home,
+    cliVersion: opts.cliVersion,
+    configPath: ymlPath,
+    ...opts.now ? { now: opts.now } : {}
+  });
+  const progressOut = opts.progressOut ?? process.stderr;
+  const interactive = (progressOut.isTTY ?? false) && !opts.verbose;
+  const progress = interactive ? createApplyProgress({ out: progressOut, interactive: true }) : null;
+  const containerLogger = progress ? progressTeeLogger(progress, applyLog.sink) : teeApplyLogger(logger, applyLog.sink);
+  const internalLogger = progress ? logFileOnlyLogger(applyLog.sink) : containerLogger;
+  const onSigint = createSigintAbort({
+    progress,
+    out: progressOut,
+    log: applyLog,
+    formatLogPointer: (p) => dim(`log: ${prettyPath(p)}`),
+    onExit: () => process.exit(130)
+  });
+  process.on("SIGINT", onSigint);
+  let exitCode;
   try {
+    const pullWarning = 'Pulling runtime image and building feature layers. First apply takes ~1\u20132 min (Docker downloads the multi-arch base); subsequent applies are cached and fast. devcontainer-cli may log a "No manifest found" line \u2014 harmless, the pull continues.';
+    if (progress) {
+      applyLog.stream.write(`# note: ${pullWarning}
+
+`);
+    } else {
+      containerLogger.info(dim(pullWarning));
+    }
+    const ports = createOpts.ports ?? [];
+    const hasPorts = ports.length > 0;
     if (hasPorts) {
-      await writeDynamicConfig(opts.name, ports, { monocerosHome: home });
-      await ensureProxy({
-        ...opts.proxyDocker ? { docker: opts.proxyDocker } : {},
-        monocerosHome: home,
-        hostPort: proxyHostPort(globalConfig),
-        logger
+      await preflightHostPort(proxyHostPort(globalConfig), {
+        ...opts.proxyDocker ? { docker: opts.proxyDocker } : {}
       });
-    } else {
-      await removeDynamicConfig(opts.name, { monocerosHome: home });
     }
-  } catch (err) {
-    logger.warn?.(
-      `Could not sync Traefik routes: ${err instanceof Error ? err.message : String(err)}. The container will start, but \`<name>.localhost\` routing may not work until the next \`monoceros apply\`.`
-    );
-  }
-  const exitCode = await runContainerCycle(targetDir, {
-    hasCompose: needsCompose(createOpts),
-    ...opts.dockerExec !== void 0 ? { dockerExec: opts.dockerExec } : {},
-    ...opts.devcontainerSpawn !== void 0 ? { devcontainerSpawn: opts.devcontainerSpawn } : {},
-    logger
-  });
-  if (exitCode === 0) {
-    section("Next steps");
-    logger.info(`  ${cyan2(`monoceros shell ${opts.name}`)}`);
+    try {
+      if (hasPorts) {
+        await writeDynamicConfig(opts.name, ports, { monocerosHome: home });
+        await ensureProxy({
+          ...opts.proxyDocker ? { docker: opts.proxyDocker } : {},
+          monocerosHome: home,
+          hostPort: proxyHostPort(globalConfig),
+          logger: containerLogger
+        });
+      } else {
+        await removeDynamicConfig(opts.name, { monocerosHome: home });
+      }
+    } catch (err) {
+      containerLogger.warn?.(
+        `Could not sync Traefik routes: ${err instanceof Error ? err.message : String(err)}. The container will start, but \`<name>.localhost\` routing may not work until the next \`monoceros apply\`.`
+      );
+    }
+    if (progress) {
+      progress.setPhase(
+        needsCompose(createOpts) ? "cleaning up previous containers\u2026" : "starting container\u2026"
+      );
+    }
+    exitCode = await runContainerCycle(targetDir, {
+      hasCompose: needsCompose(createOpts),
+      ...opts.dockerExec !== void 0 ? { dockerExec: opts.dockerExec } : {},
+      ...opts.devcontainerSpawn !== void 0 ? { devcontainerSpawn: opts.devcontainerSpawn } : {},
+      logSink: applyLog.sink,
+      ...progress ? { progressSink: progress.streamSink, silent: true } : {},
+      logger: internalLogger
+    });
+    if (progress) {
+      if (exitCode === 0) {
+        progress.succeed();
+      } else {
+        const { tailLines } = progress.fail();
+        progressOut.write(`
+\u2718 apply failed (exit ${exitCode})
+
+`);
+        for (const line of tailLines) {
+          progressOut.write(`  ${line}
+`);
+        }
+        if (tailLines.length > 0) progressOut.write("\n");
+      }
+    }
+    if (exitCode === 0) {
+      const summaryLines = buildApplySummary(createOpts);
+      if (summaryLines.length > 0) {
+        const formatted = formatApplySummary(summaryLines);
+        progressOut.write(`
+${formatted}
+`);
+        applyLog.stream.write(`
+${stripAnsi(formatted)}
+`);
+      }
+    }
+    await applyLog.close();
+    progressOut.write(`
+  ${dim(`log: ${prettyPath(applyLog.path)}`)}
+`);
+    if (exitCode === 0) {
+      section("Next steps");
+      logger.info(`  ${cyan2(`monoceros shell ${opts.name}`)}`);
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
   }
   return { targetDir, configPath: ymlPath, containerExitCode: exitCode };
 }
 async function assertSafeTargetDir(targetDir, expectedOrigin) {
-  if (!existsSync8(targetDir)) return;
-  const entries = await fs12.readdir(targetDir);
+  if (!existsSync7(targetDir)) return;
+  const entries = await fs11.readdir(targetDir);
   if (entries.length === 0) return;
   const state = await readStateFile(targetDir);
   if (state) {
@@ -5337,7 +5470,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
   }
   if (wantContainer) {
     try {
-      const text = await fs12.readFile(ymlPath, "utf8");
+      const text = await fs11.readFile(ymlPath, "utf8");
       const parsed = parseConfig(text, ymlPath);
       const changed = setContainerGitUserInDoc(parsed.doc, {
         name: prompted.name,
@@ -5345,7 +5478,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
       });
       if (changed) {
         const out = stringifyConfig(parsed.doc);
-        await fs12.writeFile(ymlPath, out, "utf8");
+        await fs11.writeFile(ymlPath, out, "utf8");
         logger.info(
           `Saved identity in this container \u2014 wrote git.user into ${prettyPath(ymlPath)}.`
         );
@@ -5359,7 +5492,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "1.13.2" : "dev";
+var CLI_VERSION = true ? "1.14.0" : "dev";
 
 // src/commands/_dispatch.ts
 import { consola as consola12 } from "consola";
@@ -5385,13 +5518,19 @@ var applyCommand = defineCommand8({
       type: "positional",
       description: "Config name. Resolves to $MONOCEROS_HOME/container-configs/<name>.yml.",
       required: true
+    },
+    verbose: {
+      type: "boolean",
+      description: "Stream the raw @devcontainers/cli output to stderr instead of showing a phase spinner. Auto-enabled when stderr is not a TTY.",
+      default: false
     }
   },
   run({ args }) {
     return dispatch(async () => {
       const result = await runApply({
         name: args.name,
-        cliVersion: CLI_VERSION
+        cliVersion: CLI_VERSION,
+        verbose: args.verbose
       });
       return result.containerExitCode;
     });
@@ -5420,7 +5559,7 @@ function renderCompletionScript(shell) {
       '  COMPREPLY=( $(compgen -W "$candidates" -- "$cur") )',
       "  # Suppress the trailing space when bash narrowed the candidate",
       "  # set to a single token that ends with `=` \u2014 those are value-",
-      "  # flags (`--with=`, `--with-ports=`, \u2026) where the user types the",
+      "  # flags (`--with-features=`, `--with-ports=`, \u2026) where the user types the",
       "  # value immediately after.",
       '  if [[ ${#COMPREPLY[@]} -eq 1 && "${COMPREPLY[0]}" == *= ]]; then',
       "    compopt -o nospace",
@@ -5493,6 +5632,10 @@ var completionCommand = defineCommand9({
   meta: {
     name: "completion",
     group: "tooling",
+    // Hidden from `monoceros --help`: the install scripts wire up
+    // completion automatically; manual setup is documented in
+    // docs/commands/completion.md. Still runnable directly.
+    hidden: true,
     description: "Print a shell completion script for bash, zsh or PowerShell to stdout. Pipe the output into a file your shell loads at startup. The install scripts (install.sh / install.ps1) call this automatically."
   },
   args: {
@@ -5519,7 +5662,7 @@ var completionCommand = defineCommand9({
 import { defineCommand as defineCommand10 } from "citty";
 
 // src/completion/resolve.ts
-import { existsSync as existsSync9, promises as fs13 } from "fs";
+import { existsSync as existsSync8, promises as fs12 } from "fs";
 import path15 from "path";
 async function resolveCompletions(line, point, opts = {}) {
   const { prev, current } = parseCompletionLine(line, point);
@@ -5669,8 +5812,8 @@ function filterPrefix(values, fragment) {
 async function listContainerNames(ctx) {
   const home = ctx.opts.monocerosHome ?? monocerosHome();
   const dir = path15.join(home, "container-configs");
-  if (!existsSync9(dir)) return [];
-  const entries = await fs13.readdir(dir);
+  if (!existsSync8(dir)) return [];
+  const entries = await fs12.readdir(dir);
   return entries.filter((e) => e.endsWith(".yml")).map((e) => e.slice(0, -".yml".length)).sort();
 }
 async function listFeatureComponents() {
@@ -5888,6 +6031,8 @@ var __completeCommand = defineCommand10({
   meta: {
     name: "__complete",
     group: "internal",
+    // Internal plumbing for the shell wrappers — never shown in help.
+    hidden: true,
     description: "Internal \u2014 shell completion engine. Used by the wrappers emitted by `monoceros completion <shell>`. Output one candidate completion per line."
   },
   args: {
@@ -5925,7 +6070,7 @@ import { defineCommand as defineCommand11 } from "citty";
 import { consola as consola14 } from "consola";
 
 // src/init/index.ts
-import { existsSync as existsSync10, promises as fs14 } from "fs";
+import { existsSync as existsSync9, promises as fs13 } from "fs";
 import path16 from "path";
 import { consola as consola13 } from "consola";
 
@@ -6292,7 +6437,7 @@ async function runInit(opts) {
     );
   }
   const dest = containerConfigPath(opts.name, home);
-  if (existsSync10(dest)) {
+  if (existsSync9(dest)) {
     throw new Error(
       `Config already exists: ${dest}. Delete it manually before re-running \`monoceros init\` \u2014 this protects any hand-edits.`
     );
@@ -6363,9 +6508,9 @@ async function runInit(opts) {
   } else {
     text = generateComposedYml(opts.name, composed, lookup, repos, ports);
   }
-  await fs14.mkdir(containerConfigsDir(home), { recursive: true });
+  await fs13.mkdir(containerConfigsDir(home), { recursive: true });
   await ensureEnvGitignored(containerConfigsDir(home));
-  await fs14.writeFile(dest, text, "utf8");
+  await fs13.writeFile(dest, text, "utf8");
   const envPath = containerEnvPath(opts.name, home);
   const seedVars = {};
   for (const f of composed.features) {
@@ -6655,7 +6800,7 @@ var listComponentsCommand = defineCommand12({
   meta: {
     name: "list-components",
     group: "discovery",
-    description: "Print the components catalog used by `monoceros init --with=\u2026`, grouped by category (Languages, Services, Features). Component names render in cyan, descriptions in default colour; when piped, the formatting drops out and lines become `name<TAB>description` for grep/awk-friendly consumption."
+    description: "Print the components catalog used by `monoceros init --with-languages=\u2026 / --with-services=\u2026 / --with-features=\u2026`, grouped by category (Languages, Services, Features). Component names render in cyan, descriptions in default colour; when piped, the formatting drops out and lines become `name<TAB>description` for grep/awk-friendly consumption."
   },
   args: {},
   async run() {
@@ -6924,7 +7069,7 @@ import { consola as consola20 } from "consola";
 import { createInterface } from "readline/promises";
 
 // src/remove/index.ts
-import { existsSync as existsSync11, promises as fs15 } from "fs";
+import { existsSync as existsSync10, promises as fs14 } from "fs";
 import path17 from "path";
 import { consola as consola19 } from "consola";
 async function runRemove(opts) {
@@ -6942,9 +7087,9 @@ async function runRemove(opts) {
   const ymlPath = containerConfigPath(opts.name, home);
   const envPath = containerEnvPath(opts.name, home);
   const containerPath = containerDir(opts.name, home);
-  const hasYml = existsSync11(ymlPath);
-  const hasEnv = existsSync11(envPath);
-  const hasContainer = existsSync11(containerPath);
+  const hasYml = existsSync10(ymlPath);
+  const hasEnv = existsSync10(envPath);
+  const hasContainer = existsSync10(containerPath);
   if (!hasYml && !hasContainer) {
     throw new Error(
       `Nothing to remove for '${opts.name}': neither ${ymlPath} nor ${containerPath} exists.`
@@ -6969,29 +7114,29 @@ async function runRemove(opts) {
   if (!opts.noBackup && (hasYml || hasContainer)) {
     const ts = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     backupPath = path17.join(home, "container-backups", `${opts.name}-${ts}`);
-    await fs15.mkdir(backupPath, { recursive: true });
+    await fs14.mkdir(backupPath, { recursive: true });
     if (hasYml) {
-      await fs15.copyFile(ymlPath, path17.join(backupPath, `${opts.name}.yml`));
+      await fs14.copyFile(ymlPath, path17.join(backupPath, `${opts.name}.yml`));
     }
     if (hasEnv) {
-      await fs15.copyFile(envPath, path17.join(backupPath, `${opts.name}.env`));
+      await fs14.copyFile(envPath, path17.join(backupPath, `${opts.name}.env`));
     }
     if (hasContainer) {
-      await fs15.cp(containerPath, path17.join(backupPath, "container"), {
+      await fs14.cp(containerPath, path17.join(backupPath, "container"), {
         recursive: true
       });
     }
     logger.info(`Backup written to ${prettyPath(backupPath)}.`);
   }
   if (hasYml) {
-    await fs15.rm(ymlPath, { force: true });
+    await fs14.rm(ymlPath, { force: true });
   }
   if (hasEnv) {
-    await fs15.rm(envPath, { force: true });
+    await fs14.rm(envPath, { force: true });
   }
   if (hasContainer) {
     try {
-      await fs15.rm(containerPath, { recursive: true, force: true });
+      await fs14.rm(containerPath, { recursive: true, force: true });
     } catch (err) {
       const code = err.code;
       if (code !== "EACCES" && code !== "EPERM") {
@@ -7017,7 +7162,7 @@ async function runRemove(opts) {
           `docker-based cleanup of ${containerPath} exited ${exit}. Inspect with \`sudo ls -la ${containerPath}\` and clean manually.`
         );
       }
-      await fs15.rm(containerPath, { recursive: true, force: true });
+      await fs14.rm(containerPath, { recursive: true, force: true });
     }
   }
   logger.success(
@@ -7120,7 +7265,7 @@ import { defineCommand as defineCommand18 } from "citty";
 import { consola as consola22 } from "consola";
 
 // src/restore/index.ts
-import { existsSync as existsSync12, promises as fs16 } from "fs";
+import { existsSync as existsSync11, promises as fs15 } from "fs";
 import path18 from "path";
 import { consola as consola21 } from "consola";
 async function runRestore(opts) {
@@ -7130,14 +7275,14 @@ async function runRestore(opts) {
     success: (msg) => consola21.success(msg)
   };
   const backup = path18.resolve(opts.backupPath);
-  if (!existsSync12(backup)) {
+  if (!existsSync11(backup)) {
     throw new Error(`Backup not found: ${backup}.`);
   }
-  const stat = await fs16.stat(backup);
+  const stat = await fs15.stat(backup);
   if (!stat.isDirectory()) {
     throw new Error(`Backup path is not a directory: ${backup}.`);
   }
-  const entries = await fs16.readdir(backup);
+  const entries = await fs15.readdir(backup);
   const ymlFiles = entries.filter((f) => f.endsWith(".yml"));
   if (ymlFiles.length === 0) {
     throw new Error(
@@ -7152,28 +7297,28 @@ async function runRestore(opts) {
   const ymlFile = ymlFiles[0];
   const name = ymlFile.replace(/\.yml$/, "");
   const containerInBackup = path18.join(backup, "container");
-  const hasContainer = existsSync12(containerInBackup);
+  const hasContainer = existsSync11(containerInBackup);
   const envInBackup = path18.join(backup, `${name}.env`);
-  const hasEnv = existsSync12(envInBackup);
+  const hasEnv = existsSync11(envInBackup);
   const destYml = containerConfigPath(name, home);
   const destContainer = containerDir(name, home);
-  if (existsSync12(destYml)) {
+  if (existsSync11(destYml)) {
     throw new Error(
       `Refusing to restore: ${destYml} already exists. Remove the current container first (\`monoceros remove ${name}\`) or rename the existing config.`
     );
   }
-  if (hasContainer && existsSync12(destContainer)) {
+  if (hasContainer && existsSync11(destContainer)) {
     throw new Error(
       `Refusing to restore: ${destContainer} already exists. Remove the current container first (\`monoceros remove ${name}\`).`
     );
   }
-  await fs16.mkdir(containerConfigsDir(home), { recursive: true });
-  await fs16.copyFile(path18.join(backup, ymlFile), destYml);
+  await fs15.mkdir(containerConfigsDir(home), { recursive: true });
+  await fs15.copyFile(path18.join(backup, ymlFile), destYml);
   if (hasEnv) {
-    await fs16.copyFile(envInBackup, containerEnvPath(name, home));
+    await fs15.copyFile(envInBackup, containerEnvPath(name, home));
   }
   if (hasContainer) {
-    await fs16.cp(containerInBackup, destContainer, { recursive: true });
+    await fs15.cp(containerInBackup, destContainer, { recursive: true });
   }
   logger.success(`Restored '${name}' from ${prettyPath(backup)}.`);
   logger.info(
@@ -7431,7 +7576,7 @@ import { defineCommand as defineCommand24 } from "citty";
 import { consola as consola28 } from "consola";
 
 // src/devcontainer/shell.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import path19 from "path";
 async function runShell(opts) {
   assertContainerExists(opts.root);
@@ -7455,7 +7600,7 @@ async function runShell(opts) {
   );
 }
 function assertContainerExists(root) {
-  if (!existsSync13(path19.join(root, ".devcontainer"))) {
+  if (!existsSync12(path19.join(root, ".devcontainer"))) {
     throw new Error(
       `No .devcontainer/ at ${root}. Run \`monoceros apply <name>\` first.`
     );
@@ -7667,15 +7812,15 @@ import { defineCommand as defineCommand29 } from "citty";
 import { consola as consola33 } from "consola";
 
 // src/tunnel/run.ts
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { consola as consola32 } from "consola";
 
 // src/tunnel/resolve.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import path20 from "path";
 async function resolveTunnelTarget(opts) {
   const ymlPath = containerConfigPath(opts.name, opts.monocerosHome);
-  if (!existsSync14(ymlPath)) {
+  if (!existsSync13(ymlPath)) {
     throw new Error(
       `No yml profile for '${opts.name}' at ${ymlPath}. Run \`monoceros init ${opts.name}\` first.`
     );
@@ -7683,13 +7828,13 @@ async function resolveTunnelTarget(opts) {
   const parsed = await readConfig(ymlPath);
   const config = parsed.config;
   const containerRoot = containerDir(opts.name, opts.monocerosHome);
-  if (!existsSync14(containerRoot)) {
+  if (!existsSync13(containerRoot)) {
     throw new Error(
       `Container '${opts.name}' is not materialised at ${containerRoot}. Run \`monoceros apply ${opts.name}\` first.`
     );
   }
   const composePath = path20.join(containerRoot, ".devcontainer", "compose.yaml");
-  const isCompose = existsSync14(composePath);
+  const isCompose = existsSync13(composePath);
   const parsedTarget = parseTargetArg(opts.target, config);
   const docker = opts.docker ?? defaultDockerExec;
   if (isCompose) {
@@ -7910,7 +8055,7 @@ function formatLocalPortHeldError(port, address, result) {
 // src/tunnel/run.ts
 var SOCAT_IMAGE = "alpine/socat:1.8.0.3";
 var defaultDockerSpawn = (args) => {
-  const child = spawn10("docker", args, {
+  const child = spawn8("docker", args, {
     stdio: "inherit"
   });
   const exited = new Promise((resolve, reject) => {