laracrew 0.1.1

package/dist/index.js

@@ -0,0 +1,3524 @@
+#!/usr/bin/env node
+
+// src/cli/program.ts
+import { Command } from "commander";
+
+// src/core/config/errors.ts
+var ConfigError = class extends Error {
+  file;
+  details;
+  constructor(message, opts = {}) {
+    super(message, opts.cause !== void 0 ? { cause: opts.cause } : void 0);
+    this.name = "ConfigError";
+    this.file = opts.file;
+    this.details = opts.details ?? [];
+  }
+  /** Multi-line, terminal-ready rendering. */
+  format() {
+    const head = this.file ? `${this.file}
+  ${this.message}` : this.message;
+    if (this.details.length === 0) return head;
+    return `${head}
+${this.details.map((d) => `  - ${d}`).join("\n")}`;
+  }
+};
+var levenshtein = (a, b) => {
+  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) rows[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+    }
+  }
+  return rows[a.length][b.length];
+};
+var didYouMean = (input, candidates) => {
+  let best;
+  for (const candidate of candidates) {
+    const distance = levenshtein(input.toLowerCase(), candidate.toLowerCase());
+    if (!best || distance < best.distance) best = { word: candidate, distance };
+  }
+  if (!best) return void 0;
+  const threshold = Math.max(2, Math.floor(input.length / 3));
+  return best.distance <= threshold ? best.word : void 0;
+};
+var pathOf = (issue) => issue.path.length === 0 ? "(root)" : issue.path.map((segment, index) => typeof segment === "number" ? `[${segment}]` : index === 0 ? segment : `.${segment}`).join("");
+var formatZodIssues = (error, knownKeys = []) => error.issues.map((issue) => {
+  if (issue.code === "unrecognized_keys") {
+    return issue.keys.map((key) => {
+      const suggestion = didYouMean(key, knownKeys);
+      const at = pathOf(issue);
+      const where = at === "(root)" ? "" : ` at ${at}`;
+      return suggestion ? `unknown field "${key}"${where} \u2014 did you mean "${suggestion}"?` : `unknown field "${key}"${where}`;
+    }).join("; ");
+  }
+  return `${pathOf(issue)}: ${issue.message}`;
+});
+var KNOWN_SERVICE_KEYS = [
+  "name",
+  "project",
+  "cmd",
+  "cwd",
+  "env",
+  "groups",
+  "needs",
+  "ready",
+  "restart",
+  "backoff",
+  "stop",
+  "watch",
+  "metrics",
+  "url",
+  "external",
+  "autostart",
+  "enabled",
+  "color"
+];
+var KNOWN_STACK_KEYS = [
+  "name",
+  "description",
+  "command",
+  "use",
+  "projects",
+  "defaults",
+  "services",
+  "profiles",
+  "hooks"
+];
+var ALL_KNOWN_KEYS = [...KNOWN_SERVICE_KEYS, ...KNOWN_STACK_KEYS];
+
+// src/core/config/load.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import path2 from "path";
+import YAML from "yaml";
+
+// src/core/config/paths.ts
+import { homedir } from "os";
+import path from "path";
+var home = (env = process.env) => env.LARACREW_HOME ? path.resolve(env.LARACREW_HOME) : path.join(homedir(), ".laracrew");
+var paths = (env = process.env) => {
+  const root = home(env);
+  return {
+    root,
+    configFile: path.join(root, "config.yaml"),
+    projectsFile: path.join(root, "projects.yaml"),
+    stacksDir: path.join(root, "stacks"),
+    tasksDir: path.join(root, "tasks"),
+    fragmentsDir: path.join(root, "fragments"),
+    logsDir: path.join(root, "logs"),
+    runDir: path.join(root, "run")
+  };
+};
+var stackDir = (name, env = process.env) => path.join(paths(env).stacksDir, name);
+var stackFile = (name, env = process.env) => path.join(stackDir(name, env), "stack.yaml");
+
+// src/core/config/schema.ts
+import { z } from "zod";
+var restartPolicy = z.enum(["never", "on-failure", "always"]);
+var watchStrategy = z.enum(["restart", "artisan-queue-restart", "none"]);
+var readyProbeSchema = z.object({
+  tcp: z.string().optional(),
+  // "127.0.0.1:6379"
+  http: z.string().url().optional(),
+  logMatch: z.string().optional(),
+  // regex source
+  delayMs: z.number().int().nonnegative().optional(),
+  timeoutMs: z.number().int().positive().default(3e4),
+  intervalMs: z.number().int().positive().default(250)
+}).strict().refine((p) => Boolean(p.tcp ?? p.http ?? p.logMatch ?? p.delayMs !== void 0), {
+  message: "a `ready` probe needs one of: tcp, http, logMatch, delayMs"
+});
+var backoffSchema = z.object({
+  initialMs: z.number().int().positive().default(1e3),
+  maxMs: z.number().int().positive().default(3e4),
+  factor: z.number().positive().default(2),
+  maxRestarts: z.number().int().nonnegative().default(10),
+  /** Stay up this long and the attempt counter resets, so a slow leak can't exhaust it. */
+  resetAfterMs: z.number().int().positive().default(6e4)
+}).strict();
+var stopPolicySchema = z.object({
+  /** Laravel-native graceful shutdown, e.g. "queue:restart" or "horizon:terminate". */
+  artisan: z.string().optional(),
+  signal: z.string().default("SIGTERM"),
+  graceMs: z.number().int().positive().default(1e4)
+}).strict();
+var watchSchema = z.object({
+  paths: z.array(z.string()).min(1),
+  ignore: z.array(z.string()).default([]),
+  strategy: watchStrategy.default("restart"),
+  debounceMs: z.number().int().nonnegative().default(800)
+}).strict();
+var metricsSchema = z.object({
+  queues: z.array(z.string()).default([]),
+  streams: z.array(z.object({ key: z.string(), group: z.string() }).strict()).default([])
+}).strict();
+var commandSchema = z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]);
+var serviceSchema = z.object({
+  name: z.string().min(1),
+  project: z.string().optional(),
+  cmd: commandSchema.optional(),
+  cwd: z.string().optional(),
+  env: z.record(z.string()).default({}),
+  groups: z.array(z.string()).default([]),
+  needs: z.array(z.string()).default([]),
+  ready: readyProbeSchema.optional(),
+  restart: restartPolicy.optional(),
+  backoff: backoffSchema.partial().optional(),
+  stop: stopPolicySchema.partial().optional(),
+  watch: watchSchema.optional(),
+  metrics: metricsSchema.optional(),
+  url: z.string().optional(),
+  /** Health-checked but never spawned: Redis, MySQL, a Docker service. */
+  external: z.boolean().default(false),
+  /** false = defined but not launched; press `s` in the TUI to start it when you need it. */
+  autostart: z.boolean().default(true),
+  enabled: z.boolean().default(true),
+  color: z.string().optional()
+}).strict().refine((s) => s.external || s.cmd !== void 0, {
+  message: "a service needs a `cmd` unless it is marked `external: true`"
+});
+var projectSchema = z.object({
+  path: z.string().min(1),
+  php: z.string().default("php"),
+  envFile: z.string().default(".env"),
+  color: z.string().optional()
+}).strict();
+var projectsFileSchema = z.object({ projects: z.record(projectSchema).default({}) }).strict();
+var profileSchema = z.object({
+  only: z.array(z.string()).default([]),
+  except: z.array(z.string()).default([])
+}).strict();
+var stackDefaultsSchema = z.object({
+  restart: restartPolicy.default("on-failure"),
+  backoff: backoffSchema.partial().default({}),
+  stop: stopPolicySchema.partial().default({}),
+  logs: z.object({
+    /** Lines kept in memory per service, for the live log view. */
+    maxLines: z.number().int().positive().default(5e3),
+    /**
+     * On by default: an in-memory buffer holds minutes, and losing the exception you
+     * just watched scroll past is the fastest way to stop trusting the tool.
+     */
+    toFile: z.boolean().default(true),
+    /** Rotate a service's log once it passes this size. */
+    maxFileBytes: z.number().int().positive().default(5e6),
+    /** How many rotated files to keep beside the current one. */
+    keepFiles: z.number().int().nonnegative().default(1)
+  }).strict().default({})
+}).strict();
+var stackSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  /** The global command name `laracrew link` installs for this stack. Defaults to `name`. */
+  command: z.string().min(1).optional(),
+  /** Project keys pulled in from ~/.laracrew/projects.yaml. */
+  use: z.array(z.string()).default([]),
+  /** Projects declared inline; merged over the shared ones. */
+  projects: z.record(projectSchema).default({}),
+  defaults: stackDefaultsSchema.default({}),
+  services: z.array(serviceSchema).min(1),
+  profiles: z.record(profileSchema).default({}),
+  hooks: z.object({ preUp: z.string().nullish(), postDown: z.string().nullish() }).strict().default({})
+}).strict();
+var globalConfigSchema = z.object({
+  theme: z.enum(["auto", "dark", "light", "mono", "high-contrast"]).default("auto"),
+  editor: z.string().optional(),
+  defaultStack: z.string().optional(),
+  metricsIntervalMs: z.number().int().positive().default(2e3)
+}).strict();
+var taskStepSchema = z.lazy(
+  () => z.union([
+    z.object({
+      project: z.string().optional(),
+      cwd: z.string().optional(),
+      cmd: commandSchema,
+      continueOnError: z.boolean().default(false)
+    }).strict(),
+    z.object({ parallel: z.array(taskStepSchema).min(1) }).strict()
+  ])
+);
+var taskSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  pauseServices: z.array(z.string()).default([]),
+  steps: z.array(taskStepSchema).min(1)
+}).strict();
+
+// src/core/config/load.ts
+var parseYaml = (source, file) => {
+  try {
+    return YAML.parse(source, { prettyErrors: true }) ?? {};
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ConfigError(`invalid YAML: ${message}`, { file, cause: error });
+  }
+};
+var readYamlFile = (file) => {
+  let source;
+  try {
+    source = readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ConfigError(`file not found`, { file, cause: error });
+    }
+    throw error;
+  }
+  return parseYaml(source, file);
+};
+var validate = (schema, value, file) => {
+  const result = schema.safeParse(value);
+  if (result.success) return result.data;
+  throw new ConfigError("this file does not match the laracrew schema", {
+    file,
+    details: formatZodIssues(result.error, ALL_KNOWN_KEYS)
+  });
+};
+var loadGlobalConfig = (env = process.env) => {
+  const file = paths(env).configFile;
+  if (!existsSync(file)) return globalConfigSchema.parse({});
+  return validate(globalConfigSchema, readYamlFile(file), file);
+};
+var loadSharedProjects = (env = process.env) => {
+  const file = paths(env).projectsFile;
+  if (!existsSync(file)) return {};
+  return validate(projectsFileSchema, readYamlFile(file), file).projects;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var mergeServiceFragments = (document, dir) => {
+  const servicesDir = path2.join(dir, "services");
+  if (!existsSync(servicesDir) || !statSync(servicesDir).isDirectory()) return document;
+  if (!isRecord(document)) return document;
+  const extra = [];
+  for (const entry of readdirSync(servicesDir).sort()) {
+    if (!/\.ya?ml$/i.test(entry)) continue;
+    const file = path2.join(servicesDir, entry);
+    const fragment = readYamlFile(file);
+    if (Array.isArray(fragment)) {
+      extra.push(...fragment);
+    } else if (isRecord(fragment) && Array.isArray(fragment.services)) {
+      extra.push(...fragment.services);
+    } else {
+      throw new ConfigError("a service fragment must be a list of services, or { services: [...] }", { file });
+    }
+  }
+  if (extra.length === 0) return document;
+  const existing = Array.isArray(document.services) ? document.services : [];
+  return { ...document, services: [...existing, ...extra] };
+};
+var loadStack = (name, env = process.env) => {
+  const dir = stackDir(name, env);
+  const file = stackFile(name, env);
+  if (!existsSync(file)) {
+    const available = listStacks(env);
+    const hint = available.length > 0 ? ` Available: ${available.join(", ")}.` : " Run `laracrew init` first.";
+    throw new ConfigError(`no stack named "${name}".${hint}`, { file });
+  }
+  const document = mergeServiceFragments(readYamlFile(file), dir);
+  const config = validate(stackSchema, document, file);
+  if (config.name !== name) {
+    throw new ConfigError(
+      `stack folder is "${name}" but \`name:\` says "${config.name}" \u2014 they must match`,
+      { file }
+    );
+  }
+  return { config, file, dir };
+};
+var listStacks = (env = process.env) => {
+  const dir = paths(env).stacksDir;
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(path2.join(dir, entry.name, "stack.yaml"))).map((entry) => entry.name).sort();
+};
+var listTasks = (env = process.env) => {
+  const dir = paths(env).tasksDir;
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((entry) => /\.ya?ml$/i.test(entry)).map((entry) => entry.replace(/\.ya?ml$/i, "")).sort();
+};
+
+// 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
+};
+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.TERM === "dumb") return false;
+  return Boolean(stream.isTTY);
+};
+var createPainter = (enabled) => {
+  const paint2 = ((name, text) => enabled ? `\x1B[${CODES[name]}m${text}\x1B[${CODES.reset}m` : text);
+  paint2.enabled = enabled;
+  return paint2;
+};
+var paint = createPainter(supportsColor());
+var asColorName = (value) => value && value in CODES ? value : "cyan";
+var stripAnsi = (text) => text.replace(/\[[0-9;]*m/g, "");
+var padEnd = (text, width) => {
+  const visible = stripAnsi(text).length;
+  return visible >= width ? text : text + " ".repeat(width - visible);
+};
+
+// src/cli/commands/doctor.ts
+import { existsSync as existsSync4 } from "fs";
+import path7 from "path";
+
+// src/core/health/probes.ts
+import net from "net";
+var tcpProbe = (target, timeoutMs = 2e3) => new Promise((resolve) => {
+  const lastColon = target.lastIndexOf(":");
+  const host = lastColon === -1 ? "127.0.0.1" : target.slice(0, lastColon) || "127.0.0.1";
+  const port = Number(lastColon === -1 ? target : target.slice(lastColon + 1));
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    resolve({ ok: false, detail: `"${target}" is not host:port` });
+    return;
+  }
+  const socket = net.connect({ host, port });
+  const finish = (result) => {
+    socket.removeAllListeners();
+    socket.destroy();
+    resolve(result);
+  };
+  socket.setTimeout(timeoutMs);
+  socket.once("connect", () => finish({ ok: true }));
+  socket.once("timeout", () => finish({ ok: false, detail: "connect timed out" }));
+  socket.once("error", (error) => finish({ ok: false, detail: error.code ?? error.message }));
+});
+var httpProbe = async (url, timeoutMs = 2e3) => {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+      redirect: "manual",
+      headers: { "user-agent": "laracrew" }
+    });
+    if (response.status >= 500) return { ok: false, detail: `HTTP ${response.status}` };
+    return { ok: true, detail: `HTTP ${response.status}` };
+  } catch (error) {
+    return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+  }
+};
+var isPortFree = (port, host = "127.0.0.1") => new Promise((resolve) => {
+  const server = net.createServer();
+  server.once("error", () => resolve(false));
+  server.once("listening", () => server.close(() => resolve(true)));
+  server.listen(port, host);
+});
+var waitFor = async (probe, options) => {
+  const deadline = Date.now() + options.timeoutMs;
+  let last = { ok: false, detail: "not attempted" };
+  while (Date.now() < deadline) {
+    if (options.signal?.aborted) return { ok: false, detail: "aborted" };
+    last = await probe();
+    if (last.ok) return last;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await sleep(Math.min(options.intervalMs, remaining), options.signal);
+  }
+  return { ok: false, detail: last.detail ?? "timed out" };
+};
+var sleep = (ms, signal) => new Promise((resolve) => {
+  if (signal?.aborted) {
+    resolve();
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    resolve();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var describeProbe = (probe) => {
+  if (probe.http) return `http ${probe.http}`;
+  if (probe.tcp) return `tcp ${probe.tcp}`;
+  if (probe.logMatch) return `log /${probe.logMatch}/`;
+  if (probe.delayMs !== void 0) return `wait ${probe.delayMs}ms`;
+  return "spawn";
+};
+
+// src/core/process/spawn.ts
+import { spawn } from "child_process";
+var IS_WINDOWS = process.platform === "win32";
+var SHIM_NAMES = /* @__PURE__ */ new Set(["npm", "npx", "yarn", "pnpm", "bun", "composer"]);
+var needsShell = (file) => {
+  if (!IS_WINDOWS) return false;
+  const base = file.replace(/\\/g, "/").split("/").pop() ?? file;
+  if (/\.(cmd|bat)$/i.test(base)) return true;
+  return SHIM_NAMES.has(base.replace(/\.[^.]+$/, "").toLowerCase());
+};
+var describeCommand = (command) => command.kind === "shell" ? command.line : [command.file, ...command.args].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
+var buildEnv = (service, base = process.env) => ({
+  ...base,
+  ...service.env,
+  LARACREW: "1",
+  LARACREW_SERVICE: service.name,
+  ...service.project ? { LARACREW_PROJECT: service.project.key } : {}
+});
+var spawnService = (service, base = process.env) => {
+  const command = service.command;
+  if (!command) throw new Error(`service "${service.name}" has no command to run`);
+  const options = {
+    cwd: service.cwd,
+    env: buildEnv(service, base),
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    // POSIX: a new process group means one kill(-pid) takes the whole tree down.
+    // Windows has no equivalent, so stop.ts uses `taskkill /T` there instead.
+    detached: !IS_WINDOWS
+  };
+  const child = command.kind === "shell" ? spawn(command.line, { ...options, shell: true }) : spawn(command.file, command.args, { ...options, shell: needsShell(command.file) });
+  return { child, description: describeCommand(command) };
+};
+var runOnce = (command, options) => new Promise((resolve, reject) => {
+  const spawnOptions = {
+    cwd: options.cwd,
+    env: options.env ?? process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  };
+  const child = command.kind === "shell" ? spawn(command.line, { ...spawnOptions, shell: true }) : spawn(command.file, command.args, { ...spawnOptions, shell: needsShell(command.file) });
+  let stdout = "";
+  let stderr = "";
+  child.stdout?.on("data", (chunk) => {
+    stdout += chunk.toString("utf8");
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString("utf8");
+  });
+  const timer = options.timeoutMs ? setTimeout(() => {
+    child.kill("SIGKILL");
+  }, options.timeoutMs) : void 0;
+  timer?.unref?.();
+  child.once("error", (error) => {
+    if (timer) clearTimeout(timer);
+    reject(error);
+  });
+  child.once("close", (code) => {
+    if (timer) clearTimeout(timer);
+    resolve({ code, stdout, stderr });
+  });
+});
+
+// src/core/events/bus.ts
+var EventBus = class {
+  #listeners = /* @__PURE__ */ new Set();
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  emit(event) {
+    for (const listener of this.#listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        process.emitWarning(
+          `laracrew: event listener threw: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /** Resolves on the first event matching `predicate`, or rejects on timeout. */
+  next(predicate, timeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        unsubscribe();
+        reject(new Error("timed out waiting for event"));
+      }, timeoutMs);
+      timer.unref?.();
+      const unsubscribe = this.subscribe((event) => {
+        if (!predicate(event)) return;
+        clearTimeout(timer);
+        unsubscribe();
+        resolve(event);
+      });
+    });
+  }
+  get size() {
+    return this.#listeners.size;
+  }
+};
+
+// src/core/config/resolve.ts
+import path4 from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/core/laravel/env.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+var parseEnv = (content) => {
+  const out = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const eq = withoutExport.indexOf("=");
+    if (eq === -1) continue;
+    const key = withoutExport.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(key)) continue;
+    let value = withoutExport.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+      const quote = value[0];
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\"/g, '"');
+    } else {
+      const hash = value.indexOf(" #");
+      if (hash !== -1) value = value.slice(0, hash).trim();
+    }
+    out[key] = value;
+  }
+  return out;
+};
+var readProjectEnv = (projectPath, envFile = ".env") => {
+  try {
+    return parseEnv(readFileSync2(path3.join(projectPath, envFile), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+};
+
+// src/core/config/interpolate.ts
+var TOKEN = /\$\{([^}]*)\}/g;
+var splitOnce = (input, separator) => {
+  const index = input.indexOf(separator);
+  return index === -1 ? [input, void 0] : [input.slice(0, index), input.slice(index + separator.length)];
+};
+var interpolate = (input, ctx) => input.replace(TOKEN, (match, body) => {
+  const [scheme, rest] = splitOnce(body.trim(), ":");
+  switch (scheme) {
+    case "env": {
+      if (!rest) throw new ConfigError(`\${env:...} needs a variable name, got "${match}"`);
+      const [key, fallback] = splitOnce(rest, ":");
+      const value = ctx.env[key];
+      if (value !== void 0) return value;
+      if (fallback !== void 0) return fallback;
+      throw new ConfigError(`environment variable "${key}" is not set (used in "${match}")`);
+    }
+    case "project.path": {
+      if (!ctx.project) throw new ConfigError(`"${match}" used on a service that has no \`project\``);
+      return ctx.project.path;
+    }
+    case "project.env": {
+      if (!ctx.project) throw new ConfigError(`"${match}" used on a service that has no \`project\``);
+      if (!rest) throw new ConfigError(`\${project.env:...} needs a variable name, got "${match}"`);
+      const [key, fallback] = splitOnce(rest, ":");
+      const value = ctx.project.env[key];
+      if (value !== void 0) return value;
+      if (fallback !== void 0) return fallback;
+      throw new ConfigError(`"${key}" is not in the project's .env (used in "${match}")`);
+    }
+    case "stack.dir": {
+      if (!ctx.stackDir) throw new ConfigError(`"${match}" used outside a stack folder`);
+      return ctx.stackDir;
+    }
+    case "port": {
+      const port = Number(rest);
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new ConfigError(`"${match}" is not a valid port number`);
+      }
+      ctx.ports?.add(port);
+      return String(port);
+    }
+    default:
+      throw new ConfigError(
+        `unknown token "${match}" \u2014 supported: \${env:VAR}, \${project.path}, \${project.env:VAR}, \${stack.dir}, \${port:N}`
+      );
+  }
+});
+var interpolateDeep = (value, ctx) => {
+  if (typeof value === "string") return interpolate(value, ctx);
+  if (Array.isArray(value)) return value.map((item) => interpolateDeep(item, ctx));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+      out[key] = interpolateDeep(item, ctx);
+    }
+    return out;
+  }
+  return value;
+};
+
+// src/core/config/resolve.ts
+var PALETTE = ["cyan", "magenta", "green", "yellow", "blue", "red"];
+var toCommand = (cmd) => Array.isArray(cmd) ? { kind: "argv", file: cmd[0], args: cmd.slice(1) } : { kind: "shell", line: cmd };
+var matches = (service, selectors) => selectors.some((selector) => service.name === selector || service.groups.includes(selector));
+var resolveProjects = (stack, shared) => {
+  const wanted = /* @__PURE__ */ new Map();
+  for (const key of stack.config.use) {
+    const project = shared[key];
+    if (!project) {
+      const suggestion = didYouMean(key, Object.keys(shared));
+      throw new ConfigError(
+        `\`use:\` refers to project "${key}", which is not in projects.yaml` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""),
+        { file: stack.file }
+      );
+    }
+    wanted.set(key, project);
+  }
+  for (const [key, project] of Object.entries(stack.config.projects)) wanted.set(key, project);
+  const out = {};
+  let index = 0;
+  for (const [key, project] of wanted) {
+    const root = path4.resolve(project.path);
+    out[key] = {
+      key,
+      path: root,
+      php: project.php,
+      envFile: project.envFile,
+      env: readProjectEnv(root, project.envFile),
+      color: project.color ?? PALETTE[index % PALETTE.length]
+    };
+    index += 1;
+  }
+  return out;
+};
+var mergeService = (raw, stack, projects, ports, processEnv, colorIndex) => {
+  const defaults = stack.config.defaults;
+  let project;
+  if (raw.project) {
+    project = projects[raw.project];
+    if (!project) {
+      const suggestion = didYouMean(raw.project, Object.keys(projects));
+      throw new ConfigError(
+        `service "${raw.name}" refers to project "${raw.project}", which this stack does not define` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""),
+        { file: stack.file }
+      );
+    }
+  }
+  const ctx = {
+    env: processEnv,
+    stackDir: stack.dir,
+    ports,
+    ...project ? { project: { path: project.path, env: project.env } } : {}
+  };
+  let service;
+  try {
+    service = interpolateDeep(raw, ctx);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw new ConfigError(`service "${raw.name}": ${error.message}`, { file: stack.file, cause: error });
+    }
+    throw error;
+  }
+  const cwd = service.cwd ? path4.resolve(project?.path ?? stack.dir, service.cwd) : project?.path ?? stack.dir;
+  return {
+    name: service.name,
+    ...project ? { project } : {},
+    ...service.cmd ? { command: toCommand(service.cmd) } : {},
+    cwd,
+    env: { ...service.env },
+    groups: service.groups,
+    needs: service.needs,
+    ...service.ready ? { ready: service.ready } : {},
+    restart: service.restart ?? defaults.restart,
+    backoff: backoffSchema.parse({ ...defaults.backoff, ...service.backoff ?? {} }),
+    stop: stopPolicySchema.parse({ ...defaults.stop, ...service.stop ?? {} }),
+    ...service.watch ? { watch: service.watch } : {},
+    ...service.metrics ? { metrics: service.metrics } : {},
+    ...service.url ? { url: service.url } : {},
+    external: service.external,
+    autostart: service.autostart,
+    color: service.color ?? project?.color ?? PALETTE[colorIndex % PALETTE.length]
+  };
+};
+var topoLevels = (services, file) => {
+  const names = new Set(services.map((s) => s.name));
+  const remaining = /* @__PURE__ */ new Map();
+  for (const service of services) {
+    for (const need of service.needs) {
+      if (!names.has(need)) {
+        const suggestion = didYouMean(need, [...names]);
+        throw new ConfigError(
+          `service "${service.name}" needs "${need}", which is not in this stack` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""),
+          file ? { file } : {}
+        );
+      }
+    }
+    remaining.set(service.name, new Set(service.needs));
+  }
+  const levels = [];
+  const done = /* @__PURE__ */ new Set();
+  while (done.size < services.length) {
+    const level = [...remaining.entries()].filter(([name, needs]) => !done.has(name) && [...needs].every((need) => done.has(need))).map(([name]) => name);
+    if (level.length === 0) {
+      const stuck = services.filter((s) => !done.has(s.name)).map((s) => s.name);
+      throw new ConfigError(
+        `dependency cycle between: ${stuck.join(" -> ")}`,
+        file ? { file } : {}
+      );
+    }
+    for (const name of level) done.add(name);
+    levels.push(level);
+  }
+  return levels;
+};
+var resolveStack = (stack, options = {}) => {
+  const processEnv = options.env ?? process.env;
+  const projects = resolveProjects(stack, options.sharedProjects ?? {});
+  const ports = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const service of stack.config.services) {
+    if (seen.has(service.name)) {
+      throw new ConfigError(`two services are both named "${service.name}"`, { file: stack.file });
+    }
+    seen.add(service.name);
+  }
+  let services = stack.config.services.filter((service) => service.enabled).map((service, index) => mergeService(service, stack, projects, ports, processEnv, index));
+  const profile = options.profile ? stack.config.profiles[options.profile] : void 0;
+  if (options.profile && !profile) {
+    const suggestion = didYouMean(options.profile, Object.keys(stack.config.profiles));
+    throw new ConfigError(
+      `no profile "${options.profile}" in this stack` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""),
+      { file: stack.file }
+    );
+  }
+  const only = options.only?.length ? options.only : profile?.only;
+  const except = options.except?.length ? options.except : profile?.except;
+  if (only?.length) services = services.filter((service) => matches(service, only));
+  if (except?.length) services = services.filter((service) => !matches(service, except));
+  if (services.length === 0) {
+    throw new ConfigError("the selection matched no services", { file: stack.file });
+  }
+  const kept = new Set(services.map((service) => service.name));
+  services = services.map((service) => ({
+    ...service,
+    needs: service.needs.filter((need) => kept.has(need))
+  }));
+  const manual = new Set(
+    services.filter((service) => !service.autostart && !service.external).map((service) => service.name)
+  );
+  for (const service of services) {
+    if (!service.autostart) continue;
+    const blocked = service.needs.filter((need) => manual.has(need));
+    if (blocked.length > 0) {
+      throw new ConfigError(
+        `service "${service.name}" starts at launch but needs "${blocked.join('", "')}", which ${blocked.length === 1 ? "does" : "do"} not`,
+        { file: stack.file, details: ["give it `autostart: false` too, or start the dependency at launch"] }
+      );
+    }
+  }
+  for (const service of services) {
+    if (!service.external && !existsSync2(service.cwd)) {
+      throw new ConfigError(
+        `service "${service.name}" has cwd "${service.cwd}", which does not exist`,
+        { file: stack.file }
+      );
+    }
+  }
+  return {
+    name: stack.config.name,
+    ...stack.config.description ? { description: stack.config.description } : {},
+    dir: stack.dir,
+    file: stack.file,
+    services,
+    levels: topoLevels(services, stack.file),
+    projects,
+    ports: [...ports].sort((a, b) => a - b),
+    logs: stack.config.defaults.logs
+  };
+};
+
+// src/core/process/supervisor.ts
+import path6 from "path";
+
+// src/core/events/types.ts
+var isLive = (state) => state === "starting" || state === "ready" || state === "running";
+
+// src/core/logs/file-sink.ts
+import { closeSync, existsSync as existsSync3, mkdirSync, openSync, renameSync, rmSync, statSync as statSync2, writeSync } from "fs";
+import path5 from "path";
+var stamp = (at) => {
+  const date = new Date(at);
+  const pad2 = (value, width = 2) => String(value).padStart(width, "0");
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}.${pad2(date.getMilliseconds(), 3)}`;
+};
+var parseLine = (raw) => {
+  const match = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) (stdout|stderr|system) (.*)$/s.exec(raw);
+  if (!match) return void 0;
+  const at = new Date(match[1].replace(" ", "T")).getTime();
+  return { at: Number.isNaN(at) ? 0 : at, stream: match[2], line: match[3] };
+};
+var safeFileName = (service) => service.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "service";
+var fileNamesFor = (services) => {
+  const used = /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Map();
+  for (const service of services) {
+    const base = safeFileName(service);
+    let candidate = base;
+    let index = 2;
+    while (used.has(candidate)) candidate = `${base}-${index++}`;
+    used.add(candidate);
+    out.set(service, `${candidate}.log`);
+  }
+  return out;
+};
+var FileSink = class {
+  file;
+  #fd;
+  #bytes = 0;
+  #closed = false;
+  #options;
+  constructor(file, options) {
+    this.file = file;
+    this.#options = options;
+  }
+  #open() {
+    if (this.#fd !== void 0) return this.#fd;
+    try {
+      mkdirSync(path5.dirname(this.file), { recursive: true });
+      this.#bytes = existsSync3(this.file) ? statSync2(this.file).size : 0;
+      this.#fd = openSync(this.file, "a");
+      return this.#fd;
+    } catch {
+      this.#closed = true;
+      return void 0;
+    }
+  }
+  write(entry) {
+    if (this.#closed) return;
+    const fd = this.#open();
+    if (fd === void 0) return;
+    const text = `${stamp(entry.at)} ${entry.stream} ${stripAnsi(entry.line)}
+`;
+    try {
+      writeSync(fd, text);
+    } catch {
+      this.#closeHandle();
+      this.#closed = true;
+      return;
+    }
+    this.#bytes += Buffer.byteLength(text);
+    if (this.#bytes >= this.#options.maxBytes) this.#rotate();
+  }
+  #closeHandle() {
+    if (this.#fd === void 0) return;
+    try {
+      closeSync(this.#fd);
+    } catch {
+    }
+    this.#fd = void 0;
+  }
+  #rotate() {
+    this.#closeHandle();
+    this.#bytes = 0;
+    try {
+      if (this.#options.keep <= 0) {
+        rmSync(this.file, { force: true });
+        return;
+      }
+      const oldest = `${this.file}.${this.#options.keep}`;
+      if (existsSync3(oldest)) rmSync(oldest, { force: true });
+      for (let index = this.#options.keep - 1; index >= 1; index -= 1) {
+        const from = `${this.file}.${index}`;
+        if (existsSync3(from)) renameSync(from, `${this.file}.${index + 1}`);
+      }
+      if (existsSync3(this.file)) renameSync(this.file, `${this.file}.1`);
+    } catch {
+    }
+  }
+  close() {
+    this.#closed = true;
+    this.#closeHandle();
+    return Promise.resolve();
+  }
+};
+var LogWriter = class {
+  dir;
+  #sinks = /* @__PURE__ */ new Map();
+  #names;
+  #unsubscribe;
+  constructor(options) {
+    this.dir = options.dir;
+    this.#names = fileNamesFor(options.services);
+    const sinkOptions = {
+      maxBytes: options.maxBytes ?? 5e6,
+      keep: options.keep ?? 1
+    };
+    for (const [service, fileName] of this.#names) {
+      this.#sinks.set(service, new FileSink(path5.join(this.dir, fileName), sinkOptions));
+    }
+  }
+  /** The file a given service writes to — used by `laracrew logs`. */
+  fileFor(service) {
+    const name = this.#names.get(service);
+    return name ? path5.join(this.dir, name) : void 0;
+  }
+  attach(bus) {
+    this.#unsubscribe = bus.subscribe((event) => {
+      if (event.type !== "service:log") return;
+      this.#sinks.get(event.log.service)?.write(event.log);
+    });
+    return this.#unsubscribe;
+  }
+  async close() {
+    this.#unsubscribe?.();
+    this.#unsubscribe = void 0;
+    await Promise.all([...this.#sinks.values()].map((sink) => sink.close()));
+  }
+};
+
+// src/core/logs/ring-buffer.ts
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (!Number.isInteger(capacity) || capacity < 1) {
+      throw new RangeError(`RingBuffer capacity must be a positive integer, got ${capacity}`);
+    }
+    this.#items = Array.from({ length: capacity });
+  }
+  capacity;
+  #items;
+  #next = 0;
+  #count = 0;
+  #dropped = 0;
+  push(item) {
+    if (this.#count === this.capacity) this.#dropped += 1;
+    this.#items[this.#next] = item;
+    this.#next = (this.#next + 1) % this.capacity;
+    this.#count = Math.min(this.#count + 1, this.capacity);
+  }
+  /** Oldest to newest. */
+  toArray() {
+    const out = [];
+    const start = this.#count === this.capacity ? this.#next : 0;
+    for (let i = 0; i < this.#count; i += 1) {
+      out.push(this.#items[(start + i) % this.capacity]);
+    }
+    return out;
+  }
+  /** The last `n` items, oldest to newest — what a log pane actually needs. */
+  tail(n) {
+    if (n >= this.#count) return this.toArray();
+    const out = [];
+    for (let i = this.#count - n; i < this.#count; i += 1) {
+      const start = this.#count === this.capacity ? this.#next : 0;
+      out.push(this.#items[(start + i) % this.capacity]);
+    }
+    return out;
+  }
+  clear() {
+    this.#items = Array.from({ length: this.capacity });
+    this.#next = 0;
+    this.#count = 0;
+    this.#dropped = 0;
+  }
+  get size() {
+    return this.#count;
+  }
+  /** How many items fell off the back — worth showing in the UI. */
+  get dropped() {
+    return this.#dropped;
+  }
+};
+
+// 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";
+var isAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var killTree = async (pid, signal = "SIGKILL") => {
+  if (IS_WINDOWS2) {
+    await new Promise((resolve) => {
+      const killer = spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", () => resolve());
+      killer.once("close", () => resolve());
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+};
+var waitForExit = (child, timeoutMs) => new Promise((resolve) => {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    resolve(true);
+    return;
+  }
+  const timer = setTimeout(() => {
+    child.removeListener("close", onClose);
+    resolve(false);
+  }, timeoutMs);
+  timer.unref?.();
+  const onClose = () => {
+    clearTimeout(timer);
+    resolve(true);
+  };
+  child.once("close", onClose);
+});
+var stopLadder = async (options) => {
+  const { child, graceful, signal, graceMs, onStep } = options;
+  const pid = child.pid;
+  if (pid === void 0 || child.exitCode !== null || child.signalCode !== null) return "already-gone";
+  if (graceful) {
+    onStep?.("graceful");
+    try {
+      await graceful();
+      if (await waitForExit(child, graceMs)) return "graceful";
+    } catch {
+    }
+  }
+  if (!IS_WINDOWS2) {
+    onStep?.("signal");
+    try {
+      process.kill(-pid, signal);
+    } catch {
+      try {
+        child.kill(signal);
+      } catch {
+        return "already-gone";
+      }
+    }
+    if (await waitForExit(child, Math.min(graceMs, 5e3))) return "signal";
+  }
+  onStep?.("tree-kill");
+  await killTree(pid);
+  if (await waitForExit(child, 5e3)) return "tree-kill";
+  return isAlive(pid) ? "survived" : "tree-kill";
+};
+
+// src/core/process/managed-process.ts
+var ManagedProcess = class {
+  service;
+  logs;
+  #bus;
+  #env;
+  #child;
+  #state = "queued";
+  #intentionalStop = false;
+  #restarts = 0;
+  #attempt = 0;
+  #startedAt;
+  #readyAt;
+  #backoffTimer;
+  #logWatchers = /* @__PURE__ */ new Set();
+  #disposed = false;
+  constructor(service, bus, options = {}) {
+    this.service = service;
+    this.#bus = bus;
+    this.#env = options.env ?? process.env;
+    this.logs = new RingBuffer(options.logCapacity ?? 5e3);
+  }
+  get state() {
+    return this.#state;
+  }
+  get pid() {
+    return this.#child?.pid;
+  }
+  get restarts() {
+    return this.#restarts;
+  }
+  get startedAt() {
+    return this.#startedAt;
+  }
+  get uptimeMs() {
+    return this.#startedAt === void 0 ? void 0 : Date.now() - this.#startedAt;
+  }
+  get readyDurationMs() {
+    return this.#readyAt !== void 0 && this.#startedAt !== void 0 ? this.#readyAt - this.#startedAt : void 0;
+  }
+  #setState(to, detail) {
+    if (this.#state === to) return;
+    const from = this.#state;
+    this.#state = to;
+    this.#bus.emit({
+      type: "service:state",
+      service: this.service.name,
+      from,
+      to,
+      ...detail ? { detail } : {},
+      at: Date.now()
+    });
+  }
+  #log(line, stream = "system") {
+    const entry = { service: this.service.name, stream, line, at: Date.now() };
+    this.logs.push(entry);
+    this.#bus.emit({ type: "service:log", log: entry });
+    for (const watcher of this.#logWatchers) watcher(line);
+  }
+  /**
+   * Spawns (unless external) and resolves once the readiness probe passes.
+   * Rejects when the gate fails, which is what aborts a boot.
+   */
+  async start() {
+    if (this.#disposed) throw new Error(`service "${this.service.name}" has been disposed`);
+    this.#intentionalStop = false;
+    this.#setState("starting");
+    this.#startedAt = Date.now();
+    this.#readyAt = void 0;
+    if (this.service.external) {
+      await this.#awaitReady();
+      return;
+    }
+    const { child, description } = spawnService(this.service, this.#env);
+    this.#child = child;
+    child.once("error", (error) => {
+      this.#log(`failed to spawn: ${error.message}`, "stderr");
+      this.#setState("failed", error.message);
+    });
+    this.#pipe(child, "stdout");
+    this.#pipe(child, "stderr");
+    child.once("close", (code, signal) => this.#onExit(code, signal));
+    if (child.pid !== void 0) {
+      this.#bus.emit({
+        type: "service:spawned",
+        service: this.service.name,
+        pid: child.pid,
+        command: description,
+        cwd: this.service.cwd,
+        at: Date.now()
+      });
+    }
+    await this.#awaitReady();
+  }
+  #pipe(child, stream) {
+    const source = child[stream];
+    if (!source) return;
+    const splitter = new LineSplitter();
+    source.setEncoding("utf8");
+    source.on("data", (chunk) => {
+      for (const line of splitter.push(chunk)) this.#log(line, stream);
+    });
+    source.once("end", () => {
+      for (const line of splitter.flush()) this.#log(line, stream);
+    });
+  }
+  async #awaitReady() {
+    const probe = this.service.ready;
+    if (!probe) {
+      this.#readyAt = Date.now();
+      this.#setState("running");
+      return;
+    }
+    const label = describeProbe(probe);
+    const result = await this.#runProbe(probe);
+    if (!result.ok) {
+      this.#setState("failed", `readiness gate failed: ${label}${result.detail ? ` (${result.detail})` : ""}`);
+      throw new Error(
+        `service "${this.service.name}" never became ready: ${label}${result.detail ? ` \u2014 ${result.detail}` : ""}`
+      );
+    }
+    this.#readyAt = Date.now();
+    this.#bus.emit({
+      type: "service:ready",
+      service: this.service.name,
+      durationMs: this.readyDurationMs ?? 0,
+      probe: label,
+      at: Date.now()
+    });
+    this.#setState(this.service.external ? "ready" : "running");
+  }
+  async #runProbe(probe) {
+    if (probe.delayMs !== void 0 && !probe.tcp && !probe.http && !probe.logMatch) {
+      await sleep(probe.delayMs);
+      return { ok: true };
+    }
+    if (probe.logMatch) return this.#waitForLogMatch(probe.logMatch, probe.timeoutMs);
+    if (probe.http) {
+      const url = probe.http;
+      return waitFor(() => httpProbe(url, probe.intervalMs * 4), {
+        timeoutMs: probe.timeoutMs,
+        intervalMs: probe.intervalMs
+      });
+    }
+    const target = probe.tcp;
+    return waitFor(() => tcpProbe(target, probe.intervalMs * 4), {
+      timeoutMs: probe.timeoutMs,
+      intervalMs: probe.intervalMs
+    });
+  }
+  /** Readiness by output, for tools that announce themselves (Vite, Reverb). */
+  #waitForLogMatch(source, timeoutMs) {
+    let pattern;
+    try {
+      pattern = new RegExp(source);
+    } catch (error) {
+      return Promise.resolve({ ok: false, detail: `invalid logMatch regex: ${String(error)}` });
+    }
+    for (const entry of this.logs.toArray()) {
+      if (pattern.test(entry.line)) return Promise.resolve({ ok: true, detail: "matched buffered output" });
+    }
+    return new Promise((resolve) => {
+      const done = (result) => {
+        clearTimeout(timer);
+        this.#logWatchers.delete(watcher);
+        resolve(result);
+      };
+      const watcher = (line) => {
+        if (pattern.test(line)) done({ ok: true });
+      };
+      const timer = setTimeout(() => done({ ok: false, detail: "no matching output" }), timeoutMs);
+      timer.unref?.();
+      this.#logWatchers.add(watcher);
+    });
+  }
+  #onExit(code, signal) {
+    const wasIntentional = this.#intentionalStop;
+    const uptime = this.uptimeMs ?? 0;
+    this.#child = void 0;
+    this.#bus.emit({
+      type: "service:exit",
+      service: this.service.name,
+      code,
+      signal,
+      intentional: wasIntentional,
+      at: Date.now()
+    });
+    if (wasIntentional || this.#disposed) {
+      this.#setState("stopped");
+      return;
+    }
+    if (uptime >= this.service.backoff.resetAfterMs) this.#attempt = 0;
+    const clean = code === 0 && signal === null;
+    const policy = this.service.restart;
+    const shouldRestart = policy === "always" || policy === "on-failure" && !clean;
+    this.#setState("crashed", signal ? `killed by ${signal}` : `exit code ${code}`);
+    if (!shouldRestart) {
+      this.#setState(clean ? "stopped" : "failed", clean ? void 0 : `exited with code ${code}`);
+      return;
+    }
+    if (this.#attempt >= this.service.backoff.maxRestarts) {
+      this.#setState("failed", `gave up after ${this.#attempt} restarts`);
+      return;
+    }
+    this.#attempt += 1;
+    this.#restarts += 1;
+    const { initialMs, factor, maxMs } = this.service.backoff;
+    const delayMs = Math.min(Math.round(initialMs * factor ** (this.#attempt - 1)), maxMs);
+    this.#setState("backoff", `restarting in ${delayMs}ms`);
+    this.#bus.emit({
+      type: "service:restart",
+      service: this.service.name,
+      attempt: this.#attempt,
+      maxAttempts: this.service.backoff.maxRestarts,
+      delayMs,
+      at: Date.now()
+    });
+    this.#backoffTimer = setTimeout(() => {
+      this.#backoffTimer = void 0;
+      if (this.#disposed || this.#intentionalStop) return;
+      void this.start().catch((error) => {
+        this.#log(`restart failed: ${error instanceof Error ? error.message : String(error)}`, "stderr");
+      });
+    }, delayMs);
+    this.#backoffTimer.unref?.();
+  }
+  /** The Laravel-native graceful shutdown, when the service declares one. */
+  #graceful() {
+    const artisan = this.service.stop.artisan;
+    const project = this.service.project;
+    if (!artisan || !project) return void 0;
+    return async () => {
+      const command = { kind: "argv", file: project.php, args: ["artisan", ...artisan.split(/\s+/)] };
+      this.#log(`stop: ${describeCommand(command)}`);
+      await runOnce(command, { cwd: project.path, env: this.#env, timeoutMs: 15e3 });
+    };
+  }
+  async stop() {
+    this.#intentionalStop = true;
+    if (this.#backoffTimer) {
+      clearTimeout(this.#backoffTimer);
+      this.#backoffTimer = void 0;
+    }
+    if (this.service.external) {
+      this.#setState("stopped");
+      return;
+    }
+    const child = this.#child;
+    if (!child) {
+      this.#setState("stopped");
+      return;
+    }
+    this.#setState("stopping");
+    const graceful = this.#graceful();
+    const outcome = await stopLadder({
+      child,
+      ...graceful ? { graceful } : {},
+      signal: this.service.stop.signal,
+      graceMs: this.service.stop.graceMs,
+      onStep: (step) => this.#log(`stop: ${step}`)
+    });
+    if (outcome === "survived") {
+      this.#bus.emit({
+        type: "notice",
+        level: "error",
+        service: this.service.name,
+        message: `process ${child.pid} survived the stop ladder \u2014 kill it manually`,
+        at: Date.now()
+      });
+    }
+    this.#setState("stopped");
+  }
+  async restart() {
+    await this.stop();
+    this.#attempt = 0;
+    this.#restarts += 1;
+    await this.start();
+  }
+  async dispose() {
+    this.#disposed = true;
+    await this.stop();
+    this.#logWatchers.clear();
+  }
+};
+
+// src/core/process/supervisor.ts
+var Supervisor = class {
+  stack;
+  #bus;
+  #processes = /* @__PURE__ */ new Map();
+  #startedOrder = [];
+  #shuttingDown = false;
+  #logWriter;
+  constructor(stack, bus, options = {}) {
+    this.stack = stack;
+    this.#bus = bus;
+    for (const service of stack.services) {
+      this.#processes.set(
+        service.name,
+        new ManagedProcess(service, bus, {
+          logCapacity: stack.logs.maxLines,
+          ...options.env ? { env: options.env } : {}
+        })
+      );
+    }
+    if (stack.logs.toFile) {
+      this.#logWriter = new LogWriter({
+        dir: options.logDir ?? path6.join(paths(options.env ?? process.env).logsDir, stack.name),
+        services: stack.services.map((service) => service.name),
+        maxBytes: stack.logs.maxFileBytes,
+        keep: stack.logs.keepFiles
+      });
+      this.#logWriter.attach(bus);
+    }
+  }
+  /** Where a service's output is being written, if anywhere. */
+  logFileFor(service) {
+    return this.#logWriter?.fileFor(service);
+  }
+  get(name) {
+    return this.#processes.get(name);
+  }
+  get processes() {
+    return [...this.#processes.values()];
+  }
+  snapshot() {
+    return this.processes.map((process2) => ({
+      name: process2.service.name,
+      state: process2.state,
+      ...process2.pid !== void 0 ? { pid: process2.pid } : {},
+      ...process2.uptimeMs !== void 0 && isLive(process2.state) ? { uptimeMs: process2.uptimeMs } : {},
+      restarts: process2.restarts,
+      autostart: process2.service.autostart,
+      groups: process2.service.groups,
+      ...process2.service.project ? { project: process2.service.project.key } : {},
+      ...process2.service.url ? { url: process2.service.url } : {},
+      external: process2.service.external,
+      color: process2.service.color
+    }));
+  }
+  /**
+   * Starts every level in order; everything inside a level goes in parallel.
+   * A failure rolls back what already started, so Ctrl-C is never needed to clean up.
+   */
+  async up() {
+    const startedAt = Date.now();
+    this.#bus.emit({
+      type: "stack:starting",
+      stack: this.stack.name,
+      services: this.stack.services.map((service) => service.name),
+      at: startedAt
+    });
+    for (const level of this.stack.levels) {
+      const toStart = level.filter((name) => this.#processes.get(name)?.service.autostart !== false);
+      const results = await Promise.allSettled(
+        toStart.map(async (name) => {
+          const process2 = this.#processes.get(name);
+          await process2.start();
+          this.#startedOrder.push(name);
+        })
+      );
+      const failures = results.map((result, index) => ({ result, name: toStart[index] })).filter((entry) => entry.result.status === "rejected");
+      if (failures.length > 0) {
+        const reasons = failures.map((failure) => {
+          const error = failure.result.reason;
+          return error instanceof Error ? error.message : String(error);
+        });
+        for (const reason of reasons) {
+          this.#bus.emit({ type: "notice", level: "error", message: reason, at: Date.now() });
+        }
+        await this.down("boot failed");
+        throw new Error(`could not boot "${this.stack.name}":
+  ${reasons.join("\n  ")}`);
+      }
+    }
+    this.#bus.emit({
+      type: "stack:ready",
+      stack: this.stack.name,
+      durationMs: Date.now() - startedAt,
+      at: Date.now()
+    });
+  }
+  /** Reverse topological order, parallel within a level. */
+  async down(reason) {
+    if (this.#shuttingDown) return;
+    this.#shuttingDown = true;
+    this.#bus.emit({ type: "stack:stopping", stack: this.stack.name, at: Date.now() });
+    if (reason) {
+      this.#bus.emit({ type: "notice", level: "info", message: `stopping: ${reason}`, at: Date.now() });
+    }
+    for (const level of [...this.stack.levels].reverse()) {
+      await Promise.all(
+        level.map(async (name) => {
+          const process2 = this.#processes.get(name);
+          if (!process2) return;
+          try {
+            await process2.dispose();
+          } catch (error) {
+            this.#bus.emit({
+              type: "notice",
+              level: "error",
+              service: name,
+              message: `stop failed: ${error instanceof Error ? error.message : String(error)}`,
+              at: Date.now()
+            });
+          }
+        })
+      );
+    }
+    this.#bus.emit({ type: "stack:stopped", stack: this.stack.name, at: Date.now() });
+    await this.#logWriter?.close();
+    this.#shuttingDown = false;
+  }
+  async restart(name) {
+    const process2 = this.#requireProcess(name);
+    await process2.restart();
+  }
+  async stopService(name) {
+    await this.#requireProcess(name).stop();
+  }
+  async startService(name) {
+    await this.#requireProcess(name).start();
+  }
+  /** Every service carrying `group`, in dependency order. */
+  servicesInGroup(group) {
+    return this.stack.services.filter((service) => service.groups.includes(group)).map((service) => service.name);
+  }
+  #requireProcess(name) {
+    const process2 = this.#processes.get(name);
+    if (!process2) {
+      const available = [...this.#processes.keys()].join(", ");
+      throw new Error(`no service "${name}" in stack "${this.stack.name}". Available: ${available}`);
+    }
+    return process2;
+  }
+};
+
+// src/cli/render/output.ts
+import "events";
+var closed = false;
+var handlers = /* @__PURE__ */ new Set();
+var onOutputClosed = (handler) => {
+  handlers.add(handler);
+  if (closed) handler();
+  return () => {
+    handlers.delete(handler);
+  };
+};
+var markClosed = () => {
+  if (closed) return;
+  closed = true;
+  for (const handler of handlers) {
+    try {
+      handler();
+    } catch {
+    }
+  }
+};
+var isPipeError = (error) => error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED" || error.code === "ERR_STREAM_WRITE_AFTER_END";
+var installPipeGuards = (streams = [process.stdout, process.stderr]) => {
+  for (const stream of streams) {
+    stream.on("error", (error) => {
+      if (isPipeError(error)) {
+        markClosed();
+        return;
+      }
+      throw error;
+    });
+  }
+};
+var write = (text, stream = process.stdout) => {
+  if (closed) return;
+  try {
+    stream.write(text);
+  } catch (error) {
+    if (isPipeError(error)) markClosed();
+    else throw error;
+  }
+};
+
+// src/cli/render/plain.ts
+var time = (date) => `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(
+  date.getSeconds()
+).padStart(2, "0")}`;
+var attachPlainRenderer = (bus, options) => {
+  const write2 = options.write ?? ((text) => write(text));
+  const painter = options.painter ?? paint;
+  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)]));
+  const width = Math.max(8, ...options.stack.services.map((service) => service.name.length), "laracrew".length);
+  const line = (service, text, colorName = colorOf.get(service) ?? "cyan") => {
+    const stamp2 = showTime ? painter("gray", `${time(now())} `) : "";
+    const prefix = painter(colorName, padEnd(service, width));
+    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 handle = (event) => {
+    switch (event.type) {
+      case "service:log":
+        line(event.log.service, event.log.line);
+        break;
+      case "stack:starting": {
+        system(`starting ${event.stack} (${event.services.length} services)`);
+        const manual = options.stack.services.filter((service) => !service.autostart && !service.external);
+        if (manual.length > 0) {
+          system(`not launched (autostart: false): ${manual.map((service) => service.name).join(", ")}`);
+        }
+        break;
+      }
+      case "stack:ready":
+        system(`${event.stack} ready in ${(event.durationMs / 1e3).toFixed(1)}s`);
+        break;
+      case "stack:stopping":
+        system(`stopping ${event.stack}\u2026`);
+        break;
+      case "stack:stopped":
+        system(`${event.stack} stopped`);
+        break;
+      case "service:spawned":
+        line(event.service, painter("gray", `$ ${event.command}`));
+        break;
+      case "service:ready":
+        line(event.service, painter("green", `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}`})`)
+          );
+        }
+        break;
+      case "service:restart":
+        line(
+          event.service,
+          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}` : ""}`));
+        }
+        break;
+      case "notice":
+        if (event.service) {
+          line(event.service, painter(event.level === "error" ? "red" : "yellow", event.message));
+        } else {
+          system(event.message, event.level);
+        }
+        break;
+      default:
+        break;
+    }
+  };
+  return bus.subscribe(handle);
+};
+
+// src/tui/model.ts
+var commandOf = (supervisor, name) => {
+  const service = supervisor.stack.services.find((entry) => entry.name === name);
+  if (!service?.command) return void 0;
+  return service.command.kind === "shell" ? service.command.line : [service.command.file, ...service.command.args].join(" ");
+};
+var buildStackView = (supervisor) => {
+  const all = supervisor.processes.map((managed) => ({
+    index: -1,
+    // assigned below, once externals are out of the way
+    name: managed.service.name,
+    state: managed.state,
+    pid: managed.pid,
+    uptimeMs: managed.uptimeMs,
+    restarts: managed.restarts,
+    external: managed.service.external,
+    autostart: managed.service.autostart,
+    probe: managed.service.ready ? describeProbe(managed.service.ready) : void 0,
+    project: managed.service.project?.key,
+    command: commandOf(supervisor, managed.service.name),
+    cwd: managed.service.cwd,
+    url: managed.service.url,
+    groups: managed.service.groups,
+    logLines: managed.logs.size
+  }));
+  const dependencies2 = all.filter((row) => row.external);
+  const rows = all.filter((row) => !row.external).map((row, index) => ({ ...row, index }));
+  return {
+    name: supervisor.stack.name,
+    rows,
+    dependencies: dependencies2,
+    running: rows.filter((row) => row.state === "running" || row.state === "ready").length,
+    total: rows.length,
+    restarts: rows.reduce((sum, row) => sum + row.restarts, 0),
+    failed: rows.filter((row) => row.state === "failed" || row.state === "crashed").length,
+    dependenciesDown: dependencies2.filter((row) => row.state !== "ready" && row.state !== "running").length
+  };
+};
+var logsFor = (supervisor, name, limit) => supervisor.get(name)?.logs.tail(limit) ?? [];
+var mergedLogs = (supervisor, limit) => {
+  const perService = Math.max(20, Math.ceil(limit / Math.max(1, supervisor.processes.length)) * 4);
+  const all = [];
+  for (const managed of supervisor.processes) all.push(...managed.logs.tail(perService));
+  all.sort((a, b) => a.at - b.at);
+  return all.slice(-limit);
+};
+
+// src/tui/keys.ts
+var none = (ui) => ({ ui, command: { type: "none" } });
+var handleKey = (ui, key, rowCount) => {
+  if (key.ctrl && key.name === "c") {
+    return { ui: { ...ui, confirmQuit: false }, command: { type: ui.phase === "stopping" ? "force-quit" : "quit" } };
+  }
+  if (ui.confirmQuit) {
+    if (key.name === "y" || key.name === "return") {
+      return { ui: { ...ui, confirmQuit: false }, command: { type: "quit" } };
+    }
+    return none({ ...ui, confirmQuit: false, note: "Ready for commands." });
+  }
+  if (ui.view === "help") {
+    return none({ ...ui, view: "overview" });
+  }
+  const clamp = (index) => Math.min(Math.max(0, index), Math.max(0, rowCount - 1));
+  const inLogView = ui.view === "log" || ui.view === "merged";
+  switch (key.name) {
+    case "q":
+      return none({ ...ui, confirmQuit: true });
+    case "?":
+      return none({ ...ui, view: "help" });
+    case "escape":
+      return none({ ...ui, view: "overview", scrollBack: 0, follow: true });
+    case "s":
+      if (inLogView) return none({ ...ui, view: "overview", scrollBack: 0, follow: true });
+      return { ui, command: { type: "toggle", index: ui.selected } };
+    case "t":
+      return { ui, command: { type: "toggle", index: ui.selected } };
+    case "r":
+      return { ui, command: { type: "restart", index: ui.selected } };
+    case "a":
+      return none({ ...ui, view: ui.view === "merged" ? "overview" : "merged", scrollBack: 0, follow: true });
+    case "return":
+    case "v":
+      if (ui.view === "overview") return none({ ...ui, view: "log", scrollBack: 0, follow: true });
+      return none(ui);
+    case "up":
+    case "k":
+      if (inLogView) return none({ ...ui, scrollBack: ui.scrollBack + 1, follow: false });
+      return none({ ...ui, selected: clamp(ui.selected - 1) });
+    case "down":
+    case "j":
+      if (inLogView) {
+        const scrollBack = Math.max(0, ui.scrollBack - 1);
+        return none({ ...ui, scrollBack, follow: scrollBack === 0 });
+      }
+      return none({ ...ui, selected: clamp(ui.selected + 1) });
+    case "pageup":
+      if (inLogView) return none({ ...ui, scrollBack: ui.scrollBack + 10, follow: false });
+      return none({ ...ui, selected: clamp(ui.selected - 5) });
+    case "pagedown":
+      if (inLogView) {
+        const scrollBack = Math.max(0, ui.scrollBack - 10);
+        return none({ ...ui, scrollBack, follow: scrollBack === 0 });
+      }
+      return none({ ...ui, selected: clamp(ui.selected + 5) });
+    case "g":
+      if (inLogView) {
+        return key.shift ? none({ ...ui, scrollBack: 0, follow: true }) : none({ ...ui, scrollBack: Number.MAX_SAFE_INTEGER, follow: false });
+      }
+      return none({ ...ui, selected: key.shift ? clamp(rowCount - 1) : 0 });
+    case "f":
+      if (inLogView) return none({ ...ui, follow: !ui.follow, scrollBack: ui.follow ? ui.scrollBack : 0 });
+      return none(ui);
+    case "home":
+      return inLogView ? none({ ...ui, scrollBack: Number.MAX_SAFE_INTEGER, follow: false }) : none({ ...ui, selected: 0 });
+    case "end":
+      return inLogView ? none({ ...ui, scrollBack: 0, follow: true }) : none({ ...ui, selected: clamp(rowCount - 1) });
+    default: {
+      if (/^[0-9]$/.test(key.name)) {
+        const index = Number(key.name);
+        if (index < rowCount) {
+          return none({ ...ui, selected: index, view: "log", scrollBack: 0, follow: true });
+        }
+      }
+      return none(ui);
+    }
+  }
+};
+
+// 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",
+  selected: 0,
+  follow: true,
+  scrollBack: 0,
+  confirmQuit: false,
+  phase: "booting",
+  note: "Booting\u2026"
+});
+var pad = (text, width) => {
+  const visible = stripAnsi(text).length;
+  return visible >= width ? text : text + " ".repeat(width - visible);
+};
+var truncate = (text, width) => {
+  if (width <= 1) return "";
+  return stripAnsi(text).length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
+};
+var rule = (width, glyph) => glyph.rule.repeat(Math.max(0, width));
+var header = ({ stack, ui, size, paint: paint2, glyph, uptimeMs }) => {
+  const title = `laracrew ${glyph.dot} ${stack.name}`;
+  const health = stack.failed > 0 ? paint2("red", `${stack.failed} failed`) : stack.dependenciesDown > 0 ? paint2("red", `${stack.dependenciesDown} dependency down`) : ui.phase === "booting" ? paint2("yellow", "booting") : paint2("green", "all healthy");
+  const idle = stack.rows.filter((entry) => !entry.autostart && entry.state === "queued").length;
+  const right = [
+    `up ${formatUptime(uptimeMs)}`,
+    `${stack.running}/${stack.total} running`,
+    idle > 0 ? `${idle} idle` : "",
+    stack.restarts > 0 ? `${glyph.restart}${stack.restarts}` : ""
+  ].filter(Boolean).join(`  ${glyph.dot} `);
+  const left = `  ${paint2("bold", title)}`;
+  const gap = Math.max(1, size.columns - stripAnsi(left).length - stripAnsi(right).length - stripAnsi(health).length - 5);
+  return [
+    "",
+    `${left}${" ".repeat(gap)}${paint2("gray", right)}  ${health}`,
+    paint2("gray", `  ${rule(Math.max(0, size.columns - 4), glyph)}`)
+  ];
+};
+var KEYS = {
+  overview: [
+    ["up/down", "select"],
+    ["enter", "inspect log"],
+    ["0-9", "jump"],
+    ["r", "restart"],
+    ["s", "stop/start"],
+    ["a", "all logs"],
+    ["?", "help"],
+    ["q", "quit"]
+  ],
+  log: [
+    ["esc", "back to stack"],
+    ["up/down", "scroll"],
+    ["g/G", "top/bottom"],
+    ["f", "follow"],
+    ["r", "restart"],
+    ["q", "quit"]
+  ],
+  merged: [
+    ["esc", "back to stack"],
+    ["up/down", "scroll"],
+    ["g/G", "top/bottom"],
+    ["f", "follow"],
+    ["q", "quit"]
+  ],
+  help: [["any key", "back"]]
+};
+var legend = ({ ui, paint: paint2, size }) => {
+  const pairs = KEYS[ui.view].map(([key, label]) => `${paint2("cyan", key)} ${paint2("gray", label)}`);
+  const lines = [];
+  let current = "  ";
+  let currentWidth = 2;
+  for (const pair of pairs) {
+    const width = stripAnsi(pair).length + 3;
+    if (currentWidth + width > size.columns - 2 && currentWidth > 2) {
+      lines.push(current);
+      current = "  ";
+      currentWidth = 2;
+    }
+    current += `${pair}   `;
+    currentWidth += width;
+  }
+  if (currentWidth > 2) lines.push(current);
+  return lines;
+};
+var processLine = (row, isSelected, isLast, nameWidth, { paint: paint2, glyph, size }) => {
+  const style = STATE_STYLE[row.state];
+  const branch = isLast ? glyph.lastBranch : glyph.branch;
+  const pointer = isSelected ? paint2("cyan", glyph.pointer) : " ";
+  const name = isSelected ? paint2("cyan", pad(row.name, nameWidth)) : pad(row.name, nameWidth);
+  const manual = !row.autostart && row.state === "queued";
+  const label = manual ? "idle" : style.label.toLowerCase();
+  const labelColor = manual ? "gray" : style.color;
+  const detail = row.external ? paint2("gray", "external") : manual ? paint2("cyan", "press s") : row.state === "running" || row.state === "ready" ? paint2("gray", formatDuration(row.uptimeMs)) : "";
+  const restarts = row.restarts > 0 ? paint2("yellow", ` ${glyph.restart}${row.restarts}`) : "";
+  const line = `  ${paint2("gray", branch)} ${pointer} ${paint2("gray", `[${row.index}]`)} ${paint2(labelColor, glyph[style.glyph])} ${name}${paint2(labelColor, pad(label, 11))}${pad(detail, 9)}${restarts}`;
+  return truncate(line, size.columns + (line.length - stripAnsi(line).length));
+};
+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 ?? "")}`;
+  return truncate(line, size.columns + (line.length - stripAnsi(line).length));
+};
+var dependencies = (input, nameWidth) => {
+  const { stack, paint: paint2 } = input;
+  if (stack.dependencies.length === 0) return [];
+  return [
+    `  ${paint2("bold", "DEPENDENT SERVICES")} ${paint2("gray", "(checked, not managed)")}`,
+    ...stack.dependencies.map((row) => dependencyLine(row, nameWidth, input)),
+    ""
+  ];
+};
+var overview = (input, bodyRows) => {
+  const { stack, ui, paint: paint2, glyph } = input;
+  const nameWidth = Math.max(12, ...[...stack.rows, ...stack.dependencies].map((row) => row.name.length)) + 2;
+  const dependencyLines = dependencies(input, nameWidth);
+  const lines = [
+    `  ${paint2("bold", "STACK DETAILS")} ${paint2("gray", "(process tree)")}`,
+    "",
+    ...dependencyLines,
+    `  ${paint2("gray", `processes (${stack.rows.length} managed)`)}`,
+    paint2("gray", `  ${glyph.pipe}`)
+  ];
+  if (stack.rows.length === 0) {
+    lines.push(`  ${paint2("gray", `${glyph.lastBranch} nothing to manage in this stack`)}`);
+    return lines;
+  }
+  const capacity = Math.max(3, bodyRows - 5 - dependencyLines.length);
+  let start = 0;
+  if (stack.rows.length > capacity) {
+    start = Math.min(Math.max(0, ui.selected - Math.floor(capacity / 2)), stack.rows.length - capacity);
+  }
+  const visible = stack.rows.slice(start, start + capacity);
+  if (start > 0) lines.push(paint2("gray", `  ${glyph.pipe}  ${start} more above`));
+  for (const [offset, row] of visible.entries()) {
+    const index = start + offset;
+    lines.push(processLine(row, index === ui.selected, index === stack.rows.length - 1, nameWidth, input));
+  }
+  const hiddenBelow = stack.rows.length - (start + visible.length);
+  if (hiddenBelow > 0) lines.push(paint2("gray", `  ${glyph.pipe}  ${hiddenBelow} more below`));
+  lines.push(paint2("gray", `  ${glyph.pipe}`));
+  lines.push(`  ${paint2("gray", `${glyph.lastBranch} ${input.ui.note}`)}`);
+  return lines;
+};
+var logHeader = (row, input) => {
+  const { paint: paint2, glyph, size } = input;
+  if (!row) return [`  ${paint2("gray", "no process selected")}`];
+  const style = STATE_STYLE[row.state];
+  const meta = [
+    paint2(style.color, style.label.toLowerCase()),
+    row.pid !== void 0 ? paint2("gray", `pid ${row.pid}`) : "",
+    row.state === "running" ? paint2("gray", `up ${formatDuration(row.uptimeMs)}`) : "",
+    row.restarts > 0 ? paint2("yellow", `${glyph.restart}${row.restarts}`) : ""
+  ].filter(Boolean).join(paint2("gray", `  ${glyph.dot} `));
+  const lines = [`  ${paint2("bold", row.name)}   ${meta}`];
+  if (row.command) lines.push(`  ${paint2("gray", truncate(`$ ${row.command}`, size.columns - 4))}`);
+  lines.push(`  ${paint2("gray", truncate(row.cwd, size.columns - 4))}`);
+  lines.push(paint2("gray", `  ${rule(Math.max(0, size.columns - 4), glyph)}`));
+  return lines;
+};
+var logBody = (input, bodyRows, withServiceName) => {
+  const { logs, ui, paint: paint2, size } = input;
+  const capacity = Math.max(1, bodyRows);
+  if (logs.length === 0) {
+    return [`  ${paint2("gray", "no output yet")}`];
+  }
+  const end = Math.max(capacity, logs.length - ui.scrollBack);
+  const window = logs.slice(Math.max(0, end - capacity), end);
+  const nameWidth = withServiceName ? Math.max(...logs.map((line) => line.service.length)) : 0;
+  return window.map((line) => {
+    const stamp2 = paint2("gray", formatClock(line.at));
+    const who = withServiceName ? ` ${paint2("cyan", pad(line.service, nameWidth))}` : "";
+    const body = line.stream === "stderr" ? paint2("red", line.line) : line.line;
+    const rendered = `  ${stamp2}${who} ${paint2("gray", "|")} ${body}`;
+    return truncate(rendered, size.columns + (rendered.length - stripAnsi(rendered).length));
+  });
+};
+var help = ({ paint: paint2, glyph }) => [
+  `  ${paint2("bold", "KEYS")}`,
+  "",
+  ...[
+    ["up / down, j / k", "move the selection"],
+    ["0 - 9", "jump straight to that process and open its log"],
+    ["enter, v", "inspect the selected process log"],
+    ["esc, s", "back to the stack overview"],
+    ["a", "merged log across every service"],
+    ["r", "restart the selected process (graceful)"],
+    ["t", "toggle the selected process: stop if running, start if stopped"],
+    ["f", "follow / pause tailing in a log view"],
+    ["g / G", "jump to the top / bottom of a log"],
+    ["?", "this help"],
+    ["q, ctrl-c", "quit \u2014 stops every process first"]
+  ].map(([key, label]) => `    ${paint2("cyan", pad(key, 20))}${paint2("gray", label)}`),
+  "",
+  `  ${paint2("gray", `The overview never streams logs \u2014 that is deliberate. Open one ${glyph.dot} read it ${glyph.dot} go back.`)}`
+];
+var renderShutdown = (input) => {
+  const { stack, paint: paint2, glyph } = input;
+  const lines = ["", `  ${paint2("bold", `Stopping ${stack.name}\u2026`)}`, ""];
+  for (const row of stack.rows) {
+    const done = row.state === "stopped" || row.state === "failed";
+    const mark = done ? paint2("green", glyph.tick) : paint2("yellow", glyph.starting);
+    const label = done ? paint2("gray", "stopped") : paint2("yellow", "stopping\u2026");
+    lines.push(`  ${mark} ${pad(row.name, 22)}${label}`);
+  }
+  lines.push("", `  ${paint2("gray", "ctrl-c again to force")}`);
+  return lines;
+};
+var renderFrame = (input) => {
+  if (input.ui.phase === "stopping") return renderShutdown(input);
+  const top = header(input);
+  const keys = legend(input);
+  const chrome = top.length + keys.length + 3;
+  const bodyRows = Math.max(3, input.size.rows - chrome);
+  let body;
+  switch (input.ui.view) {
+    case "help":
+      body = help(input);
+      break;
+    case "log": {
+      const row = input.stack.rows[input.ui.selected];
+      const head = logHeader(row, input);
+      body = [...head, ...logBody(input, bodyRows - head.length, false)];
+      break;
+    }
+    case "merged":
+      body = [
+        `  ${input.paint("bold", "ALL SERVICES")}`,
+        input.paint("gray", `  ${rule(Math.max(0, input.size.columns - 4), input.glyph)}`),
+        ...logBody(input, bodyRows - 2, true)
+      ];
+      break;
+    default:
+      body = overview(input, bodyRows);
+  }
+  const status = input.ui.confirmQuit ? `  ${input.paint("yellow", "Quit and stop every process? (y/n)")}` : input.ui.view !== "overview" ? `  ${input.paint("gray", input.ui.note)}` : "";
+  return [...top, "", ...keys, ...body, "", ...status ? [status] : []];
+};
+
+// src/tui/terminal.ts
+import readline from "readline";
+var ESC2 = String.fromCharCode(27);
+var CSI2 = `${ESC2}[`;
+var codes = {
+  altScreenOn: `${CSI2}?1049h`,
+  altScreenOff: `${CSI2}?1049l`,
+  hideCursor: `${CSI2}?25l`,
+  showCursor: `${CSI2}?25h`,
+  home: `${CSI2}H`,
+  clearLine: `${CSI2}K`,
+  clearBelow: `${CSI2}J`
+};
+var Terminal = class {
+  #stdout;
+  #stdin;
+  #lastFrame = [];
+  #active = false;
+  #onKey;
+  #onResize;
+  #keyListener;
+  #resizeListener;
+  constructor(options = {}) {
+    this.#stdout = options.stdout ?? process.stdout;
+    this.#stdin = options.stdin ?? process.stdin;
+  }
+  get size() {
+    return {
+      columns: Math.max(40, this.#stdout.columns ?? 80),
+      rows: Math.max(10, this.#stdout.rows ?? 24)
+    };
+  }
+  start(handlers2) {
+    if (this.#active) return;
+    this.#active = true;
+    this.#onKey = handlers2.onKey;
+    if (handlers2.onResize) this.#onResize = handlers2.onResize;
+    this.#stdout.write(codes.altScreenOn + codes.hideCursor);
+    readline.emitKeypressEvents(this.#stdin);
+    if (this.#stdin.isTTY) this.#stdin.setRawMode(true);
+    this.#stdin.resume();
+    this.#keyListener = (_str, key) => {
+      if (!key) return;
+      this.#onKey?.({
+        name: key.name ?? key.sequence ?? "",
+        ...key.ctrl ? { ctrl: true } : {},
+        ...key.shift ? { shift: true } : {}
+      });
+    };
+    this.#stdin.on("keypress", this.#keyListener);
+    this.#resizeListener = () => {
+      this.#lastFrame = [];
+      this.#onResize?.();
+    };
+    this.#stdout.on("resize", this.#resizeListener);
+  }
+  /** Repaints only the lines that changed. */
+  paint(lines) {
+    if (!this.#active) return;
+    const { rows, columns } = this.size;
+    const frame = lines.slice(0, rows - 1).map((line) => clip(line, columns));
+    let output = codes.home;
+    const height = Math.max(frame.length, this.#lastFrame.length);
+    for (let index = 0; index < height; index += 1) {
+      const line = frame[index] ?? "";
+      if (this.#lastFrame[index] === line) {
+        output += `${CSI2}${index + 2};1H`;
+        continue;
+      }
+      output += `${CSI2}${index + 1};1H${line}${codes.clearLine}`;
+    }
+    output += codes.clearBelow;
+    this.#stdout.write(output);
+    this.#lastFrame = frame;
+  }
+  stop() {
+    if (!this.#active) return;
+    this.#active = false;
+    if (this.#keyListener) this.#stdin.off("keypress", this.#keyListener);
+    if (this.#resizeListener) this.#stdout.off("resize", this.#resizeListener);
+    if (this.#stdin.isTTY) this.#stdin.setRawMode(false);
+    this.#stdin.pause();
+    this.#stdout.write(codes.showCursor + codes.altScreenOff);
+    this.#lastFrame = [];
+  }
+};
+var clip = (line, columns) => {
+  const visible = stripAnsi(line).length;
+  if (visible <= columns) return line;
+  let out = "";
+  let width = 0;
+  let index = 0;
+  while (index < line.length && width < columns) {
+    if (line[index] === ESC2) {
+      const end = line.indexOf("m", index);
+      if (end === -1) break;
+      out += line.slice(index, end + 1);
+      index = end + 1;
+      continue;
+    }
+    out += line[index];
+    width += 1;
+    index += 1;
+  }
+  return out;
+};
+
+// src/tui/app.ts
+var MAX_LOG_LINES = 400;
+var runTui = async (supervisor, bus, options = {}) => {
+  const env = options.env ?? process.env;
+  const stdout = options.stdout ?? process.stdout;
+  const terminal = new Terminal({
+    stdout,
+    ...options.stdin ? { stdin: options.stdin } : {}
+  });
+  const basePainter = createPainter(supportsColor(stdout, env));
+  const paint2 = Object.assign(
+    (color, text) => basePainter(color, text),
+    { enabled: basePainter.enabled }
+  );
+  const glyph = glyphs(env);
+  const startedAt = Date.now();
+  let ui = initialUiState();
+  let exitCode = 0;
+  let stopping = false;
+  let finished = false;
+  const setNote = (note) => {
+    ui = { ...ui, note };
+  };
+  const unsubscribe = bus.subscribe((event) => {
+    switch (event.type) {
+      case "stack:ready":
+        ui = { ...ui, phase: "running" };
+        setNote(`Ready in ${(event.durationMs / 1e3).toFixed(1)}s. Awaiting keyboard input\u2026`);
+        break;
+      case "service:restart":
+        setNote(`${event.service} restarting in ${event.delayMs}ms (attempt ${event.attempt}/${event.maxAttempts})`);
+        break;
+      case "service:exit":
+        if (!event.intentional) {
+          setNote(`${event.service} exited with ${event.signal ? `signal ${event.signal}` : `code ${event.code}`}`);
+        }
+        break;
+      case "notice":
+        if (event.level !== "info") setNote(`${event.service ? `${event.service}: ` : ""}${event.message}`);
+        break;
+      default:
+        break;
+    }
+  });
+  const draw = () => {
+    const stack = buildStackView(supervisor);
+    const selectedRow = stack.rows[ui.selected];
+    const logs = ui.view === "log" && selectedRow ? logsFor(supervisor, selectedRow.name, MAX_LOG_LINES) : ui.view === "merged" ? mergedLogs(supervisor, MAX_LOG_LINES) : [];
+    terminal.paint(
+      renderFrame({
+        stack,
+        ui,
+        size: terminal.size,
+        glyph,
+        paint: paint2,
+        logs,
+        uptimeMs: Date.now() - startedAt
+      })
+    );
+  };
+  const shutdown = async (reason) => {
+    if (stopping) return;
+    stopping = true;
+    ui = { ...ui, phase: "stopping" };
+    draw();
+    await supervisor.down(reason);
+    finished = true;
+  };
+  const perform = (command) => {
+    const stack = buildStackView(supervisor);
+    const row = stack.rows[command.type === "none" || command.type === "quit" || command.type === "force-quit" ? ui.selected : command.index];
+    switch (command.type) {
+      case "quit":
+        void shutdown("user quit");
+        break;
+      case "force-quit":
+        terminal.stop();
+        process.exit(130);
+        break;
+      case "restart":
+        if (!row) break;
+        setNote(`restarting ${row.name}\u2026`);
+        void supervisor.restart(row.name).then(() => setNote(`${row.name} restarted`)).catch((error) => setNote(`restart failed: ${error instanceof Error ? error.message : String(error)}`));
+        break;
+      case "toggle": {
+        if (!row) break;
+        if (row.external) {
+          setNote(`${row.name} is external \u2014 laracrew does not start or stop it`);
+          break;
+        }
+        const live = row.state === "running" || row.state === "ready" || row.state === "starting";
+        setNote(`${live ? "stopping" : "starting"} ${row.name}\u2026`);
+        const action = live ? supervisor.stopService(row.name) : supervisor.startService(row.name);
+        void action.then(() => setNote(`${row.name} ${live ? "stopped" : "started"}`)).catch((error) => setNote(error instanceof Error ? error.message : String(error)));
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  terminal.start({
+    onKey: (key) => {
+      const rowCount = buildStackView(supervisor).rows.length;
+      const result = handleKey(ui, key, rowCount);
+      ui = result.ui;
+      perform(result.command);
+      draw();
+    },
+    onResize: draw
+  });
+  const timer = setInterval(draw, options.frameMs ?? 250);
+  timer.unref?.();
+  const onSignal = () => {
+    void shutdown("received signal");
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  draw();
+  try {
+    await supervisor.up();
+  } catch (error) {
+    ui = { ...ui, phase: "running" };
+    setNote(error instanceof Error ? error.message : String(error));
+    exitCode = 1;
+    draw();
+  }
+  await new Promise((resolve) => {
+    const check = setInterval(() => {
+      if (finished) {
+        clearInterval(check);
+        resolve();
+        return;
+      }
+      if (stopping) return;
+      const anyLive = supervisor.processes.some(
+        (managed) => managed.state !== "stopped" && managed.state !== "failed"
+      );
+      if (!anyLive) {
+        clearInterval(check);
+        void shutdown("all services finished").then(resolve);
+      }
+    }, 200);
+    check.unref?.();
+  });
+  clearInterval(timer);
+  process.off("SIGINT", onSignal);
+  process.off("SIGTERM", onSignal);
+  unsubscribe();
+  terminal.stop();
+  return exitCode;
+};
+
+// src/cli/commands/up.ts
+var splitList = (values) => (values ?? []).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+var prepareStack = (name, options = {}) => {
+  const env = options.env ?? process.env;
+  const loaded = loadStack(name, env);
+  return resolveStack(loaded, {
+    sharedProjects: loadSharedProjects(env),
+    env,
+    ...options.profile ? { profile: options.profile } : {},
+    only: splitList(options.only),
+    except: splitList(options.except)
+  });
+};
+var attachJsonRenderer = (bus) => bus.subscribe((event) => process.stdout.write(`${JSON.stringify(event)}
+`));
+var shouldUseTui = (options, stdout = process.stdout) => !options.plain && !options.json && Boolean(stdout.isTTY);
+var upCommand = async (name, options = {}) => {
+  const stack = prepareStack(name, options);
+  const bus = new EventBus();
+  if (shouldUseTui(options)) {
+    const supervisor2 = new Supervisor(stack, bus, options.env ? { env: options.env } : {});
+    return runTui(supervisor2, bus, options.env ? { env: options.env } : {});
+  }
+  const detach = options.json ? attachJsonRenderer(bus) : attachPlainRenderer(bus, { stack });
+  const supervisor = new Supervisor(stack, bus, options.env ? { env: options.env } : {});
+  let exitCode = 0;
+  let stopping = false;
+  const shutdown = async (reason) => {
+    if (stopping) return;
+    stopping = true;
+    await supervisor.down(reason);
+  };
+  const onSignal = (signal) => {
+    if (stopping) {
+      console.error(paint("red", "\nforced exit \u2014 some children may survive"));
+      process.exit(130);
+    }
+    void shutdown(`received ${signal}`);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const releaseOutputHook = onOutputClosed(() => {
+    void shutdown("output closed");
+  });
+  try {
+    await supervisor.up();
+    await waitUntilIdle(supervisor, () => stopping);
+  } catch (error) {
+    console.error(paint("red", error instanceof Error ? error.message : String(error)));
+    exitCode = 1;
+  } finally {
+    await shutdown("done");
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    releaseOutputHook();
+    detach();
+  }
+  return exitCode;
+};
+var waitUntilIdle = (supervisor, stopRequested) => new Promise((resolve) => {
+  const check = () => {
+    if (stopRequested()) {
+      clearInterval(timer);
+      resolve();
+      return;
+    }
+    const anyLive = supervisor.processes.some(
+      (process2) => process2.state !== "stopped" && process2.state !== "failed"
+    );
+    if (!anyLive) {
+      clearInterval(timer);
+      resolve();
+    }
+  };
+  const timer = setInterval(check, 250);
+  timer.unref?.();
+});
+
+// src/cli/commands/doctor.ts
+var PORT_IN_COMMAND = /--port[= ](\d{2,5})/g;
+var declaredPorts = (stack) => {
+  const ports = new Set(stack.ports);
+  for (const service of stack.services) {
+    const line = service.command?.kind === "shell" ? service.command.line : service.command ? [service.command.file, ...service.command.args].join(" ") : "";
+    for (const match of line.matchAll(PORT_IN_COMMAND)) {
+      const port = Number(match[1]);
+      if (Number.isInteger(port)) ports.add(port);
+    }
+  }
+  return [...ports].sort((a, b) => a - b);
+};
+var redisTargetOf = (project) => `${project.env.REDIS_HOST ?? "127.0.0.1"}:${project.env.REDIS_PORT ?? "6379"}`;
+var slug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var redisPrefixOf = (project) => project.env.REDIS_PREFIX ?? `${slug(project.env.APP_NAME ?? "laravel")}_database_`;
+var redisNamespaceOf = (project) => `${redisTargetOf(project)}/${project.env.REDIS_DB ?? "0"}#${redisPrefixOf(project)}`;
+var checkProjects = (stack) => {
+  const findings = [];
+  for (const project of Object.values(stack.projects)) {
+    if (!existsSync4(project.path)) {
+      findings.push({ level: "error", message: `project "${project.key}": path does not exist \u2014 ${project.path}` });
+      continue;
+    }
+    if (!existsSync4(path7.join(project.path, "artisan"))) {
+      findings.push({
+        level: "warn",
+        message: `project "${project.key}": no \`artisan\` file in ${project.path}`,
+        hint: "laracrew will still run the commands, but this does not look like a Laravel root"
+      });
+    }
+    if (Object.keys(project.env).length === 0) {
+      findings.push({
+        level: "warn",
+        message: `project "${project.key}": ${project.envFile} is missing or empty`,
+        hint: "queue/Redis checks and ${project.env:...} tokens need it"
+      });
+    }
+  }
+  return findings;
+};
+var checkRedisCollisions = (stack) => {
+  const findings = [];
+  const projects = Object.values(stack.projects);
+  const byNamespace = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    const namespace = redisNamespaceOf(project);
+    byNamespace.set(namespace, [...byNamespace.get(namespace) ?? [], project]);
+  }
+  for (const [namespace, sharing] of byNamespace) {
+    if (sharing.length < 2) continue;
+    const queuesByProject = /* @__PURE__ */ new Map();
+    const streamsByProject = /* @__PURE__ */ new Map();
+    for (const service of stack.services) {
+      if (!service.project || !service.metrics) continue;
+      const key = service.project.key;
+      for (const queue of service.metrics.queues) {
+        queuesByProject.set(key, (queuesByProject.get(key) ?? /* @__PURE__ */ new Set()).add(queue));
+      }
+      for (const stream of service.metrics.streams) {
+        streamsByProject.set(key, (streamsByProject.get(key) ?? /* @__PURE__ */ new Set()).add(`${stream.key}/${stream.group}`));
+      }
+    }
+    const names = sharing.map((project) => project.key);
+    const overlap = (map) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const key of names) {
+        for (const value of map.get(key) ?? []) counts.set(value, (counts.get(value) ?? 0) + 1);
+      }
+      return [...counts.entries()].filter(([, count]) => count > 1).map(([value]) => value);
+    };
+    const sharedQueues = overlap(queuesByProject);
+    const sharedStreams = overlap(streamsByProject);
+    if (sharedQueues.length > 0) {
+      findings.push({
+        level: "error",
+        message: `${names.join(" and ")} share Redis ${namespace} AND queue(s): ${sharedQueues.join(", ")}`,
+        hint: "each project's workers will steal the other's jobs \u2014 set a different REDIS_DB or REDIS_PREFIX"
+      });
+    }
+    if (sharedStreams.length > 0) {
+      findings.push({
+        level: "error",
+        message: `${names.join(" and ")} share Redis ${namespace} AND stream/group: ${sharedStreams.join(", ")}`,
+        hint: "two consumers in one group split the entries between them \u2014 give each project its own group name"
+      });
+    }
+    if (sharedQueues.length === 0 && sharedStreams.length === 0) {
+      findings.push({
+        level: "warn",
+        message: `${names.join(" and ")} share Redis ${namespace}`,
+        hint: "no queue or stream overlap declared, but cache and session keys can still collide"
+      });
+    }
+  }
+  const byServer = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    const server = `${redisTargetOf(project)}/${project.env.REDIS_DB ?? "0"}`;
+    byServer.set(server, [...byServer.get(server) ?? [], project]);
+  }
+  for (const [server, sharing] of byServer) {
+    if (sharing.length < 2) continue;
+    const prefixes = new Set(sharing.map(redisPrefixOf));
+    if (prefixes.size === sharing.length) {
+      findings.push({
+        level: "ok",
+        message: `${sharing.map((p) => p.key).join(" and ")} share Redis ${server} but are isolated by prefix (${[...prefixes].join(", ")})`
+      });
+    }
+  }
+  return findings;
+};
+var checkQueueConnections = (stack) => {
+  const findings = [];
+  const workerProjects = new Set(
+    stack.services.filter((service) => {
+      if (!service.autostart) return false;
+      const line = service.command?.kind === "shell" ? service.command.line : service.command ? [service.command.file, ...service.command.args].join(" ") : "";
+      return /\b(queue:work|queue:listen|horizon)\b/.test(line);
+    }).map((service) => service.project?.key).filter((key) => Boolean(key))
+  );
+  for (const key of workerProjects) {
+    const project = stack.projects[key];
+    if (!project) continue;
+    const connection = project.env.QUEUE_CONNECTION;
+    if (connection === void 0) continue;
+    if (connection === "sync") {
+      findings.push({
+        level: "error",
+        message: `project "${key}" runs a queue worker but QUEUE_CONNECTION=sync`,
+        hint: "jobs run inline on dispatch, so the worker will sit idle forever \u2014 set it to redis or database"
+      });
+    }
+  }
+  return findings;
+};
+var checkPhp = async (stack) => {
+  const binaries = new Set(Object.values(stack.projects).map((project) => project.php));
+  const findings = [];
+  for (const binary of binaries) {
+    try {
+      const result = await runOnce({ kind: "argv", file: binary, args: ["--version"] }, {
+        cwd: process.cwd(),
+        timeoutMs: 8e3
+      });
+      if (result.code === 0) {
+        const version = result.stdout.split("\n")[0]?.trim() ?? "";
+        findings.push({ level: "ok", message: `php: ${version}` });
+      } else {
+        findings.push({ level: "error", message: `"${binary} --version" exited with code ${result.code}` });
+      }
+    } catch {
+      findings.push({
+        level: "error",
+        message: `cannot run "${binary}"`,
+        hint: "put PHP on PATH, or set an absolute path in projects.yaml"
+      });
+    }
+  }
+  return findings;
+};
+var checkPorts = async (stack) => {
+  const findings = [];
+  for (const port of declaredPorts(stack)) {
+    const free = await isPortFree(port);
+    findings.push(
+      free ? { level: "ok", message: `port ${port} is free` } : {
+        level: "error",
+        message: `port ${port} is already in use`,
+        hint: "something else is bound to it \u2014 a stale worker from a previous run, most likely"
+      }
+    );
+  }
+  return findings;
+};
+var checkRedisReachable = async (stack) => {
+  const targets = new Set(Object.values(stack.projects).map(redisTargetOf));
+  const findings = [];
+  for (const target of targets) {
+    const result = await tcpProbe(target, 2e3);
+    findings.push(
+      result.ok ? { level: "ok", message: `redis reachable at ${target}` } : { level: "warn", message: `redis not reachable at ${target}${result.detail ? ` (${result.detail})` : ""}` }
+    );
+  }
+  return findings;
+};
+var runDoctor = async (stackName, env = process.env) => {
+  let stack;
+  try {
+    stack = prepareStack(stackName, { env });
+  } catch (error) {
+    if (error instanceof ConfigError) return [{ level: "error", message: error.format() }];
+    throw error;
+  }
+  const findings = [
+    { level: "ok", message: `stack "${stack.name}" is valid \u2014 ${stack.services.length} services` },
+    ...checkProjects(stack),
+    ...checkQueueConnections(stack),
+    ...checkRedisCollisions(stack)
+  ];
+  const async = await Promise.all([checkPhp(stack), checkPorts(stack), checkRedisReachable(stack)]);
+  return [...findings, ...async.flat()];
+};
+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") };
+  for (const finding of findings) {
+    console.log(`${glyph[finding.level]} ${finding.message}`);
+    if (finding.hint) console.log(`  ${paint("gray", finding.hint)}`);
+  }
+  const errors = findings.filter((finding) => finding.level === "error").length;
+  const warnings = findings.filter((finding) => finding.level === "warn").length;
+  console.log(
+    `
+${errors === 0 ? paint("green", "no blocking problems") : paint("red", `${errors} problem(s)`)}` + (warnings > 0 ? paint("yellow", `, ${warnings} warning(s)`) : "")
+  );
+  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/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.
+metricsIntervalMs: 2000
+
+# The stack \`laracrew up\` boots when you don't name one.
+# defaultStack: dual
+`;
+var PROJECTS_YAML = `# Your Laravel projects, referenced by key from any stack.
+# Paths may use forward slashes on Windows.
+projects: {}
+
+# Example \u2014 delete the \`{}\` above and uncomment:
+#
+# projects:
+#   api:
+#     path: D:/work/api
+#     php: php            # or an absolute path to a specific PHP build
+#     envFile: .env       # read for QUEUE_CONNECTION, REDIS_*, APP_URL, DB_*
+#     color: cyan
+#   portal:
+#     path: D:/work/portal
+#     php: php
+#     envFile: .env
+#     color: magenta
+`;
+var EXAMPLE_STACK_YAML = `# A runnable demo stack \u2014 no Laravel project required.
+# Try:  laracrew up example
+# Then: laracrew up example --only workers
+name: example
+description: Three fake services that prove laracrew works on this machine
+
+# \`laracrew link example\` installs this as a global command you can run from anywhere.
+command: demo
+
+defaults:
+  restart: on-failure
+  backoff: { initialMs: 500, maxMs: 5000, factor: 2, maxRestarts: 5 }
+  stop: { graceMs: 5000 }
+
+services:
+  - name: demo:heartbeat
+    cmd: ["node", "-e", "let n=0; setInterval(() => console.log('heartbeat ' + (++n)), 1000)"]
+    groups: [workers]
+    color: cyan
+
+  - name: demo:worker
+    cmd: ["node", "-e", "let n=0; setInterval(() => console.log('processed job #' + (++n)), 1700)"]
+    groups: [workers]
+    needs: [demo:heartbeat]
+    color: magenta
+
+  - name: demo:slow-starter
+    cmd: ["node", "-e", "setTimeout(() => console.log('listening on 9'), 1200); setInterval(() => {}, 1000)"]
+    groups: [http]
+    ready: { logMatch: "listening on", timeoutMs: 10000 }
+    color: green
+
+profiles:
+  quiet:
+    except: [http]
+`;
+var REAL_STACK_TEMPLATE = `# Two interconnected Laravel projects: queues, Redis stream listeners, schedulers.
+# Fill in the project paths in ~/.laracrew/projects.yaml first, then:  laracrew up dual
+name: dual
+description: API + Portal with queues, streams and schedulers
+
+# Run \`laracrew link dual\` and this whole set boots by typing \`dual\` from anywhere.
+command: dual
+
+use: [api, portal]
+
+defaults:
+  restart: on-failure
+  backoff: { initialMs: 1000, maxMs: 30000, factor: 2, maxRestarts: 10 }
+  stop: { graceMs: 10000 }
+  logs: { maxLines: 5000, toFile: false }
+
+services:
+  - name: redis
+    external: true              # laracrew checks it, never starts it
+    ready: { tcp: "127.0.0.1:6379" }
+
+  - name: api:serve
+    project: api
+    cmd: php artisan serve --port=\${port:8000}
+    groups: [http]
+    needs: [redis]
+    ready: { http: "http://127.0.0.1:8000/up", timeoutMs: 20000 }
+    url: http://127.0.0.1:8000
+
+  - name: api:queue
+    project: api
+    cmd: php artisan queue:work redis --queue=high,default --tries=3 --timeout=90
+    groups: [workers]
+    needs: [redis]
+    stop: { artisan: "queue:restart", graceMs: 15000 }
+    watch:
+      paths: [app, config, routes, database]
+      strategy: artisan-queue-restart
+      debounceMs: 800
+    metrics:
+      queues: [high, default]
+
+  - name: api:streams
+    project: api
+    cmd: php artisan streams:listen orders
+    groups: [workers, streams]
+    needs: [redis]
+    metrics:
+      streams:
+        - { key: orders, group: api-consumers }
+
+  - name: api:schedule
+    project: api
+    cmd: php artisan schedule:work
+    groups: [workers]
+    needs: [redis]
+
+  - name: portal:serve
+    project: portal
+    cmd: php artisan serve --port=\${port:8001}
+    groups: [http]
+    needs: [redis, api:serve]   # don't boot until the API answers
+    ready: { http: "http://127.0.0.1:8001/up", timeoutMs: 20000 }
+    url: http://127.0.0.1:8001
+
+  - name: portal:queue
+    project: portal
+    cmd: php artisan queue:work redis --queue=default --tries=3
+    groups: [workers]
+    needs: [redis, api:serve]
+    stop: { artisan: "queue:restart" }
+    watch: { paths: [app, config], strategy: artisan-queue-restart }
+    metrics: { queues: [default] }
+
+  - name: portal:streams
+    project: portal
+    cmd: php artisan streams:listen inventory
+    groups: [workers, streams]
+    needs: [redis]
+    metrics:
+      streams:
+        - { key: inventory, group: portal-consumers }
+
+profiles:
+  light:
+    except: [assets]
+  workers-only:
+    only: [workers]
+`;
+var RESET_TASK_YAML = `# laracrew run reset
+name: reset
+description: Wipe and reseed both databases in the right order
+pauseServices: [workers]     # stopped before the steps, restarted after
+steps:
+  - { project: api, cmd: php artisan migrate:fresh --seed }
+  - { project: portal, cmd: php artisan migrate:fresh --seed }
+  - parallel:
+      - { project: api, cmd: php artisan cache:clear }
+      - { project: portal, cmd: php artisan cache:clear }
+`;
+var HOME_README = `# ~/.laracrew
+
+Your laracrew configuration. Safe to keep in git \u2014 nothing here is secret unless you put
+secrets in it.
+
+    config.yaml        global preferences
+    projects.yaml      your Laravel projects, referenced by key
+    stacks/<name>/     one folder per stack; stack.yaml is the definition
+    tasks/<name>.yaml  one-shot sequences (laracrew run <name>)
+    fragments/         shared YAML any stack can reuse
+    logs/              per-run log files, when defaults.logs.toFile is on
+
+Start here:
+
+    laracrew init --examples   # add a demo stack and a two-project template
+    laracrew ls                # what is defined
+    laracrew doctor <stack>    # check a stack before booting it
+    laracrew link <stack>      # give a stack its own global command
+`;
+
+// src/cli/commands/init.ts
+var runInit = (env = process.env, options = {}) => {
+  const home2 = paths(env);
+  const created = [];
+  const skipped = [];
+  for (const dir of [home2.root, home2.stacksDir, home2.tasksDir, home2.fragmentsDir, home2.logsDir, home2.runDir]) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const files = [
+    [home2.configFile, CONFIG_YAML],
+    [home2.projectsFile, PROJECTS_YAML],
+    [path8.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 });
+    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]
+    );
+  }
+  for (const [file, contents] of files) {
+    if (existsSync5(file)) {
+      skipped.push(file);
+      continue;
+    }
+    writeFileSync(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)}`);
+  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(`
+${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>")}
+`);
+};
+
+// 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";
+
+// src/core/logs/read.ts
+import { openSync as openSync2, readSync, closeSync as closeSync2, statSync as statSync3, existsSync as existsSync7 } from "fs";
+var CHUNK = 64 * 1024;
+var tailFile = (file, limit) => {
+  if (!existsSync7(file) || limit <= 0) return [];
+  const size = statSync3(file).size;
+  if (size === 0) return [];
+  const handle = openSync2(file, "r");
+  try {
+    let position = size;
+    let text = "";
+    let newlines = 0;
+    while (position > 0 && newlines <= limit) {
+      const length = Math.min(CHUNK, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      readSync(handle, buffer, 0, length, position);
+      const chunk = buffer.toString("utf8");
+      text = chunk + text;
+      newlines = 0;
+      for (const character of text) if (character === "\n") newlines += 1;
+    }
+    const lines = text.split("\n");
+    if (lines.at(-1) === "") lines.pop();
+    return lines.slice(-limit);
+  } finally {
+    closeSync2(handle);
+  }
+};
+var toEntries = (service, lines) => lines.map((raw) => {
+  const parsed = parseLine(raw);
+  if (!parsed) return { service, stream: "stdout", line: raw, at: 0 };
+  return {
+    service,
+    stream: parsed.stream === "stderr" ? "stderr" : parsed.stream === "system" ? "system" : "stdout",
+    line: parsed.line,
+    at: parsed.at
+  };
+});
+var parseSince = (input) => {
+  const relative = /^(\d+)\s*(s|m|h|d)$/i.exec(input.trim());
+  if (relative) {
+    const amount = Number(relative[1]);
+    const unit = relative[2].toLowerCase();
+    const ms = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[unit] ?? 0;
+    return Date.now() - amount * ms;
+  }
+  const absolute = new Date(input).getTime();
+  return Number.isNaN(absolute) ? void 0 : absolute;
+};
+var followFile = (file, options) => {
+  let position = existsSync7(file) ? statSync3(file).size : 0;
+  let carry = "";
+  const read = () => {
+    if (!existsSync7(file)) return;
+    const size = statSync3(file).size;
+    if (size === position) return;
+    if (size < position) {
+      position = 0;
+      carry = "";
+    }
+    const length = size - position;
+    const handle = openSync2(file, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      readSync(handle, buffer, 0, length, position);
+      position = size;
+      const text = carry + buffer.toString("utf8");
+      const lines = text.split("\n");
+      carry = lines.pop() ?? "";
+      if (lines.length > 0) options.onLines(lines);
+    } finally {
+      closeSync2(handle);
+    }
+  };
+  const timer = setInterval(read, options.intervalMs ?? 300);
+  timer.unref?.();
+  const stop = () => clearInterval(timer);
+  options.signal?.addEventListener("abort", stop, { once: true });
+  return stop;
+};
+
+// src/cli/commands/logs.ts
+var logDirFor = (stackName, env = process.env) => path10.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)),
+    color: service.color
+  })).filter((target) => existsSync8(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}
+`;
+};
+var logsCommand = async (service, options = {}) => {
+  const env = options.env ?? process.env;
+  const stackName = options.stack;
+  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);
+  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"));
+      return 0;
+    }
+    console.log(paint("gray", dir));
+    for (const target of available) {
+      console.log(`  ${paint("cyan", target.service)}  ${paint("gray", path10.basename(target.file))}`);
+    }
+    return 0;
+  }
+  if (available.length === 0) {
+    console.error(paint("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"
+      )
+    );
+    return 1;
+  }
+  let selected;
+  if (options.all || !service) {
+    selected = available;
+  } else {
+    const match = available.find((target) => target.service === service);
+    if (!match) {
+      const suggestion = didYouMean(
+        service,
+        available.map((target) => target.service)
+      );
+      throw new ConfigError(
+        `no log for service "${service}" in stack "${stackName}"` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""),
+        { details: [`available: ${available.map((target) => target.service).join(", ")}`] }
+      );
+    }
+    selected = [match];
+  }
+  const withName = selected.length > 1;
+  const width = Math.max(...selected.map((target) => target.service.length));
+  const limit = options.lines ?? 200;
+  const since = options.since ? parseSince(options.since) : void 0;
+  if (options.since && since === void 0) {
+    throw new ConfigError(`could not read --since "${options.since}"`, {
+      details: ["try a relative window like 10m, 2h, 1d, or an absolute date"]
+    });
+  }
+  const history = [];
+  for (const target of selected) {
+    history.push(...toEntries(target.service, tailFile(target.file, since ? Math.max(limit, 5e3) : limit)));
+  }
+  history.sort((a, b) => a.at - b.at);
+  const filtered = since ? history.filter((entry) => entry.at >= since) : history;
+  for (const entry of filtered.slice(-limit)) write(formatEntry(entry, width, withName));
+  if (!options.follow) return 0;
+  const controller = new AbortController();
+  const stops = selected.map(
+    (target) => followFile(target.file, {
+      signal: controller.signal,
+      onLines: (lines) => {
+        for (const entry of toEntries(target.service, lines)) {
+          write(formatEntry(entry, width, withName));
+        }
+      }
+    })
+  );
+  await new Promise((resolve) => {
+    const finish = () => {
+      controller.abort();
+      for (const stop of stops) stop();
+      resolve();
+    };
+    process.once("SIGINT", finish);
+    process.once("SIGTERM", finish);
+  });
+  return 0;
+};
+
+// src/cli/commands/ls.ts
+import { existsSync as existsSync9 } 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")}`);
+    return 1;
+  }
+  const stackNames = listStacks(env);
+  const taskNames = listTasks(env);
+  const projects = loadSharedProjects(env);
+  const linkedByStack = new Map(listLinks({ env }).map((link) => [link.stack, link.name]));
+  const stacks = stackNames.map((name) => {
+    try {
+      const { config } = loadStack(name, env);
+      return {
+        name,
+        description: config.description ?? "",
+        services: config.services.length,
+        profiles: Object.keys(config.profiles),
+        command: linkedByStack.get(name) ?? null,
+        valid: true
+      };
+    } catch (error) {
+      return {
+        name,
+        description: error instanceof ConfigError ? error.message : "invalid",
+        services: 0,
+        profiles: [],
+        command: linkedByStack.get(name) ?? null,
+        valid: false
+      };
+    }
+  });
+  if (json) {
+    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 width = Math.max(4, ...stacks.map((stack) => stack.name.length));
+  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(", ")}`)}`);
+    }
+  }
+  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"));
+  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)}`);
+  console.log("");
+  return 0;
+};
+
+// src/cli/program.ts
+var VERSION = "0.1.0";
+var resolveStackName = (explicit, env = process.env) => {
+  if (explicit) return explicit;
+  const configured = loadGlobalConfig(env).defaultStack;
+  if (configured) return configured;
+  const stacks = listStacks(env);
+  if (stacks.length === 1) return stacks[0];
+  if (stacks.length === 0) {
+    throw new ConfigError("no stacks defined yet \u2014 run `laracrew init`");
+  }
+  throw new ConfigError(
+    `several stacks exist, so name one: ${stacks.join(", ")}`,
+    { details: ["or set `defaultStack:` in ~/.laracrew/config.yaml"] }
+  );
+};
+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 Laravel projects with one command.").version(VERSION, "-v, --version").showHelpAfterError();
+  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 });
+  });
+  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);
+  });
+  program.command("up").argument("[stack]", "stack to boot").description("boot a stack and supervise it").option("--only <selector>", "only these services or groups (repeatable, comma-separated)", collect, []).option("--except <selector>", "skip these services or groups (repeatable, comma-separated)", collect, []).option("--profile <name>", "apply a profile from the stack").option("--plain", "prefixed interleaved logs instead of the full-screen view").option("--json", "newline-delimited JSON events").action(async (stack, options) => {
+    const name = resolveStackName(stack);
+    process.exitCode = await upCommand(name, {
+      only: options.only,
+      except: options.except,
+      profile: options.profile,
+      plain: options.plain,
+      json: options.json
+    });
+  });
+  program.command("logs").argument("[service]", "service to read; omit for every service in the stack").description("read what a stack wrote to disk, after the fact").option("--stack <name>", "which stack (defaults the same way `up` does)").option("-n, --lines <count>", "how many lines to show", (value) => Number(value), 200).option("-f, --follow", "keep printing new lines as they arrive").option("--since <window>", "only lines newer than this: 10m, 2h, 1d, or a date").option("--all", "merge every service in the stack").option("--list", "list the services that have a log file").action(async (service, options) => {
+    process.exitCode = await logsCommand(service, {
+      stack: resolveStackName(options.stack),
+      lines: options.lines,
+      follow: options.follow,
+      since: options.since,
+      all: options.all,
+      list: options.list
+    });
+  });
+  program.command("link").argument("[stack]", "stack to give its own global command").description("install a global command that boots one stack").option("--as <name>", "name the command something other than the stack name").option("--all", "link every stack that declares `command:` in its stack.yaml").option("--dir <path>", "install into this directory instead of the npm global bin").option("--force", "overwrite a name that is taken or reserved").action((stack, options) => {
+    process.exitCode = linkCommand(
+      stack,
+      {
+        as: options.as,
+        all: options.all,
+        dir: options.dir,
+        force: options.force
+      },
+      process.env
+    );
+  });
+  program.command("unlink").argument("<name>", "the global command to remove").description("remove a global command laracrew installed").action((name) => {
+    process.exitCode = unlinkCommandAction(name);
+  });
+  program.command("doctor").argument("[stack]", "stack to check").description("check a stack before booting it").action(async (stack) => {
+    process.exitCode = await doctorCommand(resolveStackName(stack));
+  });
+  return program;
+};
+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()}`);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+};
+
+// src/index.ts
+installPipeGuards();
+run().catch((error) => {
+  console.error(paint("red", error instanceof Error ? error.stack ?? error.message : String(error)));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map