laracrew 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli/program.ts
-import { readFileSync as readFileSync4 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
@@ -315,6 +315,7 @@ var mergeServiceFragments = (document, dir) => {
   const existing = Array.isArray(document.services) ? document.services : [];
   return { ...document, services: [...existing, ...extra] };
 };
+var validateStack = (document, file) => validate(stackSchema, document, file);
 var loadStack = (name, env = process.env) => {
   const dir = stackDir(name, env);
   const file = stackFile(name, env);
@@ -345,41 +346,192 @@ var listTasks = (env = process.env) => {
 };
 
 // src/cli/render/colors.ts
-var CODES = {
-  reset: 0,
-  bold: 1,
-  dim: 2,
-  italic: 3,
-  underline: 4,
-  black: 30,
-  red: 31,
-  green: 32,
-  yellow: 33,
-  blue: 34,
-  magenta: 35,
-  cyan: 36,
-  white: 37,
-  gray: 90
+import { Chalk, supportsColor as chalkDetected } from "chalk";
+
+// src/core/logs/sanitize.ts
+var ESC = String.fromCharCode(27);
+var BEL = String.fromCharCode(7);
+var CSI = new RegExp(ESC + "\\[[0-?]*[ -/]*[@-~]", "g");
+var OSC = new RegExp(ESC + "\\][^" + BEL + ESC + "]*(?:" + BEL + "|" + ESC + "\\\\)", "g");
+var SINGLE = new RegExp(ESC + "[=>78MD]", "g");
+var SGR = new RegExp(ESC + "\\[[0-9;]*m", "g");
+var stripAnsi = (text) => text.replace(SGR, "");
+var TAB = 9;
+var ESC_CODE = 27;
+var sanitize = (input) => {
+  let out = input.replace(OSC, "").replace(SINGLE, "");
+  out = out.replace(CSI, (seq) => seq.endsWith("m") ? seq : "");
+  if (out.includes("\r")) {
+    const segments = out.split("\r").filter((segment) => segment !== "");
+    out = segments.length > 0 ? segments[segments.length - 1] : "";
+  }
+  return out.replace(new RegExp("\\p{Cc}", "gu"), (character) => {
+    const code = character.charCodeAt(0);
+    return code === TAB || code === ESC_CODE ? character : "";
+  });
+};
+var LineSplitter = class {
+  #buffer = "";
+  #maxLineLength;
+  constructor(maxLineLength = 16384) {
+    this.#maxLineLength = maxLineLength;
+  }
+  push(chunk) {
+    this.#buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    const lines = [];
+    let index = this.#buffer.indexOf("\n");
+    while (index !== -1) {
+      const line = this.#buffer.slice(0, index).replace(/\r$/, "");
+      lines.push(sanitize(line));
+      this.#buffer = this.#buffer.slice(index + 1);
+      index = this.#buffer.indexOf("\n");
+    }
+    if (this.#buffer.length > this.#maxLineLength) {
+      lines.push(sanitize(this.#buffer));
+      this.#buffer = "";
+    }
+    return lines;
+  }
+  /** Emits whatever is left when the stream closes. */
+  flush() {
+    if (this.#buffer === "") return [];
+    const line = sanitize(this.#buffer.replace(/\r$/, ""));
+    this.#buffer = "";
+    return line === "" ? [] : [line];
+  }
 };
+
+// src/cli/render/colors.ts
+var NAMES = [
+  "reset",
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "gray"
+];
 var supportsColor = (stream = process.stdout, env = process.env) => {
   if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
-  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") return true;
+  if (env.FORCE_COLOR !== void 0) return env.FORCE_COLOR !== "0" && env.FORCE_COLOR !== "false";
   if (env.TERM === "dumb") return false;
   return Boolean(stream.isTTY);
 };
+var levelFor = (enabled) => enabled ? Math.max(1, chalkDetected ? chalkDetected.level : 1) : 0;
+var createColor = (enabled) => new Chalk({ level: levelFor(enabled) });
+var color = createColor(supportsColor());
 var createPainter = (enabled) => {
-  const paint2 = ((name, text) => enabled ? `\x1B[${CODES[name]}m${text}\x1B[${CODES.reset}m` : text);
-  paint2.enabled = enabled;
-  return paint2;
+  const chalk = createColor(enabled);
+  return Object.assign((name, text) => chalk[name](text), { enabled });
 };
 var paint = createPainter(supportsColor());
-var asColorName = (value) => value && value in CODES ? value : "cyan";
-var stripAnsi = (text) => text.replace(/\[[0-9;]*m/g, "");
+var asColorName = (value) => value && NAMES.includes(value) ? value : "cyan";
 var padEnd = (text, width) => {
   const visible = stripAnsi(text).length;
   return visible >= width ? text : text + " ".repeat(width - visible);
 };
 
+// src/tui/theme.ts
+var asciiOnly = (env = process.env) => env.LARACREW_ASCII === "1" || env.TERM === "dumb";
+var UNICODE = {
+  running: "\u25CF",
+  ready: "\u25CF",
+  starting: "\u25D0",
+  stopped: "\u25FC",
+  failed: "\u2716",
+  queued: "\u25CB",
+  branch: "\u251C\u2500",
+  lastBranch: "\u2514\u2500",
+  pipe: "\u2502",
+  pointer: "\u25B8",
+  restart: "\u27F3",
+  rule: "\u2500",
+  dot: "\xB7",
+  tick: "\u2714",
+  warn: "\u25B2",
+  arrow: "\u2192"
+};
+var ASCII = {
+  running: "*",
+  ready: "*",
+  starting: "o",
+  stopped: "#",
+  failed: "X",
+  queued: ".",
+  branch: "|-",
+  lastBranch: "`-",
+  pipe: "|",
+  pointer: ">",
+  restart: "r",
+  rule: "-",
+  dot: ".",
+  tick: "v",
+  warn: "!",
+  arrow: "->"
+};
+var glyphs = (env = process.env) => asciiOnly(env) ? ASCII : UNICODE;
+var STATE_STYLE = {
+  queued: { glyph: "queued", color: "gray", label: "QUEUED" },
+  starting: { glyph: "starting", color: "yellow", label: "STARTING" },
+  ready: { glyph: "ready", color: "cyan", label: "READY" },
+  running: { glyph: "running", color: "green", label: "RUNNING" },
+  stopping: { glyph: "starting", color: "yellow", label: "STOPPING" },
+  stopped: { glyph: "stopped", color: "gray", label: "STOPPED" },
+  crashed: { glyph: "failed", color: "red", label: "CRASHED" },
+  backoff: { glyph: "starting", color: "yellow", label: "RESTARTING" },
+  failed: { glyph: "failed", color: "red", label: "FAILED" }
+};
+var formatUptime = (ms) => {
+  if (ms === void 0 || ms < 0) return "--:--:--";
+  const total = Math.floor(ms / 1e3);
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  return [hours, minutes, seconds].map((part) => String(part).padStart(2, "0")).join(":");
+};
+var formatDuration = (ms) => {
+  if (ms === void 0 || ms < 0) return "\u2014";
+  const total = Math.floor(ms / 1e3);
+  if (total < 60) return `${total}s`;
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  if (minutes < 60) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
+};
+var formatClock = (at) => {
+  const date = new Date(at);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((part) => String(part).padStart(2, "0")).join(":");
+};
+
+// src/cli/render/marks.ts
+var marks = (env = process.env) => {
+  const glyph = glyphs(env);
+  return {
+    ok: color.green(glyph.tick),
+    fail: color.red(glyph.failed),
+    warn: color.yellow(glyph.warn),
+    skip: color.gray(glyph.dot),
+    hint: color.cyan(glyph.pointer),
+    arrow: color.gray(glyph.arrow)
+  };
+};
+var nextSteps = (rows, env = process.env) => {
+  const mark = marks(env);
+  const width = Math.max(...rows.map(([command]) => command.length));
+  const lines = rows.map(
+    ([command, why]) => command ? `  ${mark.hint} ${color.cyan(padEnd(command, width))}  ${why}` : `${" ".repeat(width + 6)}${why}`
+  );
+  return [color.bold("Next"), ...lines].join("\n");
+};
+
 // src/cli/commands/doctor.ts
 import { existsSync as existsSync4 } from "fs";
 import path7 from "path";
@@ -1063,57 +1215,6 @@ var RingBuffer = class {
   }
 };
 
-// src/core/logs/sanitize.ts
-var ESC = String.fromCharCode(27);
-var BEL = String.fromCharCode(7);
-var CSI = new RegExp(ESC + "\\[[0-?]*[ -/]*[@-~]", "g");
-var OSC = new RegExp(ESC + "\\][^" + BEL + ESC + "]*(?:" + BEL + "|" + ESC + "\\\\)", "g");
-var SINGLE = new RegExp(ESC + "[=>78MD]", "g");
-var TAB = 9;
-var ESC_CODE = 27;
-var sanitize = (input) => {
-  let out = input.replace(OSC, "").replace(SINGLE, "");
-  out = out.replace(CSI, (seq) => seq.endsWith("m") ? seq : "");
-  if (out.includes("\r")) {
-    const segments = out.split("\r").filter((segment) => segment !== "");
-    out = segments.length > 0 ? segments[segments.length - 1] : "";
-  }
-  return out.replace(new RegExp("\\p{Cc}", "gu"), (character) => {
-    const code = character.charCodeAt(0);
-    return code === TAB || code === ESC_CODE ? character : "";
-  });
-};
-var LineSplitter = class {
-  #buffer = "";
-  #maxLineLength;
-  constructor(maxLineLength = 16384) {
-    this.#maxLineLength = maxLineLength;
-  }
-  push(chunk) {
-    this.#buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    const lines = [];
-    let index = this.#buffer.indexOf("\n");
-    while (index !== -1) {
-      const line = this.#buffer.slice(0, index).replace(/\r$/, "");
-      lines.push(sanitize(line));
-      this.#buffer = this.#buffer.slice(index + 1);
-      index = this.#buffer.indexOf("\n");
-    }
-    if (this.#buffer.length > this.#maxLineLength) {
-      lines.push(sanitize(this.#buffer));
-      this.#buffer = "";
-    }
-    return lines;
-  }
-  /** Emits whatever is left when the stream closes. */
-  flush() {
-    if (this.#buffer === "") return [];
-    const line = sanitize(this.#buffer.replace(/\r$/, ""));
-    this.#buffer = "";
-    return line === "" ? [] : [line];
-  }
-};
-
 // src/core/process/stop.ts
 import { spawn as spawn2 } from "child_process";
 var IS_WINDOWS2 = process.platform === "win32";
@@ -1721,6 +1822,7 @@ var time = (date) => `${String(date.getHours()).padStart(2, "0")}:${String(date.
 var attachPlainRenderer = (bus, options) => {
   const write2 = options.write ?? ((text) => write(text));
   const painter = options.painter ?? paint;
+  const glyph = options.glyph ?? glyphs();
   const showTime = options.timestamps ?? true;
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const colorOf = new Map(options.stack.services.map((service) => [service.name, asColorName(service.color)]));
@@ -1731,10 +1833,19 @@ var attachPlainRenderer = (bus, options) => {
     write2(`${stamp2}${prefix} ${painter("gray", "|")} ${text}
 `);
   };
-  const system = (text, level = "info") => {
-    const color = level === "error" ? "red" : level === "warn" ? "yellow" : "gray";
-    line("laracrew", painter(color, text), "bold");
+  const note = (tone, text) => {
+    switch (tone) {
+      case "ok":
+        return `${painter("green", glyph.tick)} ${painter("green", text)}`;
+      case "warn":
+        return `${painter("yellow", glyph.warn)} ${painter("yellow", text)}`;
+      case "error":
+        return `${painter("red", glyph.failed)} ${painter("red", text)}`;
+      default:
+        return painter("gray", text);
+    }
   };
+  const system = (text, tone = "info") => line("laracrew", note(tone, text), "bold");
   const handle = (event) => {
     switch (event.type) {
       case "service:log":
@@ -1749,7 +1860,7 @@ var attachPlainRenderer = (bus, options) => {
         break;
       }
       case "stack:ready":
-        system(`${event.stack} ready in ${(event.durationMs / 1e3).toFixed(1)}s`);
+        system(`${event.stack} ready in ${(event.durationMs / 1e3).toFixed(1)}s`, "ok");
         break;
       case "stack:stopping":
         system(`stopping ${event.stack}\u2026`);
@@ -1761,30 +1872,32 @@ var attachPlainRenderer = (bus, options) => {
         line(event.service, painter("gray", `$ ${event.command}`));
         break;
       case "service:ready":
-        line(event.service, painter("green", `ready (${event.probe}) in ${event.durationMs}ms`));
+        line(event.service, note("ok", `ready (${event.probe}) in ${event.durationMs}ms`));
         break;
       case "service:exit":
         if (!event.intentional) {
-          line(
-            event.service,
-            painter("red", `exited (${event.signal ? `signal ${event.signal}` : `code ${event.code}`})`)
-          );
+          const clean = event.code === 0 && !event.signal;
+          const why = event.signal ? `signal ${event.signal}` : `code ${event.code}`;
+          line(event.service, note(clean ? "warn" : "error", `exited (${why})`));
         }
         break;
       case "service:restart":
         line(
           event.service,
-          painter("yellow", `restarting in ${event.delayMs}ms (attempt ${event.attempt}/${event.maxAttempts})`)
+          `${painter("yellow", glyph.restart)} ${painter(
+            "yellow",
+            `restarting in ${event.delayMs}ms (attempt ${event.attempt}/${event.maxAttempts})`
+          )}`
         );
         break;
       case "service:state":
         if (event.to === "failed") {
-          line(event.service, painter("red", `failed${event.detail ? `: ${event.detail}` : ""}`));
+          line(event.service, note("error", `failed${event.detail ? `: ${event.detail}` : ""}`));
         }
         break;
       case "notice":
         if (event.service) {
-          line(event.service, painter(event.level === "error" ? "red" : "yellow", event.message));
+          line(event.service, note(event.level, event.message));
         } else {
           system(event.message, event.level);
         }
@@ -1925,75 +2038,6 @@ var handleKey = (ui, key, rowCount) => {
   }
 };
 
-// src/tui/theme.ts
-var asciiOnly = (env = process.env) => env.LARACREW_ASCII === "1" || env.TERM === "dumb";
-var UNICODE = {
-  running: "\u25CF",
-  ready: "\u25CF",
-  starting: "\u25D0",
-  stopped: "\u25FC",
-  failed: "\u2716",
-  queued: "\u25CB",
-  branch: "\u251C\u2500",
-  lastBranch: "\u2514\u2500",
-  pipe: "\u2502",
-  pointer: "\u25B8",
-  restart: "\u27F3",
-  rule: "\u2500",
-  dot: "\xB7",
-  tick: "\u2714"
-};
-var ASCII = {
-  running: "*",
-  ready: "*",
-  starting: "o",
-  stopped: "#",
-  failed: "X",
-  queued: ".",
-  branch: "|-",
-  lastBranch: "`-",
-  pipe: "|",
-  pointer: ">",
-  restart: "r",
-  rule: "-",
-  dot: ".",
-  tick: "v"
-};
-var glyphs = (env = process.env) => asciiOnly(env) ? ASCII : UNICODE;
-var STATE_STYLE = {
-  queued: { glyph: "queued", color: "gray", label: "QUEUED" },
-  starting: { glyph: "starting", color: "yellow", label: "STARTING" },
-  ready: { glyph: "ready", color: "cyan", label: "READY" },
-  running: { glyph: "running", color: "green", label: "RUNNING" },
-  stopping: { glyph: "starting", color: "yellow", label: "STOPPING" },
-  stopped: { glyph: "stopped", color: "gray", label: "STOPPED" },
-  crashed: { glyph: "failed", color: "red", label: "CRASHED" },
-  backoff: { glyph: "starting", color: "yellow", label: "RESTARTING" },
-  failed: { glyph: "failed", color: "red", label: "FAILED" }
-};
-var formatUptime = (ms) => {
-  if (ms === void 0 || ms < 0) return "--:--:--";
-  const total = Math.floor(ms / 1e3);
-  const hours = Math.floor(total / 3600);
-  const minutes = Math.floor(total % 3600 / 60);
-  const seconds = total % 60;
-  return [hours, minutes, seconds].map((part) => String(part).padStart(2, "0")).join(":");
-};
-var formatDuration = (ms) => {
-  if (ms === void 0 || ms < 0) return "\u2014";
-  const total = Math.floor(ms / 1e3);
-  if (total < 60) return `${total}s`;
-  const minutes = Math.floor(total / 60);
-  const seconds = total % 60;
-  if (minutes < 60) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
-  const hours = Math.floor(minutes / 60);
-  return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
-};
-var formatClock = (at) => {
-  const date = new Date(at);
-  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((part) => String(part).padStart(2, "0")).join(":");
-};
-
 // src/tui/screen.ts
 var initialUiState = () => ({
   view: "overview",
@@ -2096,8 +2140,8 @@ var processLine = (row, isSelected, isLast, nameWidth, { paint: paint2, glyph, s
 var dependencyLine = (row, nameWidth, { paint: paint2, glyph, size }) => {
   const style = STATE_STYLE[row.state];
   const label = row.state === "ready" || row.state === "running" ? "ready" : style.label.toLowerCase();
-  const color = row.state === "ready" || row.state === "running" ? "green" : style.color;
-  const line = `      ${paint2(color, glyph[style.glyph])} ${pad(row.name, nameWidth)}${paint2(color, pad(label, 11))}${paint2("gray", row.probe ?? "")}`;
+  const color2 = row.state === "ready" || row.state === "running" ? "green" : style.color;
+  const line = `      ${paint2(color2, glyph[style.glyph])} ${pad(row.name, nameWidth)}${paint2(color2, pad(label, 11))}${paint2("gray", row.probe ?? "")}`;
   return truncate(line, size.columns + (line.length - stripAnsi(line).length));
 };
 var dependencies = (input, nameWidth) => {
@@ -2355,7 +2399,7 @@ var runTui = async (supervisor, bus, options = {}) => {
   });
   const basePainter = createPainter(supportsColor(stdout, env));
   const paint2 = Object.assign(
-    (color, text) => basePainter(color, text),
+    (color2, text) => basePainter(color2, text),
     { enabled: basePainter.enabled }
   );
   const glyph = glyphs(env);
@@ -2523,6 +2567,7 @@ var shouldUseTui = (options, stdout = process.stdout) => !options.plain && !opti
 var upCommand = async (name, options = {}) => {
   const stack = prepareStack(name, options);
   const bus = new EventBus();
+  const mark = marks(options.env);
   if (shouldUseTui(options)) {
     const supervisor2 = new Supervisor(stack, bus, options.env ? { env: options.env } : {});
     return runTui(supervisor2, bus, options.env ? { env: options.env } : {});
@@ -2538,7 +2583,8 @@ var upCommand = async (name, options = {}) => {
   };
   const onSignal = (signal) => {
     if (stopping) {
-      console.error(paint("red", "\nforced exit \u2014 some children may survive"));
+      console.error(`
+${mark.fail} ${color.red.bold("forced exit \u2014 some children may survive")}`);
       process.exit(130);
     }
     void shutdown(`received ${signal}`);
@@ -2552,7 +2598,7 @@ var upCommand = async (name, options = {}) => {
     await supervisor.up();
     await waitUntilIdle(supervisor, () => stopping);
   } catch (error) {
-    console.error(paint("red", error instanceof Error ? error.message : String(error)));
+    console.error(`${mark.fail} ${color.red(error instanceof Error ? error.message : String(error))}`);
     exitCode = 1;
   } finally {
     await shutdown("done");
@@ -2868,27 +2914,577 @@ var runDoctor = async (stackName, env = process.env) => {
 };
 var doctorCommand = async (stackName, env = process.env) => {
   const findings = await runDoctor(stackName, env);
-  const glyph = { ok: paint("green", "\u2714"), warn: paint("yellow", "\u25B2"), error: paint("red", "\u2716") };
+  const mark = marks(env);
+  console.log(`${color.bold("doctor")} ${color.gray(glyphs(env).dot)} ${color.cyan.bold(stackName)}
+`);
+  const lead = { ok: mark.ok, warn: mark.warn, error: mark.fail };
+  const tone = { ok: (text) => text, warn: color.yellow, error: color.red };
   for (const finding of findings) {
-    console.log(`${glyph[finding.level]} ${finding.message}`);
-    if (finding.hint) console.log(`  ${paint("gray", finding.hint)}`);
+    console.log(`${lead[finding.level]} ${tone[finding.level](finding.message)}`);
+    if (finding.hint) console.log(`  ${color.gray(finding.hint)}`);
   }
   const errors = findings.filter((finding) => finding.level === "error").length;
   const warnings = findings.filter((finding) => finding.level === "warn").length;
+  const count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+  const tail = warnings > 0 ? color.yellow(`, ${count(warnings, "warning")}`) : "";
   console.log(
-    `
-${errors === 0 ? paint("green", "no blocking problems") : paint("red", `${errors} problem(s)`)}` + (warnings > 0 ? paint("yellow", `, ${warnings} warning(s)`) : "")
+    errors === 0 ? `
+${mark.ok} ${color.green.bold("no blocking problems")}${tail}` : `
+${mark.fail} ${color.red.bold(count(errors, "problem"))}${tail}`
   );
   return errors > 0 ? 1 : 0;
 };
 
-// src/cli/commands/init.ts
-import { mkdirSync as mkdirSync2, writeFileSync, existsSync as existsSync5 } from "fs";
-import path8 from "path";
+// src/cli/commands/draft.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync3, realpathSync, writeFileSync as writeFileSync2 } from "fs";
+import path9 from "path";
+import { isMap, isSeq, parseDocument } from "yaml";
 
-// src/cli/commands/templates.ts
-var CONFIG_YAML = `# laracrew global preferences
-# theme: auto | dark | light | mono | high-contrast
+// src/cli/commands/link.ts
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, unlinkSync, writeFileSync } from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
+var IS_WINDOWS3 = process.platform === "win32";
+var MARKER = "laracrew-generated";
+var RESERVED = /* @__PURE__ */ new Set(["laracrew", "node", "npm", "npx", "php", "git", "cd", "ls", "rm", "sh", "bash"]);
+var VALID_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+var entryScript = (argv = process.argv) => {
+  const main = argv[1];
+  if (!main) return fileURLToPath(import.meta.url);
+  const resolved = path8.resolve(main);
+  if (!resolved.endsWith(".ts")) return resolved;
+  const dist = path8.join(path8.dirname(path8.dirname(resolved)), "dist", "index.js");
+  if (existsSync5(dist)) return dist;
+  throw new ConfigError("run `npm run build` first \u2014 a generated command has to point at dist/index.js");
+};
+var currentTarget = (stack) => ({
+  node: process.execPath,
+  entry: entryScript(),
+  stack
+});
+var forward = (value) => value.replace(/\\/g, "/");
+var shShim = ({ node, entry, stack }) => `#!/bin/sh
+# ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.
+exec "${forward(node)}" "${forward(entry)}" up ${stack} "$@"
+`;
+var cmdShim = ({ node, entry, stack }) => `@ECHO OFF\r
+REM ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.\r
+"${node}" "${entry}" up ${stack} %*\r
+`;
+var ps1Shim = ({ node, entry, stack }) => `#!/usr/bin/env pwsh
+# ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.
+& "${node}" "${entry}" up ${stack} @args
+exit $LASTEXITCODE
+`;
+var shimFiles = (name, target) => {
+  const posix = { file: name, contents: shShim(target), exec: true };
+  if (!IS_WINDOWS3) return [posix];
+  return [
+    posix,
+    // Git Bash reads the extensionless file
+    { file: `${name}.cmd`, contents: cmdShim(target), exec: false },
+    { file: `${name}.ps1`, contents: ps1Shim(target), exec: true }
+  ];
+};
+var pathDirs = (env) => (env.PATH ?? env.Path ?? "").split(path8.delimiter).filter(Boolean);
+var samePath = (a, b) => IS_WINDOWS3 ? a.toLowerCase() === b.toLowerCase() : a === b;
+var ownBinDir = (env) => {
+  for (const dir of pathDirs(env)) {
+    for (const candidate of IS_WINDOWS3 ? ["laracrew.cmd", "laracrew"] : ["laracrew"]) {
+      try {
+        if (existsSync5(path8.join(dir, candidate))) return dir;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+};
+var resolveBinDir = (env = process.env) => {
+  if (env.LARACREW_BIN) return { dir: path8.resolve(env.LARACREW_BIN), onPath: true };
+  const own = ownBinDir(env);
+  if (own) return { dir: own, onPath: true };
+  const conventional = IS_WINDOWS3 ? env.APPDATA ? path8.join(env.APPDATA, "npm") : void 0 : path8.dirname(process.execPath);
+  if (conventional && existsSync5(conventional) && pathDirs(env).some((dir) => samePath(dir, conventional))) {
+    return { dir: conventional, onPath: true };
+  }
+  return { dir: path8.join(paths(env).root, "bin"), onPath: false };
+};
+var isOurs = (file) => {
+  try {
+    return readFileSync3(file, "utf8").includes(MARKER);
+  } catch {
+    return false;
+  }
+};
+var linkStack = (stackName, options = {}) => {
+  const env = options.env ?? process.env;
+  const { config } = loadStack(stackName, env);
+  const name = options.as ?? config.command ?? stackName;
+  if (!VALID_NAME.test(name)) {
+    throw new ConfigError(
+      `"${name}" is not a usable command name \u2014 letters, digits, dot, dash and underscore only`
+    );
+  }
+  if (RESERVED.has(name.toLowerCase()) && !options.force) {
+    throw new ConfigError(`"${name}" would shadow an important command`, {
+      details: ["pick another with `--as <name>`, or pass --force if you really mean it"]
+    });
+  }
+  const resolved = options.dir ? { dir: path8.resolve(options.dir), onPath: true } : resolveBinDir(env);
+  mkdirSync2(resolved.dir, { recursive: true });
+  const target = currentTarget(stackName);
+  const planned = shimFiles(name, target);
+  let replaced = false;
+  for (const { file } of planned) {
+    const full = path8.join(resolved.dir, file);
+    if (!existsSync5(full)) continue;
+    if (isOurs(full)) {
+      replaced = true;
+      continue;
+    }
+    if (!options.force) {
+      throw new ConfigError(`"${full}" already exists and was not created by laracrew`, {
+        details: ["choose another name with `--as <name>`, or pass --force to overwrite"]
+      });
+    }
+    replaced = true;
+  }
+  const written = [];
+  for (const { file, contents, exec } of planned) {
+    const full = path8.join(resolved.dir, file);
+    writeFileSync(full, contents, "utf8");
+    if (exec && !IS_WINDOWS3) chmodSync(full, 493);
+    else if (exec) {
+      try {
+        chmodSync(full, 493);
+      } catch {
+      }
+    }
+    written.push(full);
+  }
+  return { name, stack: stackName, dir: resolved.dir, onPath: resolved.onPath, files: written, replaced };
+};
+var unlinkCommandName = (name, options = {}) => {
+  const env = options.env ?? process.env;
+  const dir = options.dir ? path8.resolve(options.dir) : resolveBinDir(env).dir;
+  const removed = [];
+  for (const candidate of [name, `${name}.cmd`, `${name}.ps1`]) {
+    const full = path8.join(dir, candidate);
+    if (!existsSync5(full)) continue;
+    if (!isOurs(full)) {
+      throw new ConfigError(`"${full}" was not created by laracrew \u2014 leaving it alone`);
+    }
+    unlinkSync(full);
+    removed.push(full);
+  }
+  if (removed.length === 0) throw new ConfigError(`no laracrew command named "${name}" in ${dir}`);
+  return removed;
+};
+var listLinks = (options = {}) => {
+  const env = options.env ?? process.env;
+  const dir = options.dir ? path8.resolve(options.dir) : resolveBinDir(env).dir;
+  if (!existsSync5(dir)) return [];
+  const found = [];
+  for (const entry of readdirSync2(dir).sort()) {
+    if (entry.endsWith(".cmd") || entry.endsWith(".ps1")) continue;
+    const full = path8.join(dir, entry);
+    let contents;
+    try {
+      contents = readFileSync3(full, "utf8");
+    } catch {
+      continue;
+    }
+    if (!contents.includes(MARKER)) continue;
+    const stack = /\bup ([^\s"]+)/.exec(contents)?.[1];
+    if (stack) found.push({ name: entry, stack, file: full });
+  }
+  return found;
+};
+var linkCommand = (stackName, options, env = process.env) => {
+  const stacks = options.all ? listStacks(env) : stackName ? [stackName] : [];
+  if (stacks.length === 0) {
+    throw new ConfigError("name a stack to link, or pass --all");
+  }
+  const results = [];
+  for (const stack of stacks) {
+    if (options.all) {
+      const { config } = loadStack(stack, env);
+      if (!config.command) continue;
+    }
+    results.push(
+      linkStack(stack, {
+        ...options.as ? { as: options.as } : {},
+        ...options.dir ? { dir: options.dir } : {},
+        ...options.force ? { force: options.force } : {},
+        env
+      })
+    );
+  }
+  const mark = marks(env);
+  if (results.length === 0) {
+    console.log(
+      `${mark.warn} ${color.yellow("nothing to link \u2014 add `command: <name>` to the stacks you want a command for")}`
+    );
+    return 0;
+  }
+  for (const result of results) {
+    const verb = result.replaced ? "updated" : "created";
+    console.log(
+      `${mark.ok} ${color.green(verb)} ${color.bold(result.name)} ${mark.arrow} ${color.gray(`laracrew up ${result.stack}`)}`
+    );
+  }
+  const first = results[0];
+  console.log(`
+${color.gray(`in ${first.dir}`)}`);
+  if (!first.onPath) {
+    console.log(
+      `
+${mark.warn} ${color.yellow("that directory is not on your PATH.")} Add it once:
+` + (IS_WINDOWS3 ? `  ${color.cyan(`setx PATH "%PATH%;${first.dir}"`)}   ${color.gray("(then reopen the terminal)")}` : `  ${color.cyan(`echo 'export PATH="$PATH:${first.dir}"' >> ~/.bashrc`)}`)
+    );
+  } else {
+    console.log(`
+Run it from anywhere:  ${color.cyan.bold(first.name)}`);
+    console.log(color.gray(`Flags pass straight through:  ${first.name} --only workers`));
+  }
+  return 0;
+};
+var unlinkCommandAction = (name, env = process.env) => {
+  const removed = unlinkCommandName(name, { env });
+  const mark = marks(env);
+  for (const file of removed) console.log(`${mark.ok} removed ${color.gray(file)}`);
+  return 0;
+};
+
+// src/cli/commands/draft.ts
+var SUFFIX = ".laracrew.yaml";
+var DRAFT_FILE = /^(.+)\.laracrew\.ya?ml$/i;
+var NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+var SERVICE_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/;
+var RUNNERS = /* @__PURE__ */ new Set(["node", "npm", "npx", "yarn", "pnpm", "bun", "deno", "python", "python3", "php", "run", "exec", "poetry"]);
+var forward2 = (value) => value.replace(/\\/g, "/");
+var canonical = (value) => {
+  try {
+    return realpathSync.native(value);
+  } catch {
+    return path9.resolve(value);
+  }
+};
+var samePath2 = (a, b) => {
+  const [x, y] = [canonical(a), canonical(b)];
+  return process.platform === "win32" ? x.toLowerCase() === y.toLowerCase() : x === y;
+};
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var draftFile = (name, cwd = process.cwd()) => path9.join(cwd, `${name}${SUFFIX}`);
+var listDrafts = (cwd = process.cwd()) => readdirSync3(cwd).map((entry) => ({ entry, match: DRAFT_FILE.exec(entry) })).filter((item) => item.match !== null).map(({ entry, match }) => ({ name: match[1], file: path9.join(cwd, entry) })).sort((a, b) => a.name.localeCompare(b.name));
+var resolveDraft = (cwd = process.cwd(), name, pick = "--draft <name>") => {
+  if (name) {
+    const file = draftFile(name, cwd);
+    if (!existsSync6(file)) {
+      throw new ConfigError(`no draft named "${name}" in ${cwd}`, { details: ["start one with `laracrew draft <name>`"] });
+    }
+    return { name, file };
+  }
+  const drafts = listDrafts(cwd);
+  if (drafts.length === 1) return drafts[0];
+  if (drafts.length === 0) {
+    throw new ConfigError(`no draft in ${cwd}`, { details: ["start one with `laracrew draft <name>`"] });
+  }
+  throw new ConfigError(`several drafts here: ${drafts.map((draft) => draft.name).join(", ")} \u2014 pick one with ${pick}`);
+};
+var template = (name) => `# Built with \`laracrew draft\`. Add services with \`laracrew draft add\`, install the stack with
+# \`laracrew draft publish\`, or edit by hand \u2014 this is an ordinary stack.yaml.
+#
+#   laracrew draft add --project api --path C:/work/api --command "php artisan queue:work"
+#   laracrew draft add --project api --command "php artisan schedule:work"
+#   laracrew draft add --command "npm run dev" --default-state stopped
+name: ${name}
+command: ${name} # \`laracrew link ${name}\` installs this as a global command
+projects: {}
+services: []
+`;
+var createDraft = (name, options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  if (!NAME.test(name)) {
+    throw new ConfigError(`"${name}" is not a usable stack name \u2014 letters, digits, dot, dash and underscore only`);
+  }
+  if (name === "add" || name === "publish") {
+    throw new ConfigError(`"${name}" would clash with \`laracrew draft ${name}\` \u2014 pick another name`);
+  }
+  const file = draftFile(name, cwd);
+  if (existsSync6(file) && !options.force) {
+    throw new ConfigError(`${path9.basename(file)} already exists here`, {
+      details: ["add to it with `laracrew draft add`, or pass --force to start over"]
+    });
+  }
+  writeFileSync2(file, template(name), "utf8");
+  return file;
+};
+var readDraft = (file) => {
+  const doc = parseDocument(readFileSync4(file, "utf8"), { prettyErrors: true });
+  const [problem] = doc.errors;
+  if (problem) throw new ConfigError(`invalid YAML: ${problem.message}`, { file });
+  if (!isMap(doc.contents)) throw new ConfigError("the draft should be a YAML mapping (name:, services: \u2026)", { file });
+  return doc;
+};
+var mapAt = (doc, key, file) => {
+  let node = doc.get(key);
+  if (node === void 0 || node === null) {
+    node = doc.createNode({});
+    doc.set(key, node);
+  }
+  if (!isMap(node)) throw new ConfigError(`\`${key}:\` should be a map`, { file });
+  return node;
+};
+var seqAt = (doc, key, file) => {
+  let node = doc.get(key);
+  if (node === void 0 || node === null) {
+    node = doc.createNode([]);
+    doc.set(key, node);
+  }
+  if (!isSeq(node)) throw new ConfigError(`\`${key}:\` should be a list`, { file });
+  return node;
+};
+var deriveServiceName = (command, project) => {
+  const artisan = /\bartisan\s+([A-Za-z0-9:_.-]+)/.exec(command);
+  let verb = artisan?.[1];
+  if (!verb) {
+    const words = command.trim().split(/\s+/).filter((word2) => word2 && !word2.startsWith("-")).map((word2) => word2.split(/[\\/]/).pop() ?? word2);
+    const word = words.find((candidate) => !RUNNERS.has(candidate.toLowerCase())) ?? words[0] ?? "service";
+    verb = word.replace(/\.[A-Za-z0-9]+$/, "");
+  }
+  const clean = verb.toLowerCase().replace(/[^a-z0-9:_.-]+/g, "-").replace(/^[-.:]+|[-.:]+$/g, "") || "service";
+  return project ? `${project}:${clean}` : clean;
+};
+var uniqueName = (base, taken) => {
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n += 1) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+};
+var parseState = (value) => {
+  if (value === void 0 || value === "running") return true;
+  if (value === "stopped") return false;
+  throw new ConfigError(`--default-state is "running" or "stopped", not "${value}"`);
+};
+var addToDraft = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const command = options.command.trim();
+  if (!command) throw new ConfigError('--command needs something to run, e.g. "php artisan queue:work"');
+  const autostart = parseState(options.state);
+  if (options.project !== void 0 && !NAME.test(options.project)) {
+    throw new ConfigError(`"${options.project}" is not a usable project key \u2014 letters, digits, dot, dash and underscore only`);
+  }
+  const { name: draftName, file } = resolveDraft(cwd, options.draft);
+  const doc = readDraft(file);
+  let project;
+  if (options.project) {
+    const projects = mapAt(doc, "projects", file);
+    const wanted = options.path ? forward2(path9.resolve(cwd, options.path)) : void 0;
+    const existing = projects.get(options.project);
+    if (existing !== void 0 && existing !== null) {
+      const current = isMap(existing) ? String(existing.get("path") ?? "") : "";
+      if (wanted && !samePath2(current, wanted)) {
+        throw new ConfigError(`project "${options.project}" already points at ${current}`, {
+          file,
+          details: ["a draft keeps one path per project \u2014 leave --path off to reuse it, or pick another key"]
+        });
+      }
+      project = { key: options.project, path: current, created: false };
+    } else {
+      const dir = wanted ?? forward2(cwd);
+      projects.set(options.project, doc.createNode({ path: dir }));
+      projects.flow = false;
+      project = { key: options.project, path: dir, created: true };
+    }
+  }
+  const services = seqAt(doc, "services", file);
+  const taken = new Set(services.items.map((item) => isMap(item) ? String(item.get("name") ?? "") : ""));
+  let name;
+  if (options.name) {
+    if (!SERVICE_NAME.test(options.name)) {
+      throw new ConfigError(`"${options.name}" is not a usable service name \u2014 letters, digits, colon, dot, dash and underscore only`);
+    }
+    if (taken.has(options.name)) throw new ConfigError(`a service named "${options.name}" is already in the draft`, { file });
+    name = options.name;
+  } else {
+    name = uniqueName(deriveServiceName(command, options.project), taken);
+  }
+  const service = { name };
+  if (options.project) service.project = options.project;
+  service.cmd = command;
+  const serviceCwd = options.project ? void 0 : forward2(path9.resolve(cwd, options.path ?? "."));
+  if (serviceCwd) service.cwd = serviceCwd;
+  if (!autostart) service.autostart = false;
+  services.add(doc.createNode(service));
+  services.flow = false;
+  writeFileSync2(file, doc.toString(), "utf8");
+  return {
+    draft: draftName,
+    file,
+    service: { name, cmd: command, autostart, ...serviceCwd ? { cwd: serviceCwd } : {} },
+    ...project ? { project } : {},
+    services: services.items.length
+  };
+};
+var describeDraft = (cwd = process.cwd(), name) => {
+  const ref = resolveDraft(cwd, name, "laracrew draft <name>");
+  const raw = parseYaml(readFileSync4(ref.file, "utf8"), ref.file);
+  const record = isRecord2(raw) ? raw : {};
+  const stackName = typeof record.name === "string" ? record.name : ref.name;
+  const projects = isRecord2(record.projects) ? Object.entries(record.projects).map(([key, value]) => ({
+    key,
+    path: isRecord2(value) && typeof value.path === "string" ? value.path : ""
+  })) : [];
+  const services = Array.isArray(record.services) ? record.services.filter(isRecord2).map((entry) => ({
+    name: typeof entry.name === "string" ? entry.name : "?",
+    cmd: Array.isArray(entry.cmd) ? entry.cmd.map(String).join(" ") : typeof entry.cmd === "string" ? entry.cmd : "",
+    ...typeof entry.project === "string" ? { project: entry.project } : {},
+    autostart: entry.autostart !== false
+  })) : [];
+  return {
+    name: ref.name,
+    file: ref.file,
+    stackName,
+    command: typeof record.command === "string" ? record.command : stackName,
+    projects,
+    services
+  };
+};
+var publishDraft = (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const { name: draftName, file } = resolveDraft(cwd, options.draft);
+  const source = readFileSync4(file, "utf8");
+  const raw = parseYaml(source, file);
+  if (isRecord2(raw) && Array.isArray(raw.services) && raw.services.length === 0) {
+    throw new ConfigError("the draft has no services yet", {
+      file,
+      details: ['add one with `laracrew draft add --command "\u2026"`']
+    });
+  }
+  const config = validateStack(raw, file);
+  const target = stackFile(config.name, env);
+  const replaced = existsSync6(target);
+  if (replaced && !options.force) {
+    throw new ConfigError(`a stack named "${config.name}" already exists`, {
+      file: target,
+      details: ["pass --force to replace it, or change `name:` in the draft"]
+    });
+  }
+  mkdirSync3(stackDir(config.name, env), { recursive: true });
+  writeFileSync2(target, source, "utf8");
+  return { name: config.name, draft: draftName, file, target, replaced, config };
+};
+var plural = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+var draftCommand = (name, options = {}, cwd = process.cwd(), env = process.env) => {
+  const mark = marks(env);
+  if (name && (options.force || !existsSync6(draftFile(name, cwd)))) {
+    const file = createDraft(name, { cwd, ...options.force ? { force: true } : {} });
+    console.log(`${mark.ok} started draft ${color.bold(name)} ${mark.arrow} ${color.gray(path9.basename(file))}`);
+    console.log(
+      `
+${nextSteps(
+        [
+          ["laracrew draft add", `--project api --path C:/work/api --command ${color.green('"php artisan queue:work"')}`],
+          ["", `--project api --command ${color.green('"php artisan schedule:work"')}   ${color.gray("the path is remembered")}`],
+          ["", `--command ${color.green('"npm run dev"')} --default-state stopped   ${color.gray("idle until you press s")}`],
+          ["laracrew draft", "show what the draft holds so far"],
+          ["laracrew draft publish", `install it as the ${color.cyan(name)} stack in ~/.laracrew`]
+        ],
+        env
+      )}
+`
+    );
+    return 0;
+  }
+  const draft = describeDraft(cwd, name);
+  console.log(`${color.bold("draft")} ${color.gray("\xB7")} ${color.cyan.bold(draft.stackName)} ${color.gray(path9.basename(draft.file))}`);
+  if (draft.command !== draft.stackName) console.log(`  ${color.gray(`command: ${draft.command}`)}`);
+  console.log(`
+${color.bold("PROJECTS")} ${color.gray(`(${draft.projects.length})`)}`);
+  if (draft.projects.length === 0) console.log(color.gray("  none \u2014 `--project <key> --path <dir>` on the next add"));
+  const keyWidth = Math.max(4, ...draft.projects.map((project) => project.key.length));
+  for (const project of draft.projects) {
+    console.log(`  ${color.magenta.bold(padEnd(project.key, keyWidth))}  ${project.path}`);
+  }
+  console.log(`
+${color.bold("SERVICES")} ${color.gray(`(${draft.services.length})`)}`);
+  if (draft.services.length === 0) console.log(color.gray('  none yet \u2014 `laracrew draft add --command "\u2026"`'));
+  const nameWidth = Math.max(4, ...draft.services.map((service) => service.name.length));
+  for (const service of draft.services) {
+    const idle = service.autostart ? "" : `  ${color.yellow("idle until started")}`;
+    console.log(`  ${color.cyan.bold(padEnd(service.name, nameWidth))}  ${service.cmd}${idle}`);
+  }
+  console.log(
+    `
+${nextSteps(
+      [
+        ["laracrew draft add", `--command ${color.green('"\u2026"')} to add another`],
+        ["laracrew draft publish", `install it as the ${color.cyan(draft.stackName)} stack`]
+      ],
+      env
+    )}
+`
+  );
+  return 0;
+};
+var draftAddCommand = (options, cwd = process.cwd(), env = process.env) => {
+  const result = addToDraft({ ...options, cwd });
+  const mark = marks(env);
+  const idle = result.service.autostart ? "" : `  ${color.yellow("idle until started")}`;
+  console.log(`${mark.ok} added ${color.bold(result.service.name)} ${mark.arrow} ${color.gray(result.service.cmd)}${idle}`);
+  if (result.project?.created) {
+    const guessed = options.path ? "" : `  ${color.yellow("this folder \u2014 pass --path if that is wrong")}`;
+    console.log(`  ${mark.ok} project ${color.magenta.bold(result.project.key)} ${mark.arrow} ${color.gray(result.project.path)}${guessed}`);
+  }
+  if (result.service.cwd) console.log(`  ${color.gray(`runs in ${result.service.cwd}`)}`);
+  console.log(
+    `  ${color.gray(`${plural(result.services, "service")} in ${path9.basename(result.file)} \u2014 \`laracrew draft publish\` when done`)}`
+  );
+  return 0;
+};
+var draftPublishCommand = (options = {}, cwd = process.cwd(), env = process.env) => {
+  const result = publishDraft({
+    cwd,
+    env,
+    ...options.draft ? { draft: options.draft } : {},
+    ...options.force ? { force: true } : {}
+  });
+  const mark = marks(env);
+  const command = result.config.command ?? result.name;
+  console.log(
+    `${mark.ok} ${color.green(result.replaced ? "replaced" : "published")} ${color.bold(result.name)} ${mark.arrow} ${color.gray(result.target)}`
+  );
+  console.log(
+    `  ${color.gray(
+      `${plural(Object.keys(result.config.projects).length, "project")}, ${plural(result.config.services.length, "service")}; the draft stays at ${path9.basename(result.file)}`
+    )}`
+  );
+  if (options.link) {
+    console.log("");
+    const code = linkCommand(result.name, {}, env);
+    if (code !== 0) return code;
+  }
+  const steps = [
+    [`laracrew doctor ${result.name}`, "check paths, ports and PHP before the first boot"],
+    [`laracrew up ${result.name}`, "boot it"]
+  ];
+  if (!options.link) steps.push([`laracrew link ${result.name}`, `type ${color.cyan(command)} from anywhere to boot it`]);
+  console.log(`
+${nextSteps(steps, env)}
+`);
+  return 0;
+};
+
+// src/cli/commands/init.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
+import path10 from "path";
+
+// src/cli/commands/templates.ts
+var CONFIG_YAML = `# laracrew global preferences
+# theme: auto | dark | light | mono | high-contrast
 theme: auto
 
 # Polling interval for queue depth and stream lag, in milliseconds.
@@ -3068,6 +3664,7 @@ secrets in it.
 Start here:
 
     laracrew init --examples   # add a demo stack and a two-project template
+    laracrew draft <name>      # build a stack in a project folder, one command at a time
     laracrew ls                # what is defined
     laracrew doctor <stack>    # check a stack before booting it
     laracrew link <stack>      # give a stack its own global command
@@ -3079,278 +3676,65 @@ var runInit = (env = process.env, options = {}) => {
   const created = [];
   const skipped = [];
   for (const dir of [home2.root, home2.stacksDir, home2.tasksDir, home2.fragmentsDir, home2.logsDir, home2.runDir]) {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync4(dir, { recursive: true });
   }
   const files = [
     [home2.configFile, CONFIG_YAML],
     [home2.projectsFile, PROJECTS_YAML],
-    [path8.join(home2.root, "README.md"), HOME_README]
+    [path10.join(home2.root, "README.md"), HOME_README]
   ];
   if (options.examples) {
-    mkdirSync2(path8.join(home2.stacksDir, "example"), { recursive: true });
-    mkdirSync2(path8.join(home2.stacksDir, "dual"), { recursive: true });
+    mkdirSync4(path10.join(home2.stacksDir, "example"), { recursive: true });
+    mkdirSync4(path10.join(home2.stacksDir, "dual"), { recursive: true });
     files.push(
-      [path8.join(home2.stacksDir, "example", "stack.yaml"), EXAMPLE_STACK_YAML],
-      [path8.join(home2.stacksDir, "dual", "stack.yaml"), REAL_STACK_TEMPLATE],
-      [path8.join(home2.tasksDir, "reset.yaml"), RESET_TASK_YAML]
+      [path10.join(home2.stacksDir, "example", "stack.yaml"), EXAMPLE_STACK_YAML],
+      [path10.join(home2.stacksDir, "dual", "stack.yaml"), REAL_STACK_TEMPLATE],
+      [path10.join(home2.tasksDir, "reset.yaml"), RESET_TASK_YAML]
     );
   }
   for (const [file, contents] of files) {
-    if (existsSync5(file)) {
+    if (existsSync7(file)) {
       skipped.push(file);
       continue;
     }
-    writeFileSync(file, contents, "utf8");
+    writeFileSync3(file, contents, "utf8");
     created.push(file);
   }
   return { root: home2.root, created, skipped, examples: options.examples ?? false };
 };
 var initCommand = (options = {}, env = process.env) => {
   const result = runInit(env, options);
-  console.log(`${paint("bold", "laracrew")} home: ${result.root}`);
-  for (const file of result.created) console.log(`  ${paint("green", "+")} ${path8.relative(result.root, file)}`);
+  const mark = marks(env);
+  console.log(`${color.bold("laracrew home")} ${color.gray(result.root)}`);
+  for (const file of result.created) console.log(`  ${mark.ok} ${path10.relative(result.root, file)}`);
   for (const file of result.skipped) {
-    console.log(`  ${paint("gray", "\xB7")} ${path8.relative(result.root, file)} ${paint("gray", "(kept)")}`);
-  }
-  if (result.examples) {
-    console.log(`
-${paint("bold", "Next:")}
-  ${paint("cyan", "laracrew up example")}      run the demo stack \u2014 proves it works, no Laravel needed
-  ${paint("cyan", "laracrew link example")}    install it as a global command you can type from anywhere
-  edit ${paint("gray", path8.join(result.root, "projects.yaml"))} with your project paths,
-  then ${paint("cyan", "laracrew doctor dual")} and ${paint("cyan", "laracrew up dual")}
-`);
-    return;
-  }
+    console.log(`  ${mark.skip} ${color.gray(`${path10.relative(result.root, file)} (kept)`)}`);
+  }
+  const steps = result.examples ? [
+    ["laracrew up example", "run the demo stack \u2014 proves it works, no Laravel needed"],
+    ["laracrew link example", "install it as a global command you can type from anywhere"],
+    ["laracrew doctor dual", `check the real stack once ${color.gray(path10.join(result.root, "projects.yaml"))}`],
+    ["", `has your project paths, then ${color.cyan("laracrew up dual")}`]
+  ] : [
+    ["laracrew init --examples", "add a runnable demo stack and a two-project template,"],
+    ["", `or write your own at ${color.gray(path10.join(result.root, "stacks", "<name>", "stack.yaml"))}`],
+    ["laracrew draft <name>", "or build one in a project folder, one command at a time"],
+    ["laracrew up <name>", `boot it \u2014 ${color.cyan("laracrew ls")} shows what is defined`]
+  ];
   console.log(`
-${paint("bold", "Next:")}
-  ${paint("cyan", "laracrew init --examples")}   add a runnable demo stack and a two-project template
-  or write your own at ${paint("gray", path8.join(result.root, "stacks", "<name>", "stack.yaml"))}
-  then ${paint("cyan", "laracrew ls")} and ${paint("cyan", "laracrew up <name>")}
+${nextSteps(steps, env)}
 `);
 };
 
-// src/cli/commands/link.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import path9 from "path";
-import { fileURLToPath } from "url";
-var IS_WINDOWS3 = process.platform === "win32";
-var MARKER = "laracrew-generated";
-var RESERVED = /* @__PURE__ */ new Set(["laracrew", "node", "npm", "npx", "php", "git", "cd", "ls", "rm", "sh", "bash"]);
-var VALID_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
-var entryScript = (argv = process.argv) => {
-  const main = argv[1];
-  if (!main) return fileURLToPath(import.meta.url);
-  const resolved = path9.resolve(main);
-  if (!resolved.endsWith(".ts")) return resolved;
-  const dist = path9.join(path9.dirname(path9.dirname(resolved)), "dist", "index.js");
-  if (existsSync6(dist)) return dist;
-  throw new ConfigError("run `npm run build` first \u2014 a generated command has to point at dist/index.js");
-};
-var currentTarget = (stack) => ({
-  node: process.execPath,
-  entry: entryScript(),
-  stack
-});
-var forward = (value) => value.replace(/\\/g, "/");
-var shShim = ({ node, entry, stack }) => `#!/bin/sh
-# ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.
-exec "${forward(node)}" "${forward(entry)}" up ${stack} "$@"
-`;
-var cmdShim = ({ node, entry, stack }) => `@ECHO OFF\r
-REM ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.\r
-"${node}" "${entry}" up ${stack} %*\r
-`;
-var ps1Shim = ({ node, entry, stack }) => `#!/usr/bin/env pwsh
-# ${MARKER}: boots the "${stack}" stack. Regenerate with \`laracrew link ${stack}\`.
-& "${node}" "${entry}" up ${stack} @args
-exit $LASTEXITCODE
-`;
-var shimFiles = (name, target) => {
-  const posix = { file: name, contents: shShim(target), exec: true };
-  if (!IS_WINDOWS3) return [posix];
-  return [
-    posix,
-    // Git Bash reads the extensionless file
-    { file: `${name}.cmd`, contents: cmdShim(target), exec: false },
-    { file: `${name}.ps1`, contents: ps1Shim(target), exec: true }
-  ];
-};
-var pathDirs = (env) => (env.PATH ?? env.Path ?? "").split(path9.delimiter).filter(Boolean);
-var samePath = (a, b) => IS_WINDOWS3 ? a.toLowerCase() === b.toLowerCase() : a === b;
-var ownBinDir = (env) => {
-  for (const dir of pathDirs(env)) {
-    for (const candidate of IS_WINDOWS3 ? ["laracrew.cmd", "laracrew"] : ["laracrew"]) {
-      try {
-        if (existsSync6(path9.join(dir, candidate))) return dir;
-      } catch {
-      }
-    }
-  }
-  return void 0;
-};
-var resolveBinDir = (env = process.env) => {
-  if (env.LARACREW_BIN) return { dir: path9.resolve(env.LARACREW_BIN), onPath: true };
-  const own = ownBinDir(env);
-  if (own) return { dir: own, onPath: true };
-  const conventional = IS_WINDOWS3 ? env.APPDATA ? path9.join(env.APPDATA, "npm") : void 0 : path9.dirname(process.execPath);
-  if (conventional && existsSync6(conventional) && pathDirs(env).some((dir) => samePath(dir, conventional))) {
-    return { dir: conventional, onPath: true };
-  }
-  return { dir: path9.join(paths(env).root, "bin"), onPath: false };
-};
-var isOurs = (file) => {
-  try {
-    return readFileSync3(file, "utf8").includes(MARKER);
-  } catch {
-    return false;
-  }
-};
-var linkStack = (stackName, options = {}) => {
-  const env = options.env ?? process.env;
-  const { config } = loadStack(stackName, env);
-  const name = options.as ?? config.command ?? stackName;
-  if (!VALID_NAME.test(name)) {
-    throw new ConfigError(
-      `"${name}" is not a usable command name \u2014 letters, digits, dot, dash and underscore only`
-    );
-  }
-  if (RESERVED.has(name.toLowerCase()) && !options.force) {
-    throw new ConfigError(`"${name}" would shadow an important command`, {
-      details: ["pick another with `--as <name>`, or pass --force if you really mean it"]
-    });
-  }
-  const resolved = options.dir ? { dir: path9.resolve(options.dir), onPath: true } : resolveBinDir(env);
-  mkdirSync3(resolved.dir, { recursive: true });
-  const target = currentTarget(stackName);
-  const planned = shimFiles(name, target);
-  let replaced = false;
-  for (const { file } of planned) {
-    const full = path9.join(resolved.dir, file);
-    if (!existsSync6(full)) continue;
-    if (isOurs(full)) {
-      replaced = true;
-      continue;
-    }
-    if (!options.force) {
-      throw new ConfigError(`"${full}" already exists and was not created by laracrew`, {
-        details: ["choose another name with `--as <name>`, or pass --force to overwrite"]
-      });
-    }
-    replaced = true;
-  }
-  const written = [];
-  for (const { file, contents, exec } of planned) {
-    const full = path9.join(resolved.dir, file);
-    writeFileSync2(full, contents, "utf8");
-    if (exec && !IS_WINDOWS3) chmodSync(full, 493);
-    else if (exec) {
-      try {
-        chmodSync(full, 493);
-      } catch {
-      }
-    }
-    written.push(full);
-  }
-  return { name, stack: stackName, dir: resolved.dir, onPath: resolved.onPath, files: written, replaced };
-};
-var unlinkCommandName = (name, options = {}) => {
-  const env = options.env ?? process.env;
-  const dir = options.dir ? path9.resolve(options.dir) : resolveBinDir(env).dir;
-  const removed = [];
-  for (const candidate of [name, `${name}.cmd`, `${name}.ps1`]) {
-    const full = path9.join(dir, candidate);
-    if (!existsSync6(full)) continue;
-    if (!isOurs(full)) {
-      throw new ConfigError(`"${full}" was not created by laracrew \u2014 leaving it alone`);
-    }
-    unlinkSync(full);
-    removed.push(full);
-  }
-  if (removed.length === 0) throw new ConfigError(`no laracrew command named "${name}" in ${dir}`);
-  return removed;
-};
-var listLinks = (options = {}) => {
-  const env = options.env ?? process.env;
-  const dir = options.dir ? path9.resolve(options.dir) : resolveBinDir(env).dir;
-  if (!existsSync6(dir)) return [];
-  const found = [];
-  for (const entry of readdirSync2(dir).sort()) {
-    if (entry.endsWith(".cmd") || entry.endsWith(".ps1")) continue;
-    const full = path9.join(dir, entry);
-    let contents;
-    try {
-      contents = readFileSync3(full, "utf8");
-    } catch {
-      continue;
-    }
-    if (!contents.includes(MARKER)) continue;
-    const stack = /\bup ([^\s"]+)/.exec(contents)?.[1];
-    if (stack) found.push({ name: entry, stack, file: full });
-  }
-  return found;
-};
-var linkCommand = (stackName, options, env = process.env) => {
-  const stacks = options.all ? listStacks(env) : stackName ? [stackName] : [];
-  if (stacks.length === 0) {
-    throw new ConfigError("name a stack to link, or pass --all");
-  }
-  const results = [];
-  for (const stack of stacks) {
-    if (options.all) {
-      const { config } = loadStack(stack, env);
-      if (!config.command) continue;
-    }
-    results.push(
-      linkStack(stack, {
-        ...options.as ? { as: options.as } : {},
-        ...options.dir ? { dir: options.dir } : {},
-        ...options.force ? { force: options.force } : {},
-        env
-      })
-    );
-  }
-  if (results.length === 0) {
-    console.log(paint("yellow", "nothing to link \u2014 add `command: <name>` to the stacks you want a command for"));
-    return 0;
-  }
-  for (const result of results) {
-    const verb = result.replaced ? "updated" : "created";
-    console.log(
-      `${paint("green", verb)} ${paint("bold", result.name)} ${paint("gray", `-> laracrew up ${result.stack}`)}`
-    );
-  }
-  const first = results[0];
-  console.log(paint("gray", `
-in ${first.dir}`));
-  if (!first.onPath) {
-    console.log(
-      `
-${paint("yellow", "that directory is not on your PATH.")} Add it once:
-` + (IS_WINDOWS3 ? `  ${paint("cyan", `setx PATH "%PATH%;${first.dir}"`)}   ${paint("gray", "(then reopen the terminal)")}` : `  ${paint("cyan", `echo 'export PATH="$PATH:${first.dir}"' >> ~/.bashrc`)}`)
-    );
-  } else {
-    console.log(`
-Run it from anywhere:  ${paint("cyan", first.name)}`);
-    console.log(paint("gray", `Flags pass straight through:  ${first.name} --only workers`));
-  }
-  return 0;
-};
-var unlinkCommandAction = (name, env = process.env) => {
-  const removed = unlinkCommandName(name, { env });
-  for (const file of removed) console.log(`${paint("red", "removed")} ${file}`);
-  return 0;
-};
-
 // src/cli/commands/logs.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4 } from "fs";
+import path11 from "path";
 
 // src/core/logs/read.ts
-import { openSync as openSync2, readSync, closeSync as closeSync2, statSync as statSync3, existsSync as existsSync7 } from "fs";
+import { openSync as openSync2, readSync, closeSync as closeSync2, statSync as statSync3, existsSync as existsSync8 } from "fs";
 var CHUNK = 64 * 1024;
 var tailFile = (file, limit) => {
-  if (!existsSync7(file) || limit <= 0) return [];
+  if (!existsSync8(file) || limit <= 0) return [];
   const size = statSync3(file).size;
   if (size === 0) return [];
   const handle = openSync2(file, "r");
@@ -3397,10 +3781,10 @@ var parseSince = (input) => {
   return Number.isNaN(absolute) ? void 0 : absolute;
 };
 var followFile = (file, options) => {
-  let position = existsSync7(file) ? statSync3(file).size : 0;
+  let position = existsSync8(file) ? statSync3(file).size : 0;
   let carry = "";
   const read = () => {
-    if (!existsSync7(file)) return;
+    if (!existsSync8(file)) return;
     const size = statSync3(file).size;
     if (size === position) return;
     if (size < position) {
@@ -3429,23 +3813,23 @@ var followFile = (file, options) => {
 };
 
 // src/cli/commands/logs.ts
-var logDirFor = (stackName, env = process.env) => path10.join(paths(env).logsDir, stackName);
+var logDirFor = (stackName, env = process.env) => path11.join(paths(env).logsDir, stackName);
 var targetsFor = (stackName, env = process.env) => {
   const stack = prepareStack(stackName, { env });
   const dir = logDirFor(stackName, env);
   const names = fileNamesFor(stack.services.map((service) => service.name));
   return stack.services.map((service) => ({
     service: service.name,
-    file: path10.join(dir, names.get(service.name)),
+    file: path11.join(dir, names.get(service.name)),
     color: service.color
-  })).filter((target) => existsSync8(target.file));
+  })).filter((target) => existsSync9(target.file));
 };
 var formatEntry = (entry, width, withName) => {
   const time2 = new Date(entry.at || Date.now());
   const clock = [time2.getHours(), time2.getMinutes(), time2.getSeconds()].map((part) => String(part).padStart(2, "0")).join(":");
-  const who = withName ? `${paint(asColorName(void 0), padEnd(entry.service, width))} ` : "";
-  const body = entry.stream === "stderr" ? paint("red", entry.line) : entry.line;
-  return `${paint("gray", clock)} ${who}${paint("gray", "|")} ${body}
+  const who = withName ? `${color.cyan(padEnd(entry.service, width))} ` : "";
+  const body = entry.stream === "stderr" ? color.red(entry.line) : entry.line;
+  return `${color.gray(clock)} ${who}${color.gray("|")} ${body}
 `;
 };
 var logsCommand = async (service, options = {}) => {
@@ -3454,25 +3838,24 @@ var logsCommand = async (service, options = {}) => {
   if (!stackName) throw new ConfigError("name a stack with --stack, or run `laracrew logs` from a known stack");
   const dir = logDirFor(stackName, env);
   const available = targetsFor(stackName, env);
+  const mark = marks(env);
   if (options.list) {
     if (available.length === 0) {
-      console.log(paint("yellow", `no log files yet in ${dir}`));
-      console.log(paint("gray", "they appear once the stack has run at least once"));
+      console.log(`${mark.warn} ${color.yellow(`no log files yet in ${dir}`)}`);
+      console.log(`  ${color.gray("they appear once the stack has run at least once")}`);
       return 0;
     }
-    console.log(paint("gray", dir));
+    console.log(`${color.bold("logs")} ${color.gray(glyphs(env).dot)} ${color.cyan.bold(stackName)}`);
+    console.log(`  ${color.gray(dir)}`);
     for (const target of available) {
-      console.log(`  ${paint("cyan", target.service)}  ${paint("gray", path10.basename(target.file))}`);
+      console.log(`  ${color.cyan(target.service)}  ${color.gray(path11.basename(target.file))}`);
     }
     return 0;
   }
   if (available.length === 0) {
-    console.error(paint("yellow", `no log files in ${dir}`));
+    console.error(`${mark.warn} ${color.yellow(`no log files in ${dir}`)}`);
     console.error(
-      paint(
-        "gray",
-        "run the stack at least once, and check `defaults.logs.toFile` is not set to false"
-      )
+      `  ${color.gray("run the stack at least once, and check `defaults.logs.toFile` is not set to false")}`
     );
     return 1;
   }
@@ -3534,11 +3917,12 @@ var logsCommand = async (service, options = {}) => {
 };
 
 // src/cli/commands/ls.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 var lsCommand = (env = process.env, json = false) => {
   const home2 = paths(env);
-  if (!existsSync9(home2.root)) {
-    console.error(`${paint("yellow", "no laracrew home yet")} \u2014 run ${paint("cyan", "laracrew init")}`);
+  const mark = marks(env);
+  if (!existsSync10(home2.root)) {
+    console.error(`${mark.warn} ${color.yellow("no laracrew home yet")} \u2014 run ${color.cyan("laracrew init")}`);
     return 1;
   }
   const stackNames = listStacks(env);
@@ -3571,43 +3955,46 @@ var lsCommand = (env = process.env, json = false) => {
     console.log(JSON.stringify({ root: home2.root, stacks, tasks: taskNames, projects }, null, 2));
     return 0;
   }
-  console.log(paint("gray", home2.root));
-  console.log(`
-${paint("bold", "STACKS")}`);
-  if (stacks.length === 0) console.log(paint("gray", "  none"));
+  const heading = (label, count) => `
+${color.bold(label)} ${color.gray(`(${count})`)}`;
+  console.log(`${color.bold("laracrew")} ${color.gray(home2.root)}`);
+  console.log(heading("STACKS", stacks.length));
+  if (stacks.length === 0) {
+    console.log(color.gray("  none \u2014 run `laracrew init --examples`, or write stacks/<name>/stack.yaml"));
+  }
   const width = Math.max(4, ...stacks.map((stack) => stack.name.length));
+  const indent = " ".repeat(width + 4);
   for (const stack of stacks) {
-    const label = stack.valid ? paint("cyan", padEnd(stack.name, width)) : paint("red", padEnd(stack.name, width));
-    const meta = stack.valid ? paint("gray", `${stack.services} services`) : paint("red", "invalid");
-    console.log(`  ${label}  ${meta}  ${paint("gray", stack.description)}`);
-    if (stack.command) {
-      console.log(`  ${" ".repeat(width)}  ${paint("green", `$ ${stack.command}`)} ${paint("gray", "(global command)")}`);
-    }
-    if (stack.profiles.length > 0) {
-      console.log(`  ${" ".repeat(width)}  ${paint("gray", `profiles: ${stack.profiles.join(", ")}`)}`);
+    if (stack.valid) {
+      const meta = padEnd(`${stack.services} service${stack.services === 1 ? "" : "s"}`, 11);
+      console.log(`  ${color.cyan.bold(padEnd(stack.name, width))}  ${color.gray(meta)}  ${stack.description}`.trimEnd());
+    } else {
+      console.log(
+        `${mark.fail} ${color.red.bold(padEnd(stack.name, width))}  ${color.red(padEnd("invalid", 11))}  ${color.red(stack.description)}`
+      );
     }
+    if (stack.command) console.log(`${indent}${color.green(`$ ${stack.command}`)} ${color.gray("global command")}`);
+    if (stack.profiles.length > 0) console.log(`${indent}${color.gray(`profiles: ${stack.profiles.join(", ")}`)}`);
   }
-  console.log(`
-${paint("bold", "PROJECTS")}`);
   const projectKeys = Object.keys(projects);
-  if (projectKeys.length === 0) console.log(paint("gray", "  none \u2014 add them to projects.yaml"));
+  console.log(heading("PROJECTS", projectKeys.length));
+  if (projectKeys.length === 0) console.log(color.gray("  none \u2014 add them to projects.yaml"));
   const projectWidth = Math.max(4, ...projectKeys.map((key) => key.length));
   for (const [key, project] of Object.entries(projects)) {
-    const exists = existsSync9(project.path);
-    console.log(
-      `  ${paint("magenta", padEnd(key, projectWidth))}  ${project.path} ${exists ? "" : paint("red", "(missing)")}`
-    );
-  }
-  console.log(`
-${paint("bold", "TASKS")}`);
-  if (taskNames.length === 0) console.log(paint("gray", "  none"));
-  for (const task of taskNames) console.log(`  ${paint("green", task)}`);
+    const exists = existsSync10(project.path);
+    const lead = exists ? "  " : `${mark.fail} `;
+    const where = exists ? project.path : color.red(`${project.path} (missing)`);
+    console.log(`${lead}${color.magenta.bold(padEnd(key, projectWidth))}  ${where}`);
+  }
+  console.log(heading("TASKS", taskNames.length));
+  if (taskNames.length === 0) console.log(color.gray("  none"));
+  for (const task of taskNames) console.log(`  ${color.green(task)}`);
   console.log("");
   return 0;
 };
 
 // src/cli/program.ts
-var VERSION = true ? "0.2.2" : versionFromPackageJson();
+var VERSION = true ? "0.3.0" : versionFromPackageJson();
 var resolveStackName = (explicit, env = process.env) => {
   if (explicit) return explicit;
   const configured = loadGlobalConfig(env).defaultStack;
@@ -3625,10 +4012,38 @@ var resolveStackName = (explicit, env = process.env) => {
 var collect = (value, previous) => [...previous, value];
 var buildProgram = () => {
   const program = new Command();
-  program.name("laracrew").description("Boot and supervise all the long-running processes of your projects with one command.").version(VERSION, "-v, --version").showHelpAfterError();
+  program.name("laracrew").description("Boot and supervise all the long-running processes of your projects with one command.").version(VERSION, "-v, --version").showHelpAfterError().configureHelp({
+    styleTitle: (text) => color.bold(text),
+    styleCommandText: (text) => color.cyan(text),
+    styleSubcommandText: (text) => color.cyan(text),
+    styleOptionText: (text) => color.green(text),
+    styleArgumentText: (text) => color.yellow(text)
+  }).configureOutput({
+    // One colour decision for the whole program — ours, so NO_COLOR is honoured here too.
+    getOutHasColors: () => color.level > 0,
+    getErrHasColors: () => color.level > 0,
+    outputError: (message, write2) => write2(`${marks().fail} ${color.red(message.trimEnd())}
+`)
+  });
   program.command("init").description("create ~/.laracrew").option("--examples", "also write a runnable demo stack and a two-project template").action((options) => {
     initCommand({ examples: options.examples ?? false });
   });
+  const draft = program.command("draft").description("build a stack step by step in the current folder, then publish it").argument("[name]", "start a draft with this stack name, or show it if it exists; omit to show the only draft here").option("--force", "start over when a draft of that name already exists here").action((name, options) => {
+    process.exitCode = draftCommand(name, options);
+  });
+  draft.command("add").description("append a service to the draft in this folder").requiredOption("--command, --cmd <line>", 'what to run, e.g. "php artisan queue:work"').option("--project <key>", "the project it runs in \u2014 any short key, e.g. api").option("--path <dir>", "the project's folder, or where the command runs when there is no --project; defaults to this folder").option("--name <service>", "service name (default: project + command, e.g. api:queue:work)").option("--default-state <state>", '"running" (default) or "stopped": defined, but idle until you start it').option("--draft <name>", "which draft, when this folder holds several").action((options) => {
+    process.exitCode = draftAddCommand({
+      command: options.command ?? options.cmd,
+      project: options.project,
+      path: options.path,
+      name: options.name,
+      state: options.defaultState,
+      draft: options.draft
+    });
+  });
+  draft.command("publish").description("validate the draft and install it as a stack in ~/.laracrew").option("--force", "replace a stack of the same name").option("--link", "also install the global command, as `laracrew link` would").option("--draft <name>", "which draft, when this folder holds several").action((options) => {
+    process.exitCode = draftPublishCommand(options);
+  });
   program.command("ls").alias("list").description("list stacks, projects and tasks").option("--json", "machine-readable output").action((options) => {
     process.exitCode = lsCommand(process.env, options.json ?? false);
   });
@@ -3672,13 +4087,19 @@ var buildProgram = () => {
   });
   return program;
 };
+var renderConfigError = (error) => {
+  const lines = [`${marks().fail} ${color.red.bold("config error")}`];
+  if (error.file) lines.push(`  ${color.gray(error.file)}`);
+  lines.push(`  ${error.message}`);
+  for (const detail of error.details) lines.push(`    ${color.gray("-")} ${detail}`);
+  return lines.join("\n");
+};
 var run = async (argv = process.argv) => {
   try {
     await buildProgram().parseAsync(argv);
   } catch (error) {
     if (error instanceof ConfigError) {
-      console.error(`${paint("red", "config error")}
-${error.format()}`);
+      console.error(renderConfigError(error));
       process.exitCode = 1;
       return;
     }
@@ -3689,7 +4110,9 @@ ${error.format()}`);
 // src/index.ts
 installPipeGuards();
 run().catch((error) => {
-  console.error(paint("red", error instanceof Error ? error.stack ?? error.message : String(error)));
+  const [head, ...trace] = (error instanceof Error ? error.stack ?? error.message : String(error)).split("\n");
+  console.error(`${marks().fail} ${color.red.bold(head ?? "unexpected error")}`);
+  if (trace.length > 0) console.error(color.gray(trace.join("\n")));
   process.exitCode = 1;
 });
 //# sourceMappingURL=index.js.map