@getmonoceros/workbench 1.13.3 → 1.14.1

package/dist/bin.js

@@ -254,25 +254,25 @@ function detectHelpRequest(argv, main2) {
   const separatorIdx = argv.indexOf("--");
   if (helpIdx === -1) return null;
   if (separatorIdx !== -1 && separatorIdx < helpIdx) return null;
-  const path20 = [];
+  const path21 = [];
   const tokens = argv.slice(
     0,
     separatorIdx === -1 ? argv.length : separatorIdx
   );
   let cursor = main2;
   const mainName = (main2.meta ?? {}).name ?? "monoceros";
-  path20.push(mainName);
+  path21.push(mainName);
   for (const tok of tokens) {
     if (tok.startsWith("-")) continue;
     const subs = cursor.subCommands ?? {};
     if (tok in subs) {
       cursor = subs[tok];
-      path20.push(tok);
+      path21.push(tok);
       continue;
     }
     break;
   }
-  return { path: path20, cmd: cursor };
+  return { path: path21, cmd: cursor };
 }
 async function maybeRenderHelp(argv, main2) {
   const hit = detectHelpRequest(argv, main2);
@@ -622,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");
 }
@@ -736,25 +739,20 @@ function resolveGitUserFields(user, vars) {
   };
   return { name: resolve(user.name), email: resolve(user.email) };
 }
-function interpolateFeatures(features, vars) {
-  const missing = [];
-  const out = {};
-  for (const [ref, options] of Object.entries(features)) {
-    const next = {};
-    for (const [key, value] of Object.entries(options)) {
+function interpolateFeatureOptions(features, vars) {
+  return features.map((f) => {
+    if (!f.options) return f;
+    const opts = {};
+    for (const [key, value] of Object.entries(f.options)) {
       if (typeof value !== "string") {
-        next[key] = value;
+        opts[key] = value;
         continue;
       }
       const r = interpolate(value, vars);
-      for (const name of r.missing) {
-        missing.push({ location: `features.${ref}.${key}`, name });
-      }
-      next[key] = r.value;
+      opts[key] = r.missing.length > 0 ? "" : r.value.trim();
     }
-    out[ref] = next;
-  }
-  return { features: out, missing };
+    return { ...f, options: opts };
+  });
 }
 function buildEnvStub(name) {
   return `# Secrets and values for \${VAR} references in ${name}.yml.
@@ -985,6 +983,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;
 }
@@ -3013,13 +3015,17 @@ function addInstallUrlToDoc(doc, url) {
 function addFeatureToDoc(doc, ref, options = {}, displayName) {
   const seq = ensureSeq(doc, "features");
   const label = displayName ?? ref;
+  const summary = loadFeatureManifestSummary(ref);
+  const hints = featureOptionHints(summary, ref, Object.keys(options));
+  const mergedOptions = { ...options };
+  for (const h of hints) mergedOptions[h.key] = h.placeholder;
   for (const item of seq.items) {
     if (!isMap2(item)) continue;
     const itemRef = item.get("ref");
     if (itemRef !== ref) continue;
     const itemJs = item.toJS(doc);
     const existingJs = itemJs.options ?? {};
-    if (JSON.stringify(existingJs) === JSON.stringify(options)) {
+    if (JSON.stringify(existingJs) === JSON.stringify(mergedOptions)) {
       return false;
     }
     throw new Error(
@@ -3028,10 +3034,9 @@ function addFeatureToDoc(doc, ref, options = {}, displayName) {
   }
   const entry2 = new YAMLMap2();
   entry2.set("ref", ref);
-  if (Object.keys(options).length > 0) {
-    entry2.set("options", options);
+  if (Object.keys(mergedOptions).length > 0) {
+    entry2.set("options", mergedOptions);
   }
-  const summary = loadFeatureManifestSummary(ref);
   const headerBefore = buildFeatureHeaderCommentBefore(
     summary,
     FEATURE_HEADER_WIDTH
@@ -3040,12 +3045,6 @@ function addFeatureToDoc(doc, ref, options = {}, displayName) {
     entry2.commentBefore = headerBefore;
     entry2.spaceBefore = true;
   }
-  const hints = featureOptionHints(summary, ref, Object.keys(options));
-  if (hints.length > 0) {
-    const commentLines = [" options:"];
-    for (const h of hints) commentLines.push(`   ${h.key}: ${h.placeholder}`);
-    entry2.comment = commentLines.join("\n");
-  }
   seq.add(entry2);
   return true;
 }
@@ -3170,8 +3169,8 @@ function removeRepoFromDoc(doc, urlOrPath) {
     if (!isMap2(item)) return false;
     const url = item.get("url");
     if (url === urlOrPath) return true;
-    const path20 = item.get("path");
-    const effectivePath = typeof path20 === "string" ? path20 : typeof url === "string" ? deriveRepoName(url) : void 0;
+    const path21 = item.get("path");
+    const effectivePath = typeof path21 === "string" ? path21 : typeof url === "string" ? deriveRepoName(url) : void 0;
     return effectivePath === urlOrPath;
   });
   if (idx < 0) return false;
@@ -3264,7 +3263,7 @@ async function runAddRepo(input) {
       "Missing repo URL. Usage: monoceros add-repo <containername> <url>."
     );
   }
-  const path20 = (input.path ?? deriveRepoName(url)).trim();
+  const path21 = (input.path ?? deriveRepoName(url)).trim();
   const hasName = typeof input.gitName === "string" && input.gitName.trim().length > 0;
   const hasEmail = typeof input.gitEmail === "string" && input.gitEmail.trim().length > 0;
   if (hasName !== hasEmail) {
@@ -3301,7 +3300,7 @@ async function runAddRepo(input) {
   const providerToWrite = !canonical && explicitProvider ? explicitProvider : void 0;
   const entry2 = {
     url,
-    path: path20,
+    path: path21,
     ...hasName && hasEmail ? {
       gitUser: {
         name: input.gitName.trim(),
@@ -4240,10 +4239,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
@@ -4306,7 +4587,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";
@@ -4357,7 +4638,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 = {}) => {
@@ -4397,8 +4678,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));
   });
@@ -4475,15 +4768,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.`
@@ -4504,9 +4797,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) {
@@ -4542,6 +4843,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
     });
   }
@@ -4555,7 +4859,8 @@ and retry \`monoceros apply\`.`
       "--mount-workspace-git-root=false",
       "--remove-existing-container"
     ],
-    root
+    root,
+    buildSpawnOptions(opts)
   );
 }
 function runStop(opts) {
@@ -4647,7 +4952,7 @@ function formatRootlessNotSupportedError() {
 // src/devcontainer/identity.ts
 import { spawn as spawn7 } from "child_process";
 import { promises as fs10 } from "fs";
-import path13 from "path";
+import path14 from "path";
 import { consola as consola10 } from "consola";
 var realGitConfigGet = (key) => {
   return new Promise((resolve, reject) => {
@@ -4761,8 +5066,8 @@ async function resolveIdentityWithPrompt(options = {}) {
   };
 }
 async function collectGitIdentity(devContainerRoot, options = {}) {
-  const gitconfigDir = path13.join(devContainerRoot, ".monoceros");
-  const gitconfigPath = path13.join(gitconfigDir, "gitconfig");
+  const gitconfigDir = path14.join(devContainerRoot, ".monoceros");
+  const gitconfigPath = path14.join(gitconfigDir, "gitconfig");
   const logger = options.logger ?? { info: () => {
   }, warn: () => {
   } };
@@ -4863,26 +5168,26 @@ ${sectionLine(label)}
   const parsed = await readConfig(ymlPath);
   const globalConfig = await readMonocerosConfig({ monocerosHome: home });
   warnOnDeprecatedFeatureRefs(parsed.config.features, globalConfig, logger);
+  const envPath = containerEnvPath(opts.name, home);
+  await ensureEnvGitignored(containerConfigsDir(home));
+  const envVars = readEnvFile(envPath);
+  const resolvedFeatures = interpolateFeatureOptions(
+    parsed.config.features,
+    envVars
+  );
   const createOpts = normalizeOptions(
     solutionConfigToCreateOptions(
-      parsed.config,
+      { ...parsed.config, features: resolvedFeatures },
       globalConfig?.defaults?.features ?? {}
     )
   );
-  const envPath = containerEnvPath(opts.name, home);
-  await ensureEnvGitignored(containerConfigsDir(home));
-  const envVars = readEnvFile(envPath);
   const interpServices = interpolateServices(createOpts.services, envVars);
-  const interpFeatures = interpolateFeatures(
-    createOpts.features ?? {},
-    envVars
-  );
-  const missingVars = [...interpServices.missing, ...interpFeatures.missing];
-  if (missingVars.length > 0) {
-    throw new Error(formatMissingVarsError(missingVars, prettyPath(envPath)));
+  if (interpServices.missing.length > 0) {
+    throw new Error(
+      formatMissingVarsError(interpServices.missing, prettyPath(envPath))
+    );
   }
   createOpts.services = interpServices.services;
-  if (createOpts.features) createOpts.features = interpFeatures.features;
   const gitUserErrors = [];
   let containerGitOverride;
   if (parsed.config.git?.user) {
@@ -4977,48 +5282,111 @@ Fix the value in the env file (or the yml).`
   );
   logger.success(`materialized into ${prettyPath(targetDir)}`);
   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 };
 }
@@ -5116,7 +5484,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "1.13.3" : "dev";
+var CLI_VERSION = true ? "1.14.1" : "dev";
 
 // src/commands/_dispatch.ts
 import { consola as consola12 } from "consola";
@@ -5142,13 +5510,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;
     });
@@ -5281,7 +5655,7 @@ import { defineCommand as defineCommand10 } from "citty";
 
 // src/completion/resolve.ts
 import { existsSync as existsSync8, promises as fs12 } from "fs";
-import path14 from "path";
+import path15 from "path";
 async function resolveCompletions(line, point, opts = {}) {
   const { prev, current } = parseCompletionLine(line, point);
   const ctx = { prev, current, opts };
@@ -5429,7 +5803,7 @@ function filterPrefix(values, fragment) {
 }
 async function listContainerNames(ctx) {
   const home = ctx.opts.monocerosHome ?? monocerosHome();
-  const dir = path14.join(home, "container-configs");
+  const dir = path15.join(home, "container-configs");
   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();
@@ -5689,7 +6063,7 @@ import { consola as consola14 } from "consola";
 
 // src/init/index.ts
 import { existsSync as existsSync9, promises as fs13 } from "fs";
-import path15 from "path";
+import path16 from "path";
 import { consola as consola13 } from "consola";
 
 // src/init/generator.ts
@@ -5992,17 +6366,12 @@ function renderFeatureBlock(out, feature, summary, commented) {
     }
     return;
   }
-  if (activeKeys.length > 0) {
-    out.push(`    options:`);
-    for (const [key, value] of activeKeys) {
-      out.push(`      ${key}: ${renderScalarValue(value)}`);
-    }
+  out.push(`    options:`);
+  for (const [key, value] of activeKeys) {
+    out.push(`      ${key}: ${renderScalarValue(value)}`);
   }
-  if (hints.length > 0) {
-    out.push(`    # options:`);
-    for (const hint of hints) {
-      out.push(`    #   ${hint.key}: ${hint.placeholder}`);
-    }
+  for (const hint of hints) {
+    out.push(`      ${hint.key}: ${hint.placeholder}`);
   }
 }
 function pushHeader(out, header, name) {
@@ -6151,8 +6520,8 @@ async function runInit(opts) {
   }
   await ensureEnvVars(envPath, opts.name, seedVars);
   const documented = !anyComposed;
-  const ymlRel = path15.relative(home, dest);
-  const envRel = path15.relative(home, envPath);
+  const ymlRel = path16.relative(home, dest);
+  const envRel = path16.relative(home, envPath);
   if (documented) {
     logger.success(`Wrote documented default to ${ymlRel} and ${envRel}.`);
     logger.info(
@@ -6688,7 +7057,7 @@ import { createInterface } from "readline/promises";
 
 // src/remove/index.ts
 import { existsSync as existsSync10, promises as fs14 } from "fs";
-import path16 from "path";
+import path17 from "path";
 import { consola as consola19 } from "consola";
 async function runRemove(opts) {
   const home = opts.monocerosHome ?? monocerosHome();
@@ -6731,16 +7100,16 @@ async function runRemove(opts) {
   let backupPath = null;
   if (!opts.noBackup && (hasYml || hasContainer)) {
     const ts = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    backupPath = path16.join(home, "container-backups", `${opts.name}-${ts}`);
+    backupPath = path17.join(home, "container-backups", `${opts.name}-${ts}`);
     await fs14.mkdir(backupPath, { recursive: true });
     if (hasYml) {
-      await fs14.copyFile(ymlPath, path16.join(backupPath, `${opts.name}.yml`));
+      await fs14.copyFile(ymlPath, path17.join(backupPath, `${opts.name}.yml`));
     }
     if (hasEnv) {
-      await fs14.copyFile(envPath, path16.join(backupPath, `${opts.name}.env`));
+      await fs14.copyFile(envPath, path17.join(backupPath, `${opts.name}.env`));
     }
     if (hasContainer) {
-      await fs14.cp(containerPath, path16.join(backupPath, "container"), {
+      await fs14.cp(containerPath, path17.join(backupPath, "container"), {
         recursive: true
       });
     }
@@ -6884,7 +7253,7 @@ import { consola as consola22 } from "consola";
 
 // src/restore/index.ts
 import { existsSync as existsSync11, promises as fs15 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import { consola as consola21 } from "consola";
 async function runRestore(opts) {
   const home = opts.monocerosHome ?? monocerosHome();
@@ -6892,7 +7261,7 @@ async function runRestore(opts) {
     info: (msg) => consola21.info(msg),
     success: (msg) => consola21.success(msg)
   };
-  const backup = path17.resolve(opts.backupPath);
+  const backup = path18.resolve(opts.backupPath);
   if (!existsSync11(backup)) {
     throw new Error(`Backup not found: ${backup}.`);
   }
@@ -6914,9 +7283,9 @@ async function runRestore(opts) {
   }
   const ymlFile = ymlFiles[0];
   const name = ymlFile.replace(/\.yml$/, "");
-  const containerInBackup = path17.join(backup, "container");
+  const containerInBackup = path18.join(backup, "container");
   const hasContainer = existsSync11(containerInBackup);
-  const envInBackup = path17.join(backup, `${name}.env`);
+  const envInBackup = path18.join(backup, `${name}.env`);
   const hasEnv = existsSync11(envInBackup);
   const destYml = containerConfigPath(name, home);
   const destContainer = containerDir(name, home);
@@ -6931,7 +7300,7 @@ async function runRestore(opts) {
     );
   }
   await fs15.mkdir(containerConfigsDir(home), { recursive: true });
-  await fs15.copyFile(path17.join(backup, ymlFile), destYml);
+  await fs15.copyFile(path18.join(backup, ymlFile), destYml);
   if (hasEnv) {
     await fs15.copyFile(envInBackup, containerEnvPath(name, home));
   }
@@ -7195,7 +7564,7 @@ import { consola as consola28 } from "consola";
 
 // src/devcontainer/shell.ts
 import { existsSync as existsSync12 } from "fs";
-import path18 from "path";
+import path19 from "path";
 async function runShell(opts) {
   assertContainerExists(opts.root);
   const spawnFn = opts.spawn ?? spawnDevcontainer;
@@ -7218,7 +7587,7 @@ async function runShell(opts) {
   );
 }
 function assertContainerExists(root) {
-  if (!existsSync12(path18.join(root, ".devcontainer"))) {
+  if (!existsSync12(path19.join(root, ".devcontainer"))) {
     throw new Error(
       `No .devcontainer/ at ${root}. Run \`monoceros apply <name>\` first.`
     );
@@ -7435,7 +7804,7 @@ import { consola as consola32 } from "consola";
 
 // src/tunnel/resolve.ts
 import { existsSync as existsSync13 } from "fs";
-import path19 from "path";
+import path20 from "path";
 async function resolveTunnelTarget(opts) {
   const ymlPath = containerConfigPath(opts.name, opts.monocerosHome);
   if (!existsSync13(ymlPath)) {
@@ -7451,7 +7820,7 @@ async function resolveTunnelTarget(opts) {
       `Container '${opts.name}' is not materialised at ${containerRoot}. Run \`monoceros apply ${opts.name}\` first.`
     );
   }
-  const composePath = path19.join(containerRoot, ".devcontainer", "compose.yaml");
+  const composePath = path20.join(containerRoot, ".devcontainer", "compose.yaml");
   const isCompose = existsSync13(composePath);
   const parsedTarget = parseTargetArg(opts.target, config);
   const docker = opts.docker ?? defaultDockerExec;