numux 1.5.1 → 1.6.0

package/dist/numux.js

@@ -0,0 +1,2614 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "numux",
+    version: "1.6.0",
+    description: "Terminal multiplexer with dependency orchestration",
+    type: "module",
+    license: "MIT",
+    author: "hyldmo",
+    repository: {
+      type: "git",
+      url: "https://github.com/hyldmo/numux.git"
+    },
+    keywords: [
+      "terminal",
+      "multiplexer",
+      "process-manager",
+      "tui",
+      "dev-tools",
+      "orchestration"
+    ],
+    engines: {
+      bun: ">=1.0"
+    },
+    bin: {
+      numux: "dist/bin.js"
+    },
+    exports: {
+      ".": {
+        types: "./dist/config.d.ts",
+        import: "./dist/config.js"
+      }
+    },
+    scripts: {
+      build: "bun build src/index.ts --outfile dist/numux.js --target bun --packages external && bun build src/config.ts --outfile dist/config.js --packages external && bunx tsc src/config.ts src/types.ts --emitDeclarationOnly --declaration --outDir dist --target ESNext --module ESNext --moduleResolution bundler && cp src/bin-wrapper.js dist/bin.js",
+      prepublishOnly: "bun run build",
+      dev: "cd example && bun run dev --debug",
+      test: "bun test",
+      typecheck: "bunx tsc --noEmit",
+      lint: "biome check .",
+      fix: "biome check . --fix --unsafe"
+    },
+    files: [
+      "dist/"
+    ],
+    dependencies: {
+      "@opentui/core": "^0.1.81",
+      "ghostty-opentui": "^1.4.3"
+    },
+    devDependencies: {
+      "@biomejs/biome": "^2.4.4",
+      "@types/bun": "^1.3.9"
+    }
+  };
+});
+
+// src/index.ts
+import { existsSync as existsSync4, writeFileSync } from "fs";
+import { resolve as resolve7 } from "path";
+
+// src/cli.ts
+function parseArgs(argv) {
+  const result = {
+    help: false,
+    version: false,
+    debug: false,
+    init: false,
+    validate: false,
+    exec: false,
+    prefix: false,
+    killOthers: false,
+    timestamps: false,
+    noRestart: false,
+    noWatch: false,
+    configPath: undefined,
+    commands: [],
+    named: []
+  };
+  const args = argv.slice(2);
+  let i = 0;
+  const consumeValue = (flag) => {
+    const next = args[++i];
+    if (next === undefined) {
+      throw new Error(`Missing value for ${flag}`);
+    }
+    return next;
+  };
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      result.help = true;
+    } else if (arg === "-v" || arg === "--version") {
+      result.version = true;
+    } else if (arg === "--debug") {
+      result.debug = true;
+    } else if (arg === "-p" || arg === "--prefix") {
+      result.prefix = true;
+    } else if (arg === "--kill-others") {
+      result.killOthers = true;
+    } else if (arg === "-t" || arg === "--timestamps") {
+      result.timestamps = true;
+    } else if (arg === "--no-restart") {
+      result.noRestart = true;
+    } else if (arg === "--no-watch") {
+      result.noWatch = true;
+    } else if (arg === "--config") {
+      result.configPath = consumeValue(arg);
+    } else if (arg === "-c" || arg === "--color") {
+      result.colors = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "--log-dir") {
+      result.logDir = consumeValue(arg);
+    } else if (arg === "--only") {
+      result.only = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "--exclude") {
+      result.exclude = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "-n" || arg === "--name") {
+      const value = consumeValue(arg);
+      const eq = value.indexOf("=");
+      if (eq < 1) {
+        throw new Error(`Invalid --name value: expected "name=command", got "${value}"`);
+      }
+      result.named.push({
+        name: value.slice(0, eq),
+        command: value.slice(eq + 1)
+      });
+    } else if (arg === "init" && result.commands.length === 0) {
+      result.init = true;
+    } else if (arg === "validate" && result.commands.length === 0) {
+      result.validate = true;
+    } else if (arg === "exec" && result.commands.length === 0) {
+      result.exec = true;
+      const name = args[++i];
+      if (!name)
+        throw new Error("exec requires a process name");
+      result.execName = name;
+      if (args[i + 1] === "--")
+        i++;
+      const rest = args.slice(i + 1);
+      if (rest.length === 0)
+        throw new Error("exec requires a command to run");
+      result.execCommand = rest.join(" ");
+      break;
+    } else if (arg === "completions" && result.commands.length === 0) {
+      result.completions = consumeValue(arg);
+    } else if (!arg.startsWith("-")) {
+      result.commands.push(arg);
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    i++;
+  }
+  return result;
+}
+function buildConfigFromArgs(commands, named, options) {
+  const processes = {};
+  const maxRestarts = options?.noRestart ? 0 : undefined;
+  const colors = options?.colors;
+  let colorIndex = 0;
+  for (const { name, command } of named) {
+    const color = colors?.[colorIndex++ % colors.length];
+    processes[name] = { command, persistent: true, maxRestarts, ...color ? { color } : {} };
+  }
+  for (let i = 0;i < commands.length; i++) {
+    const cmd = commands[i];
+    let name = cmd.split(/\s+/)[0].split("/").pop();
+    if (processes[name]) {
+      name = `${name}-${i}`;
+    }
+    const color = colors?.[colorIndex++ % colors.length];
+    processes[name] = { command: cmd, persistent: true, maxRestarts, ...color ? { color } : {} };
+  }
+  return { processes };
+}
+function filterConfig(config, only, exclude) {
+  const allNames = Object.keys(config.processes);
+  let selected;
+  if (only && only.length > 0) {
+    for (const name of only) {
+      if (!allNames.includes(name)) {
+        throw new Error(`--only: unknown process "${name}"`);
+      }
+    }
+    selected = new Set;
+    const queue = [...only];
+    while (queue.length > 0) {
+      const name = queue.pop();
+      if (selected.has(name))
+        continue;
+      selected.add(name);
+      const deps = config.processes[name].dependsOn ?? [];
+      for (const dep of deps) {
+        if (!selected.has(dep))
+          queue.push(dep);
+      }
+    }
+  } else {
+    selected = new Set(allNames);
+  }
+  if (exclude && exclude.length > 0) {
+    for (const name of exclude) {
+      if (!allNames.includes(name)) {
+        throw new Error(`--exclude: unknown process "${name}"`);
+      }
+      selected.delete(name);
+    }
+  }
+  if (selected.size === 0) {
+    throw new Error("No processes left after filtering");
+  }
+  const processes = {};
+  for (const name of selected) {
+    const proc = { ...config.processes[name] };
+    if (proc.dependsOn) {
+      proc.dependsOn = proc.dependsOn.filter((d) => selected.has(d));
+      if (proc.dependsOn.length === 0)
+        proc.dependsOn = undefined;
+    }
+    processes[name] = proc;
+  }
+  return { processes };
+}
+
+// src/completions.ts
+var SUPPORTED_SHELLS = ["bash", "zsh", "fish"];
+function generateCompletions(shell) {
+  switch (shell) {
+    case "bash":
+      return bashCompletions();
+    case "zsh":
+      return zshCompletions();
+    case "fish":
+      return fishCompletions();
+    default:
+      throw new Error(`Unknown shell: "${shell}". Supported: ${SUPPORTED_SHELLS.join(", ")}`);
+  }
+}
+function bashCompletions() {
+  return `# numux bash completions
+# Add to ~/.bashrc: eval "$(numux completions bash)"
+_numux() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  case "$prev" in
+    --config)
+      COMPREPLY=( $(compgen -f -- "$cur") )
+      return ;;
+    --log-dir)
+      COMPREPLY=( $(compgen -d -- "$cur") )
+      return ;;
+    --only|--exclude)
+      return ;;
+    -n|--name)
+      return ;;
+    completions)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+      return ;;
+  esac
+
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=( $(compgen -W "-h --help -v --version -c --color --config -n --name -p --prefix --only --exclude --kill-others --no-restart --no-watch -t --timestamps --log-dir --debug" -- "$cur") )
+  else
+    local subcmds="init validate exec completions"
+    COMPREPLY=( $(compgen -W "$subcmds" -- "$cur") )
+  fi
+}
+complete -F _numux numux`;
+}
+function zshCompletions() {
+  return `#compdef numux
+# numux zsh completions
+# Add to ~/.zshrc: eval "$(numux completions zsh)"
+_numux() {
+  local -a subcmds
+  subcmds=(
+    'init:Create a starter config file'
+    'validate:Validate config and show process graph'
+    'exec:Run a command in a process environment'
+    'completions:Generate shell completions'
+  )
+
+  _arguments -s \\
+    '(-h --help)'{-h,--help}'[Show help]' \\
+    '(-v --version)'{-v,--version}'[Show version]' \\
+    '(-c --color)'{-c,--color}'[Comma-separated colors for processes]' \\
+    '--config[Config file path]:file:_files' \\
+    '(-n --name)'{-n,--name}'[Named process (name=command)]:named process' \\
+    '(-p --prefix)'{-p,--prefix}'[Prefixed output mode]' \\
+    '--only[Only run these processes]:processes' \\
+    '--exclude[Exclude these processes]:processes' \\
+    '--kill-others[Kill all when any exits]' \\
+    '--no-restart[Disable auto-restart]' \\
+    '--no-watch[Disable file watching]' \\
+    '(-t --timestamps)'{-t,--timestamps}'[Add timestamps to output]' \\
+    '--log-dir[Log directory]:directory:_directories' \\
+    '--debug[Enable debug logging]' \\
+    '1:subcommand:->subcmd' \\
+    '*:command' \\
+    && return
+
+  case "$state" in
+    subcmd)
+      _describe 'subcommand' subcmds
+      ;;
+  esac
+}
+_numux`;
+}
+function fishCompletions() {
+  return `# numux fish completions
+# Add to fish: numux completions fish | source
+# Or save to: ~/.config/fish/completions/numux.fish
+complete -c numux -f
+
+# Subcommands
+complete -c numux -n __fish_use_subcommand -a init -d 'Create a starter config file'
+complete -c numux -n __fish_use_subcommand -a validate -d 'Validate config and show process graph'
+complete -c numux -n __fish_use_subcommand -a exec -d 'Run a command in a process environment'
+complete -c numux -n __fish_use_subcommand -a completions -d 'Generate shell completions'
+
+# Completions subcommand
+complete -c numux -n '__fish_seen_subcommand_from completions' -a 'bash zsh fish'
+
+# Options
+complete -c numux -s h -l help -d 'Show help'
+complete -c numux -s v -l version -d 'Show version'
+complete -c numux -s c -l color -r -d 'Comma-separated colors for processes'
+complete -c numux -l config -rF -d 'Config file path'
+complete -c numux -s n -l name -r -d 'Named process (name=command)'
+complete -c numux -s p -l prefix -d 'Prefixed output mode'
+complete -c numux -l only -r -d 'Only run these processes'
+complete -c numux -l exclude -r -d 'Exclude these processes'
+complete -c numux -l kill-others -d 'Kill all when any exits'
+complete -c numux -l no-restart -d 'Disable auto-restart'
+complete -c numux -l no-watch -d 'Disable file watching'
+complete -c numux -s t -l timestamps -d 'Add timestamps to output'
+complete -c numux -l log-dir -ra '(__fish_complete_directories)' -d 'Log directory'
+complete -c numux -l debug -d 'Enable debug logging'`;
+}
+
+// src/config/expand-scripts.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var LOCKFILE_PM = [
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["yarn.lock", "yarn"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["package-lock.json", "npm"]
+];
+function detectPackageManager(pkgJson, cwd) {
+  const field = pkgJson.packageManager;
+  if (typeof field === "string") {
+    const name = field.split("@")[0];
+    if (["npm", "yarn", "pnpm", "bun"].includes(name))
+      return name;
+  }
+  for (const [file, pm] of LOCKFILE_PM) {
+    if (existsSync(resolve(cwd, file)))
+      return pm;
+  }
+  return "npm";
+}
+function isGlobPattern(name) {
+  return /[*?[]/.test(name);
+}
+function expandScriptPatterns(config, cwd) {
+  const entries = Object.entries(config.processes);
+  const hasWildcard = entries.some(([name]) => name.startsWith("npm:") || isGlobPattern(name));
+  if (!hasWildcard)
+    return config;
+  const dir = config.cwd ?? cwd ?? process.cwd();
+  const pkgPath = resolve(dir, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`Wildcard patterns require a package.json (looked in ${dir})`);
+  }
+  const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const scripts = pkgJson.scripts;
+  if (!scripts || typeof scripts !== "object") {
+    throw new Error('package.json has no "scripts" field');
+  }
+  const scriptNames = Object.keys(scripts);
+  const pm = detectPackageManager(pkgJson, dir);
+  const expanded = {};
+  for (const [name, value] of entries) {
+    if (!(name.startsWith("npm:") || isGlobPattern(name))) {
+      expanded[name] = value;
+      continue;
+    }
+    const pattern = name.startsWith("npm:") ? name.slice(4) : name;
+    const template = value ?? {};
+    if (template.command) {
+      throw new Error(`"${name}": wildcard processes cannot have a "command" field (commands come from package.json scripts)`);
+    }
+    const glob = new Bun.Glob(pattern);
+    const matches = scriptNames.filter((s) => glob.match(s));
+    if (matches.length === 0) {
+      throw new Error(`"${name}": no scripts matched pattern "${pattern}". Available scripts: ${scriptNames.join(", ")}`);
+    }
+    const colors = Array.isArray(template.color) ? template.color : undefined;
+    const singleColor = typeof template.color === "string" ? template.color : undefined;
+    for (let i = 0;i < matches.length; i++) {
+      const scriptName = matches[i];
+      if (expanded[scriptName]) {
+        throw new Error(`"${name}": expanded script "${scriptName}" collides with an existing process name`);
+      }
+      const color = colors ? colors[i % colors.length] : singleColor;
+      const { color: _color, ...rest } = template;
+      expanded[scriptName] = {
+        ...rest,
+        command: `${pm} run ${scriptName}`,
+        ...color ? { color } : {}
+      };
+    }
+  }
+  return { ...config, processes: expanded };
+}
+
+// src/config/loader.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/utils/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+var enabled = false;
+var logFile = "";
+var debugCallback = null;
+function enableDebugLog(dir) {
+  const logDir = dir ?? resolve2(process.cwd(), ".numux");
+  logFile = resolve2(logDir, "debug.log");
+  if (!existsSync2(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+  enabled = true;
+}
+function log(...args) {
+  if (!enabled)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    const formatted = args.length > 0 ? `${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}` : "";
+    const line = `[${timestamp}] ${formatted}`;
+    appendFileSync(logFile, `${line}
+`);
+    debugCallback?.(line);
+  } catch {
+    enabled = false;
+  }
+}
+
+// src/config/interpolate.ts
+var VAR_RE = /\$\{([^}:]+)(?::([-?])([^}]*))?\}/g;
+function interpolateConfig(config) {
+  return interpolateValue(config);
+}
+function interpolateValue(value) {
+  if (typeof value === "string") {
+    return interpolateString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(interpolateValue);
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = interpolateValue(v);
+    }
+    return result;
+  }
+  return value;
+}
+function interpolateString(str) {
+  return str.replace(VAR_RE, (_match, name, operator, operand) => {
+    const value = process.env[name];
+    if (value !== undefined && value !== "") {
+      return value;
+    }
+    if (operator === "-") {
+      return operand ?? "";
+    }
+    if (operator === "?") {
+      throw new Error(operand || `Required variable ${name} is not set`);
+    }
+    return "";
+  });
+}
+
+// src/config/loader.ts
+var CONFIG_FILES = ["numux.config.ts", "numux.config.js"];
+async function loadConfig(configPath, cwd) {
+  if (configPath) {
+    return loadExplicitConfig(configPath);
+  }
+  return autoDetectConfig(cwd ?? process.cwd());
+}
+async function loadFile(path) {
+  try {
+    const mod = await import(path);
+    return interpolateConfig(mod.default ?? mod);
+  } catch (err) {
+    throw new Error(`Failed to load ${path}: ${err instanceof Error ? err.message : err}`, { cause: err });
+  }
+}
+async function loadExplicitConfig(configPath) {
+  const path = resolve3(configPath);
+  if (!existsSync3(path)) {
+    throw new Error(`Config file not found: ${path}`);
+  }
+  log(`Loading explicit config: ${path}`);
+  return loadFile(path);
+}
+async function autoDetectConfig(cwd) {
+  for (const file of CONFIG_FILES) {
+    const path = resolve3(cwd, file);
+    if (existsSync3(path)) {
+      log(`Found config file: ${path}`);
+      return loadFile(path);
+    }
+  }
+  throw new Error(`No numux config found. Create one of: ${CONFIG_FILES.join(", ")}`);
+}
+
+// src/config/resolver.ts
+function resolveDependencyTiers(config) {
+  const names = Object.keys(config.processes);
+  const inDegree = new Map;
+  const dependents = new Map;
+  for (const name of names) {
+    inDegree.set(name, 0);
+    dependents.set(name, []);
+  }
+  for (const name of names) {
+    const deps = config.processes[name].dependsOn ?? [];
+    inDegree.set(name, deps.length);
+    for (const dep of deps) {
+      dependents.get(dep).push(name);
+    }
+  }
+  const tiers = [];
+  const remaining = new Set(names);
+  while (remaining.size > 0) {
+    const tier = [...remaining].filter((n) => inDegree.get(n) === 0);
+    if (tier.length === 0) {
+      const cycle = findCycle(remaining, config);
+      throw new Error(`Dependency cycle detected: ${cycle.join(" \u2192 ")} \u2192 ${cycle[0]}`);
+    }
+    tiers.push(tier);
+    for (const name of tier) {
+      remaining.delete(name);
+      for (const dep of dependents.get(name)) {
+        inDegree.set(dep, inDegree.get(dep) - 1);
+      }
+    }
+  }
+  return tiers;
+}
+function findCycle(remaining, config) {
+  const start = remaining.values().next().value;
+  const visited = new Set;
+  const path = [];
+  let current = start;
+  while (!visited.has(current)) {
+    visited.add(current);
+    path.push(current);
+    const deps = (config.processes[current].dependsOn ?? []).filter((d) => remaining.has(d));
+    current = deps[0];
+  }
+  const cycleStart = path.indexOf(current);
+  return path.slice(cycleStart);
+}
+
+// src/utils/color.ts
+function hexToAnsi(hex) {
+  const h = hex.replace("#", "");
+  const r = Number.parseInt(h.slice(0, 2), 16);
+  const g = Number.parseInt(h.slice(2, 4), 16);
+  const b = Number.parseInt(h.slice(4, 6), 16);
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b))
+    return "";
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+var HEX_COLOR_RE = /^#?[0-9a-fA-F]{6}$/;
+var STATUS_ANSI = {
+  ready: "\x1B[32m",
+  running: "\x1B[36m",
+  finished: "\x1B[32m",
+  failed: "\x1B[31m",
+  stopped: "\x1B[90m",
+  skipped: "\x1B[90m"
+};
+var ANSI_RESET = "\x1B[0m";
+var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()#][0-9A-Za-z]|\x1b[A-Za-z><=]/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_RE, "");
+}
+var DEFAULT_ANSI_COLORS = [
+  "\x1B[36m",
+  "\x1B[33m",
+  "\x1B[35m",
+  "\x1B[34m",
+  "\x1B[32m",
+  "\x1B[91m",
+  "\x1B[93m",
+  "\x1B[95m"
+];
+var DEFAULT_HEX_COLORS = ["#00cccc", "#cccc00", "#cc00cc", "#0000cc", "#00cc00", "#ff5555", "#ffff55", "#ff55ff"];
+function resolveColor(color) {
+  if (typeof color === "string")
+    return color;
+  if (Array.isArray(color) && color.length > 0)
+    return color[0];
+  return;
+}
+function buildProcessColorMap(names, config) {
+  const map = new Map;
+  if ("NO_COLOR" in process.env)
+    return map;
+  let paletteIndex = 0;
+  for (const name of names) {
+    const explicit = resolveColor(config.processes[name]?.color);
+    if (explicit) {
+      map.set(name, hexToAnsi(explicit));
+    } else {
+      map.set(name, DEFAULT_ANSI_COLORS[paletteIndex % DEFAULT_ANSI_COLORS.length]);
+      paletteIndex++;
+    }
+  }
+  return map;
+}
+function buildProcessHexColorMap(names, config) {
+  const map = new Map;
+  if ("NO_COLOR" in process.env)
+    return map;
+  let paletteIndex = 0;
+  for (const name of names) {
+    const explicit = resolveColor(config.processes[name]?.color);
+    if (explicit) {
+      map.set(name, explicit.startsWith("#") ? explicit : `#${explicit}`);
+    } else {
+      map.set(name, DEFAULT_HEX_COLORS[paletteIndex % DEFAULT_HEX_COLORS.length]);
+      paletteIndex++;
+    }
+  }
+  return map;
+}
+
+// src/config/validator.ts
+function validateConfig(raw, warnings) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Config must be an object");
+  }
+  const config = raw;
+  if (!config.processes || typeof config.processes !== "object") {
+    throw new Error('Config must have a "processes" object');
+  }
+  const processes = config.processes;
+  const names = Object.keys(processes);
+  if (names.length === 0) {
+    throw new Error("Config must define at least one process");
+  }
+  const globalCwd = typeof config.cwd === "string" ? config.cwd : undefined;
+  const globalEnvFile = validateStringOrStringArray(config.envFile);
+  let globalEnv;
+  if (config.env && typeof config.env === "object") {
+    for (const [k, v] of Object.entries(config.env)) {
+      if (typeof v !== "string") {
+        throw new Error(`env.${k} must be a string, got ${typeof v}`);
+      }
+    }
+    globalEnv = config.env;
+  }
+  const validated = {};
+  for (const name of names) {
+    let proc = processes[name];
+    if (typeof proc === "string") {
+      proc = { command: proc };
+    }
+    if (!proc || typeof proc !== "object") {
+      throw new Error(`Process "${name}" must be an object or a command string`);
+    }
+    const p = proc;
+    if (typeof p.command !== "string" || !p.command.trim()) {
+      throw new Error(`Process "${name}" must have a non-empty "command" string`);
+    }
+    if (p.dependsOn !== undefined) {
+      if (!Array.isArray(p.dependsOn)) {
+        throw new Error(`Process "${name}".dependsOn must be an array`);
+      }
+      for (const dep of p.dependsOn) {
+        if (typeof dep !== "string") {
+          throw new Error(`Process "${name}".dependsOn entries must be strings`);
+        }
+        if (!names.includes(dep)) {
+          throw new Error(`Process "${name}" depends on unknown process "${dep}"`);
+        }
+        if (dep === name) {
+          throw new Error(`Process "${name}" cannot depend on itself`);
+        }
+      }
+    }
+    if (typeof p.color === "string") {
+      if (!HEX_COLOR_RE.test(p.color)) {
+        throw new Error(`Process "${name}".color must be a valid hex color (e.g. "#ff8800"), got "${p.color}"`);
+      }
+    } else if (Array.isArray(p.color)) {
+      for (const c of p.color) {
+        if (typeof c !== "string" || !HEX_COLOR_RE.test(c)) {
+          throw new Error(`Process "${name}".color entries must be valid hex colors (e.g. "#ff8800"), got "${c}"`);
+        }
+      }
+    }
+    const persistent = typeof p.persistent === "boolean" ? p.persistent : true;
+    const readyPattern = typeof p.readyPattern === "string" ? p.readyPattern : undefined;
+    if (readyPattern && !persistent) {
+      warnings?.push({
+        process: name,
+        message: "readyPattern is ignored on non-persistent processes (readiness is determined by exit code)"
+      });
+    }
+    if (p.env && typeof p.env === "object") {
+      for (const [k, v] of Object.entries(p.env)) {
+        if (typeof v !== "string") {
+          throw new Error(`Process "${name}".env.${k} must be a string, got ${typeof v}`);
+        }
+      }
+    }
+    const processCwd = typeof p.cwd === "string" ? p.cwd : undefined;
+    const processEnv = p.env && typeof p.env === "object" ? p.env : undefined;
+    const processEnvFile = validateEnvFile(p.envFile);
+    validated[name] = {
+      command: p.command,
+      cwd: processCwd ?? globalCwd,
+      env: globalEnv || processEnv ? { ...globalEnv, ...processEnv } : undefined,
+      envFile: processEnvFile ?? globalEnvFile,
+      dependsOn: Array.isArray(p.dependsOn) ? p.dependsOn : undefined,
+      readyPattern,
+      persistent,
+      maxRestarts: typeof p.maxRestarts === "number" && p.maxRestarts >= 0 ? p.maxRestarts : undefined,
+      readyTimeout: typeof p.readyTimeout === "number" && p.readyTimeout > 0 ? p.readyTimeout : undefined,
+      delay: typeof p.delay === "number" && p.delay > 0 ? p.delay : undefined,
+      condition: typeof p.condition === "string" && p.condition.trim() ? p.condition.trim() : undefined,
+      stopSignal: validateStopSignal(p.stopSignal),
+      color: typeof p.color === "string" ? p.color : Array.isArray(p.color) ? p.color : undefined,
+      watch: validateStringOrStringArray(p.watch),
+      interactive: typeof p.interactive === "boolean" ? p.interactive : false
+    };
+  }
+  return { processes: validated };
+}
+function validateStringOrStringArray(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value) && value.every((v) => typeof v === "string"))
+    return value;
+  return;
+}
+var validateEnvFile = validateStringOrStringArray;
+var VALID_STOP_SIGNALS = new Set(["SIGTERM", "SIGINT", "SIGHUP"]);
+function validateStopSignal(value) {
+  if (typeof value === "string" && VALID_STOP_SIGNALS.has(value)) {
+    return value;
+  }
+  return;
+}
+
+// src/process/manager.ts
+import { resolve as resolve6 } from "path";
+
+// src/utils/watcher.ts
+import { watch } from "fs";
+var DEBOUNCE_MS = 300;
+var IGNORED_SEGMENTS = new Set(["node_modules", ".git"]);
+
+class FileWatcher {
+  watchers = [];
+  debounceTimers = new Map;
+  watch(name, patterns, cwd, onChanged) {
+    const globs = patterns.map((p) => new Bun.Glob(p));
+    try {
+      const watcher = watch(cwd, { recursive: true }, (_event, filename) => {
+        if (!filename)
+          return;
+        const segments = filename.split("/");
+        if (segments.some((s) => IGNORED_SEGMENTS.has(s)))
+          return;
+        if (!globs.some((g) => g.match(filename)))
+          return;
+        const existing = this.debounceTimers.get(name);
+        if (existing)
+          clearTimeout(existing);
+        this.debounceTimers.set(name, setTimeout(() => {
+          this.debounceTimers.delete(name);
+          onChanged(filename);
+        }, DEBOUNCE_MS));
+      });
+      this.watchers.push(watcher);
+      log(`[${name}] Watching: ${patterns.join(", ")}`);
+    } catch (err) {
+      log(`[${name}] Failed to set up file watcher: ${err}`);
+    }
+  }
+  close() {
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    this.watchers = [];
+  }
+}
+
+// src/process/runner.ts
+import { resolve as resolve5 } from "path";
+
+// src/utils/env-file.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+function parseEnvFile(content) {
+  const vars = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex < 1)
+      continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    } else {
+      const commentIndex = value.indexOf(" #");
+      if (commentIndex !== -1) {
+        value = value.slice(0, commentIndex).trimEnd();
+      }
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function loadEnvFiles(envFile, cwd) {
+  const files = Array.isArray(envFile) ? envFile : [envFile];
+  const merged = {};
+  for (const file of files) {
+    const path = resolve4(cwd, file);
+    let content;
+    try {
+      content = readFileSync2(path, "utf-8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        throw new Error(`envFile not found: ${path}`, { cause: err });
+      }
+      throw new Error(`Failed to read envFile "${path}": ${err instanceof Error ? err.message : err}`, {
+        cause: err
+      });
+    }
+    Object.assign(merged, parseEnvFile(content));
+  }
+  return merged;
+}
+
+// src/process/ready.ts
+var BUFFER_CAP = 65536;
+function createReadinessChecker(config) {
+  const pattern = config.readyPattern ? new RegExp(config.readyPattern) : null;
+  const persistent = config.persistent !== false;
+  let outputBuffer = "";
+  return {
+    feedOutput(data) {
+      if (!(persistent && pattern))
+        return false;
+      outputBuffer += data;
+      if (outputBuffer.length > BUFFER_CAP) {
+        outputBuffer = outputBuffer.slice(-BUFFER_CAP);
+      }
+      return pattern.test(outputBuffer);
+    },
+    get isImmediatelyReady() {
+      return persistent && !pattern;
+    },
+    get dependsOnExit() {
+      return !persistent;
+    }
+  };
+}
+
+// src/process/runner.ts
+class ProcessRunner {
+  name;
+  config;
+  handler;
+  proc = null;
+  readiness;
+  _ready = false;
+  stopping = false;
+  decoder = new TextDecoder;
+  generation = 0;
+  readyTimer = null;
+  restarting = false;
+  readyTimedOut = false;
+  constructor(name, config, handler) {
+    this.name = name;
+    this.config = config;
+    this.handler = handler;
+    this.readiness = createReadinessChecker(config);
+  }
+  get isReady() {
+    return this._ready;
+  }
+  get signal() {
+    return this.config.stopSignal ?? "SIGTERM";
+  }
+  start(cols, rows) {
+    const gen = ++this.generation;
+    this.stopping = false;
+    log(`[${this.name}] Starting (gen ${gen}): ${this.config.command}`);
+    this.handler.onStatus("starting");
+    const cwd = this.config.cwd ? resolve5(this.config.cwd) : process.cwd();
+    try {
+      const envFromFile = this.config.envFile ? loadEnvFiles(this.config.envFile, cwd) : {};
+      const noColor = "NO_COLOR" in process.env;
+      const env = {
+        ...process.env,
+        ...noColor ? {} : { FORCE_COLOR: "1" },
+        TERM: "xterm-256color",
+        ...envFromFile,
+        ...this.config.env
+      };
+      this.proc = Bun.spawn(["sh", "-c", this.config.command], {
+        cwd,
+        env,
+        terminal: {
+          cols,
+          rows,
+          data: (_terminal, data) => {
+            if (this.generation !== gen)
+              return;
+            this.handler.onOutput(data);
+            this.checkReadiness(data);
+          }
+        }
+      });
+    } catch (err) {
+      log(`[${this.name}] Spawn failed: ${err}`);
+      const encoder = new TextEncoder;
+      const msg = `\r
+\x1B[31m[numux] failed to start: ${err instanceof Error ? err.message : err}\x1B[0m\r
+`;
+      this.handler.onOutput(encoder.encode(msg));
+      this.handler.onStatus("failed");
+      this.handler.onExit(null);
+      return;
+    }
+    this.handler.onStatus(this.config.persistent !== false ? "running" : "starting");
+    if (this.readiness.isImmediatelyReady) {
+      this.markReady();
+    }
+    this.startReadyTimeout(gen);
+    this.proc.exited.then((code) => {
+      if (this.generation !== gen)
+        return;
+      log(`[${this.name}] Exited with code ${code}`);
+      if (this.readiness.dependsOnExit && code === 0) {
+        this.markReady();
+      }
+      if (code === 127 || code === 126) {
+        const encoder = new TextEncoder;
+        const hint = code === 127 ? "command not found" : "permission denied";
+        const msg = `\r
+\x1B[31m[numux] exit ${code}: ${hint}\x1B[0m\r
+`;
+        this.handler.onOutput(encoder.encode(msg));
+      }
+      if (!this.readyTimedOut) {
+        const status = this.stopping ? "stopped" : code === 0 ? "finished" : "failed";
+        this.handler.onStatus(status);
+        this.handler.onExit(code);
+      }
+    }).catch((err) => {
+      if (this.generation !== gen)
+        return;
+      log(`[${this.name}] proc.exited rejected: ${err}`);
+      this.handler.onStatus("failed");
+      this.handler.onExit(null);
+    });
+  }
+  checkReadiness(data) {
+    if (this._ready)
+      return;
+    const text = this.decoder.decode(data, { stream: true });
+    if (this.readiness.feedOutput(text)) {
+      this.markReady();
+    }
+  }
+  startReadyTimeout(gen) {
+    const timeout = this.config.readyTimeout;
+    if (!(timeout && this.config.readyPattern) || this.config.persistent === false)
+      return;
+    this.readyTimer = setTimeout(() => {
+      this.readyTimer = null;
+      if (this.generation !== gen || this._ready)
+        return;
+      this.readyTimedOut = true;
+      log(`[${this.name}] Ready timeout after ${timeout}ms`);
+      const encoder = new TextEncoder;
+      const msg = `\r
+\x1B[31m[numux] readyPattern not matched within ${(timeout / 1000).toFixed(0)}s \u2014 marking as failed\x1B[0m\r
+`;
+      this.handler.onOutput(encoder.encode(msg));
+      this.handler.onStatus("failed");
+      this.handler.onReady();
+    }, timeout);
+  }
+  clearReadyTimeout() {
+    if (this.readyTimer) {
+      clearTimeout(this.readyTimer);
+      this.readyTimer = null;
+    }
+  }
+  markReady() {
+    if (this._ready)
+      return;
+    this._ready = true;
+    this.clearReadyTimeout();
+    log(`[${this.name}] Ready`);
+    this.handler.onStatus("ready");
+    this.handler.onReady();
+  }
+  async restart(cols, rows) {
+    if (this.restarting)
+      return;
+    this.restarting = true;
+    log(`[${this.name}] Restarting`);
+    this.clearReadyTimeout();
+    if (this.proc) {
+      this.stopping = true;
+      this.handler.onStatus("stopping");
+      this.killProcessGroup(this.signal);
+      const result = await Promise.race([
+        this.proc.exited.then(() => "exited"),
+        new Promise((r) => setTimeout(() => r("timeout"), 2000))
+      ]);
+      if (result === "timeout" && this.proc) {
+        this.killProcessGroup("SIGKILL");
+        await this.proc.exited;
+      }
+    }
+    this.proc = null;
+    this._ready = false;
+    this.restarting = false;
+    this.readyTimedOut = false;
+    this.readiness = createReadinessChecker(this.config);
+    this.start(cols, rows);
+  }
+  async stop(timeoutMs = 5000) {
+    if (!this.proc)
+      return;
+    this.clearReadyTimeout();
+    this.stopping = true;
+    log(`[${this.name}] Stopping (timeout: ${timeoutMs}ms)`);
+    this.handler.onStatus("stopping");
+    this.killProcessGroup(this.signal);
+    const exited = Promise.race([
+      this.proc.exited,
+      new Promise((r) => setTimeout(() => r("timeout"), timeoutMs))
+    ]);
+    const result = await exited;
+    if (result === "timeout") {
+      this.killProcessGroup("SIGKILL");
+      await this.proc.exited;
+    }
+    this.proc = null;
+  }
+  killProcessGroup(sig) {
+    if (!this.proc)
+      return;
+    try {
+      process.kill(-this.proc.pid, sig);
+    } catch {
+      try {
+        this.proc.kill(sig);
+      } catch {}
+    }
+  }
+  resize(cols, rows) {
+    if (this.proc?.terminal) {
+      this.proc.terminal.resize(cols, rows);
+    }
+  }
+  write(data) {
+    if (this.config.interactive && this.proc?.terminal) {
+      this.proc.terminal.write(data);
+    }
+  }
+}
+
+// src/process/manager.ts
+var BACKOFF_BASE_MS = 1000;
+var BACKOFF_MAX_MS = 30000;
+var BACKOFF_RESET_MS = 1e4;
+
+class ProcessManager {
+  config;
+  runners = new Map;
+  states = new Map;
+  tiers;
+  listeners = [];
+  stopping = false;
+  lastCols = 80;
+  lastRows = 24;
+  restartAttempts = new Map;
+  restartTimers = new Map;
+  startTimes = new Map;
+  pendingReadyResolvers = new Map;
+  fileWatcher;
+  constructor(config) {
+    this.config = config;
+    this.tiers = resolveDependencyTiers(config);
+    log(`Resolved ${this.tiers.length} dependency tiers:`, this.tiers);
+    for (const [name, proc] of Object.entries(config.processes)) {
+      this.states.set(name, {
+        name,
+        config: proc,
+        status: "pending",
+        exitCode: null,
+        restartCount: 0
+      });
+    }
+  }
+  on(listener) {
+    this.listeners.push(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  getState(name) {
+    return this.states.get(name);
+  }
+  getAllStates() {
+    return [...this.states.values()];
+  }
+  getProcessNames() {
+    return this.tiers.flat();
+  }
+  async startAll(cols, rows) {
+    log("Starting all processes");
+    this.lastCols = cols;
+    this.lastRows = rows;
+    for (const tier of this.tiers) {
+      const readyPromises = [];
+      for (const name of tier) {
+        const proc = this.config.processes[name];
+        if (proc.condition && !evaluateCondition(proc.condition)) {
+          log(`Skipping ${name}: condition "${proc.condition}" not met`);
+          this.updateStatus(name, "skipped");
+          continue;
+        }
+        const deps = proc.dependsOn ?? [];
+        const failedDep = deps.find((d) => {
+          const s = this.states.get(d).status;
+          return s === "failed" || s === "skipped";
+        });
+        if (failedDep) {
+          log(`Skipping ${name}: dependency ${failedDep} failed`);
+          this.updateStatus(name, "skipped");
+          continue;
+        }
+        const { promise, resolve: resolve7 } = Promise.withResolvers();
+        readyPromises.push(promise);
+        this.pendingReadyResolvers.set(name, resolve7);
+        this.createRunner(name, () => {
+          this.pendingReadyResolvers.delete(name);
+          resolve7();
+        });
+        this.startProcess(name, cols, rows);
+      }
+      if (readyPromises.length > 0) {
+        await Promise.all(readyPromises);
+      }
+    }
+    this.setupWatchers();
+  }
+  startProcess(name, cols, rows) {
+    const delay = this.config.processes[name].delay;
+    if (delay) {
+      log(`[${name}] Delaying start by ${delay}ms`);
+      const timer = setTimeout(() => {
+        this.restartTimers.delete(name);
+        if (this.stopping)
+          return;
+        this.startTimes.set(name, Date.now());
+        this.runners.get(name).start(cols, rows);
+      }, delay);
+      this.restartTimers.set(name, timer);
+    } else {
+      this.startTimes.set(name, Date.now());
+      this.runners.get(name).start(cols, rows);
+    }
+  }
+  createRunner(name, onInitialReady) {
+    let readyResolved = !onInitialReady;
+    const runner = new ProcessRunner(name, this.config.processes[name], {
+      onStatus: (status) => this.updateStatus(name, status),
+      onOutput: (data) => this.emit({ type: "output", name, data }),
+      onExit: (code) => {
+        const state = this.states.get(name);
+        state.exitCode = code;
+        this.emit({ type: "exit", name, code });
+        if (!readyResolved) {
+          readyResolved = true;
+          onInitialReady();
+        }
+        this.scheduleAutoRestart(name, code);
+      },
+      onReady: () => {
+        if (!readyResolved) {
+          readyResolved = true;
+          onInitialReady();
+        }
+      }
+    });
+    this.runners.set(name, runner);
+  }
+  scheduleAutoRestart(name, exitCode) {
+    if (this.stopping)
+      return;
+    const proc = this.config.processes[name];
+    if (proc.persistent === false)
+      return;
+    if (exitCode === 0)
+      return;
+    if (exitCode === null)
+      return;
+    log(`Scheduling auto-restart for ${name} (exit code: ${exitCode})`);
+    const startTime = this.startTimes.get(name) ?? 0;
+    if (Date.now() - startTime > BACKOFF_RESET_MS) {
+      this.restartAttempts.set(name, 0);
+    }
+    const attempt = this.restartAttempts.get(name) ?? 0;
+    const maxRestarts = proc.maxRestarts;
+    if (maxRestarts !== undefined && attempt >= maxRestarts) {
+      log(`[${name}] Reached maxRestarts limit (${maxRestarts}), not restarting`);
+      const encoder2 = new TextEncoder;
+      const msg2 = `\r
+\x1B[31m[numux] reached restart limit (${maxRestarts}), giving up\x1B[0m\r
+`;
+      this.emit({ type: "output", name, data: encoder2.encode(msg2) });
+      return;
+    }
+    const delay = Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_MAX_MS);
+    this.restartAttempts.set(name, attempt + 1);
+    const encoder = new TextEncoder;
+    const msg = `\r
+\x1B[33m[numux] restarting in ${(delay / 1000).toFixed(0)}s (attempt ${attempt + 1}${maxRestarts !== undefined ? `/${maxRestarts}` : ""})...\x1B[0m\r
+`;
+    this.emit({ type: "output", name, data: encoder.encode(msg) });
+    const timer = setTimeout(() => {
+      this.restartTimers.delete(name);
+      if (this.stopping)
+        return;
+      const runner = this.runners.get(name);
+      if (!runner)
+        return;
+      const state = this.states.get(name);
+      if (state)
+        state.restartCount++;
+      this.startTimes.set(name, Date.now());
+      runner.restart(this.lastCols, this.lastRows);
+    }, delay);
+    this.restartTimers.set(name, timer);
+  }
+  setupWatchers() {
+    const encoder = new TextEncoder;
+    for (const [name, proc] of Object.entries(this.config.processes)) {
+      if (!proc.watch)
+        continue;
+      if (!this.fileWatcher)
+        this.fileWatcher = new FileWatcher;
+      const patterns = Array.isArray(proc.watch) ? proc.watch : [proc.watch];
+      const cwd = proc.cwd ? resolve6(proc.cwd) : process.cwd();
+      this.fileWatcher.watch(name, patterns, cwd, (changedFile) => {
+        const state = this.states.get(name);
+        if (!state)
+          return;
+        if (state.status === "pending" || state.status === "stopped" || state.status === "finished" || state.status === "stopping" || state.status === "skipped")
+          return;
+        log(`[${name}] File changed: ${changedFile}, restarting`);
+        const msg = `\r
+\x1B[36m[numux] file changed: ${changedFile}, restarting...\x1B[0m\r
+`;
+        this.emit({ type: "output", name, data: encoder.encode(msg) });
+        this.restart(name, this.lastCols, this.lastRows);
+      });
+    }
+  }
+  updateStatus(name, status) {
+    const state = this.states.get(name);
+    state.status = status;
+    this.emit({ type: "status", name, status });
+  }
+  restart(name, cols, rows) {
+    const state = this.states.get(name);
+    if (!state)
+      return;
+    if (state.status === "pending" || state.status === "stopping" || state.status === "skipped")
+      return;
+    const runner = this.runners.get(name);
+    if (!runner)
+      return;
+    const timer = this.restartTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.restartTimers.delete(name);
+    }
+    this.restartAttempts.set(name, 0);
+    state.exitCode = null;
+    state.restartCount++;
+    this.startTimes.set(name, Date.now());
+    runner.restart(cols, rows);
+  }
+  async stop(name) {
+    const state = this.states.get(name);
+    if (!state)
+      return;
+    if (state.status === "pending" || state.status === "stopped" || state.status === "finished" || state.status === "stopping" || state.status === "skipped")
+      return;
+    const timer = this.restartTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.restartTimers.delete(name);
+    }
+    const runner = this.runners.get(name);
+    if (!runner)
+      return;
+    if (state.status === "failed") {
+      await runner.stop();
+      this.updateStatus(name, "stopped");
+      return;
+    }
+    await runner.stop();
+  }
+  start(name, cols, rows) {
+    const state = this.states.get(name);
+    if (!state)
+      return;
+    if (state.status !== "stopped" && state.status !== "finished" && state.status !== "failed")
+      return;
+    const timer = this.restartTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.restartTimers.delete(name);
+    }
+    this.restartAttempts.set(name, 0);
+    state.exitCode = null;
+    state.restartCount++;
+    this.startTimes.set(name, Date.now());
+    this.runners.get(name)?.restart(cols, rows);
+  }
+  restartAll(cols, rows) {
+    log("Restarting all processes");
+    for (const name of this.tiers.flat()) {
+      this.restart(name, cols, rows);
+    }
+  }
+  resize(name, cols, rows) {
+    this.runners.get(name)?.resize(cols, rows);
+  }
+  resizeAll(cols, rows) {
+    this.lastCols = cols;
+    this.lastRows = rows;
+    for (const runner of this.runners.values()) {
+      runner.resize(cols, rows);
+    }
+  }
+  write(name, data) {
+    this.runners.get(name)?.write(data);
+  }
+  async stopAll() {
+    log("Stopping all processes");
+    this.stopping = true;
+    this.fileWatcher?.close();
+    for (const timer of this.restartTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.restartTimers.clear();
+    for (const resolve7 of this.pendingReadyResolvers.values()) {
+      resolve7();
+    }
+    this.pendingReadyResolvers.clear();
+    const reversed = [...this.tiers].reverse();
+    for (const tier of reversed) {
+      await Promise.allSettled(tier.map((name) => this.runners.get(name)?.stop()).filter(Boolean));
+    }
+  }
+}
+var FALSY_VALUES = new Set(["", "0", "false", "no", "off"]);
+function evaluateCondition(condition) {
+  const negated = condition.startsWith("!");
+  const varName = negated ? condition.slice(1) : condition;
+  const value = process.env[varName];
+  const isTruthy = value !== undefined && !FALSY_VALUES.has(value.toLowerCase());
+  return negated ? !isTruthy : isTruthy;
+}
+
+// src/ui/app.ts
+import { BoxRenderable, createCliRenderer } from "@opentui/core";
+
+// src/ui/pane.ts
+import { ScrollBoxRenderable } from "@opentui/core";
+import { GhosttyTerminalRenderable } from "ghostty-opentui/terminal-buffer";
+
+class Pane {
+  scrollBox;
+  terminal;
+  decoder = new TextDecoder;
+  _onScroll = null;
+  constructor(renderer, name, cols, rows, interactive = false) {
+    this.scrollBox = new ScrollBoxRenderable(renderer, {
+      id: `pane-${name}`,
+      flexGrow: 1,
+      width: "100%",
+      stickyScroll: true,
+      stickyStart: "bottom",
+      visible: false,
+      onMouseScroll: () => this._onScroll?.()
+    });
+    this.terminal = new GhosttyTerminalRenderable(renderer, {
+      id: `term-${name}`,
+      cols,
+      rows,
+      persistent: true,
+      showCursor: interactive,
+      trimEnd: true
+    });
+    this.scrollBox.add(this.terminal);
+  }
+  feed(data) {
+    const text = this.decoder.decode(data, { stream: true });
+    this.terminal.feed(text);
+  }
+  resize(cols, rows) {
+    this.terminal.cols = cols;
+    this.terminal.rows = rows;
+  }
+  get isAtBottom() {
+    const { scrollTop, scrollHeight, viewport } = this.scrollBox;
+    if (scrollHeight <= 0)
+      return true;
+    return scrollTop >= scrollHeight - viewport.height - 2;
+  }
+  scrollBy(delta) {
+    this.scrollBox.scrollBy(delta);
+  }
+  scrollToTop() {
+    this.scrollBox.scrollTo(0);
+  }
+  scrollToBottom() {
+    this.scrollBox.scrollTo(this.scrollBox.scrollHeight);
+  }
+  onScroll(handler) {
+    this._onScroll = handler;
+  }
+  show() {
+    this.scrollBox.visible = true;
+  }
+  hide() {
+    this.scrollBox.visible = false;
+  }
+  search(query) {
+    if (!query)
+      return [];
+    const text = this.terminal.getText();
+    const lines = text.split(`
+`);
+    const matches = [];
+    const lowerQuery = query.toLowerCase();
+    for (let line = 0;line < lines.length; line++) {
+      const lowerLine = lines[line].toLowerCase();
+      let pos = 0;
+      while (true) {
+        const idx = lowerLine.indexOf(lowerQuery, pos);
+        if (idx === -1)
+          break;
+        matches.push({ line, start: idx, end: idx + query.length });
+        pos = idx + 1;
+      }
+    }
+    return matches;
+  }
+  setHighlights(matches, currentIndex) {
+    const regions = matches.map((m, i) => ({
+      line: m.line,
+      start: m.start,
+      end: m.end,
+      backgroundColor: i === currentIndex ? "#b58900" : "#073642"
+    }));
+    this.terminal.highlights = regions;
+  }
+  clearHighlights() {
+    this.terminal.highlights = undefined;
+  }
+  scrollToLine(line) {
+    const pos = this.terminal.getScrollPositionForLine(line);
+    this.scrollBox.scrollTo(pos);
+  }
+  clear() {
+    this.terminal.reset();
+  }
+  destroy() {
+    this.terminal.destroy();
+  }
+}
+
+// src/ui/status-bar.ts
+import { cyan, red, reverse, StyledText, TextRenderable, yellow } from "@opentui/core";
+function plain(text) {
+  return { __isChunk: true, text };
+}
+
+class StatusBar {
+  renderable;
+  _searchMode = false;
+  _searchQuery = "";
+  _searchMatchCount = 0;
+  _searchCurrentIndex = -1;
+  constructor(renderer) {
+    this.renderable = new TextRenderable(renderer, {
+      id: "status-bar",
+      width: "100%",
+      height: 1,
+      content: this.buildContent(),
+      bg: "#1a1a1a",
+      paddingX: 1
+    });
+  }
+  setSearchMode(active, query = "", matchCount = 0, currentIndex = -1) {
+    this._searchMode = active;
+    this._searchQuery = query;
+    this._searchMatchCount = matchCount;
+    this._searchCurrentIndex = currentIndex;
+    this.renderable.content = this.buildContent();
+  }
+  buildContent() {
+    if (this._searchMode) {
+      return this.buildSearchContent();
+    }
+    return new StyledText([
+      plain("\u2190\u2192/1-9: tabs  R: restart  S: stop/start  F: search  L: clear  Ctrl+C: quit")
+    ]);
+  }
+  buildSearchContent() {
+    const chunks = [];
+    chunks.push(yellow("/"));
+    if (this._searchQuery)
+      chunks.push(plain(this._searchQuery));
+    chunks.push(reverse(" "));
+    if (this._searchMatchCount === 0 && this._searchQuery) {
+      chunks.push(plain("  "));
+      chunks.push(red("no matches"));
+      chunks.push(plain("  Esc: close"));
+    } else if (this._searchMatchCount > 0) {
+      chunks.push(plain("  "));
+      chunks.push(cyan(`${this._searchCurrentIndex + 1}/${this._searchMatchCount}`));
+      chunks.push(plain("  Enter/Shift+Enter: next/prev  Esc: close"));
+    } else {
+      chunks.push(plain("  Enter: next  Esc: close"));
+    }
+    return new StyledText(chunks);
+  }
+}
+
+// src/ui/tabs.ts
+import {
+  parseColor,
+  SelectRenderable,
+  SelectRenderableEvents
+} from "@opentui/core";
+var STATUS_ICONS = {
+  pending: "\u25CB",
+  starting: "\u25D0",
+  running: "\u25C9",
+  ready: "\u25CF",
+  stopping: "\u25D1",
+  stopped: "\u25A0",
+  finished: "\u2713",
+  failed: "\u2716",
+  skipped: "\u2298"
+};
+var STATUS_ICON_HEX = {
+  ready: "#00cc00",
+  finished: "#66aa66",
+  failed: "#ff5555",
+  stopped: "#888888",
+  skipped: "#888888"
+};
+var TERMINAL_STATUSES = new Set(["finished", "stopped", "failed", "skipped"]);
+
+class ColoredSelectRenderable extends SelectRenderable {
+  _optionColors = [];
+  setOptionColors(colors) {
+    this._optionColors = colors;
+    this.requestRender();
+  }
+  renderSelf(buffer, deltaTime) {
+    const wasDirty = this.isDirty;
+    super.renderSelf(buffer, deltaTime);
+    if (wasDirty && this.frameBuffer && this._optionColors.length > 0) {
+      this.colorizeOptions();
+    }
+  }
+  onMouseEvent(event) {
+    if (event.type === "down") {
+      const linesPerItem = this.linesPerItem;
+      const scrollOffset = this.scrollOffset;
+      const clickedIndex = scrollOffset + Math.floor(event.y / linesPerItem);
+      if (clickedIndex >= 0 && clickedIndex < this.options.length) {
+        this.setSelectedIndex(clickedIndex);
+        this.selectCurrent();
+      }
+    }
+  }
+  colorizeOptions() {
+    const fb = this.frameBuffer;
+    const scrollOffset = this.scrollOffset;
+    const maxVisibleItems = this.maxVisibleItems;
+    const linesPerItem = this.linesPerItem;
+    const options = this.options;
+    const visibleCount = Math.min(maxVisibleItems, options.length - scrollOffset);
+    for (let i = 0;i < visibleCount; i++) {
+      const actualIndex = scrollOffset + i;
+      const colors = this._optionColors[actualIndex];
+      if (!colors)
+        continue;
+      const itemY = i * linesPerItem;
+      const optName = options[actualIndex].name;
+      if (colors.icon) {
+        fb.drawText(optName.charAt(0), 3, itemY, colors.icon);
+      }
+      if (colors.name) {
+        fb.drawText(optName.slice(2), 5, itemY, colors.name);
+      }
+    }
+  }
+}
+
+class TabBar {
+  renderable;
+  originalNames;
+  names;
+  statuses;
+  baseDescriptions;
+  processColors;
+  inputWaiting = new Set;
+  constructor(renderer, names, colors) {
+    this.originalNames = names;
+    this.names = [...names];
+    this.statuses = new Map(names.map((n) => [n, "pending"]));
+    this.baseDescriptions = new Map(names.map((n) => [n, "pending"]));
+    this.processColors = colors ?? new Map;
+    this.renderable = new ColoredSelectRenderable(renderer, {
+      id: "tab-bar",
+      width: "100%",
+      height: "100%",
+      options: names.map((n) => ({
+        name: this.formatTab(n, "pending"),
+        description: "pending"
+      })),
+      selectedBackgroundColor: "#334455",
+      selectedTextColor: "#fff",
+      textColor: "#888",
+      showDescription: true,
+      wrapSelection: true
+    });
+    this.updateOptionColors();
+  }
+  onSelect(handler) {
+    this.renderable.on(SelectRenderableEvents.ITEM_SELECTED, (index) => {
+      handler(index, this.names[index]);
+    });
+  }
+  onSelectionChanged(handler) {
+    this.renderable.on(SelectRenderableEvents.SELECTION_CHANGED, (index) => {
+      handler(index, this.names[index]);
+    });
+  }
+  updateStatus(name, status, exitCode, restartCount) {
+    this.statuses.set(name, status);
+    this.baseDescriptions.set(name, this.formatDescription(status, exitCode, restartCount));
+    if (TERMINAL_STATUSES.has(status) || status === "stopping") {
+      this.inputWaiting.delete(name);
+    }
+    this.refreshOptions();
+  }
+  setInputWaiting(name, waiting) {
+    if (waiting)
+      this.inputWaiting.add(name);
+    else
+      this.inputWaiting.delete(name);
+    this.refreshOptions();
+  }
+  getNameAtIndex(index) {
+    return this.names[index];
+  }
+  get count() {
+    return this.names.length;
+  }
+  refreshOptions() {
+    const currentIdx = this.renderable.getSelectedIndex();
+    const currentName = this.names[currentIdx];
+    this.names = this.getDisplayOrder();
+    this.renderable.options = this.names.map((n) => ({
+      name: this.formatTab(n, this.statuses.get(n)),
+      description: this.getDescription(n)
+    }));
+    const newIdx = this.names.indexOf(currentName);
+    if (newIdx >= 0 && newIdx !== currentIdx) {
+      this.renderable.setSelectedIndex(newIdx);
+    }
+    this.updateOptionColors();
+  }
+  getDisplayOrder() {
+    const active = this.originalNames.filter((n) => !TERMINAL_STATUSES.has(this.statuses.get(n)));
+    const terminal = this.originalNames.filter((n) => TERMINAL_STATUSES.has(this.statuses.get(n)));
+    return [...active, ...terminal];
+  }
+  getDescription(name) {
+    if (this.inputWaiting.has(name))
+      return "awaiting input";
+    return this.baseDescriptions.get(name) ?? "pending";
+  }
+  updateOptionColors() {
+    const colors = this.names.map((name) => {
+      const status = this.statuses.get(name);
+      const waiting = this.inputWaiting.has(name);
+      const statusHex = waiting ? "#ffaa00" : STATUS_ICON_HEX[status];
+      const processHex = this.processColors.get(name);
+      return {
+        icon: parseColor(statusHex ?? processHex ?? "#888888"),
+        name: processHex ? parseColor(processHex) : null
+      };
+    });
+    this.renderable.setOptionColors(colors);
+  }
+  formatDescription(status, exitCode, restartCount) {
+    let desc = status;
+    if ((status === "failed" || status === "stopped") && exitCode != null && exitCode !== 0) {
+      desc = `exit ${exitCode}`;
+    }
+    if (restartCount && restartCount > 0) {
+      desc += ` \xD7${restartCount}`;
+    }
+    return desc;
+  }
+  formatTab(name, status) {
+    const icon = STATUS_ICONS[status];
+    return `${icon} ${name}`;
+  }
+  getSelectedIndex() {
+    return this.renderable.getSelectedIndex();
+  }
+  setSelectedIndex(index) {
+    this.renderable.setSelectedIndex(index);
+  }
+  focus() {
+    this.renderable.focus();
+  }
+}
+
+// src/ui/app.ts
+class App {
+  renderer;
+  manager;
+  panes = new Map;
+  tabBar;
+  statusBar;
+  activePane = null;
+  destroyed = false;
+  names;
+  termCols = 80;
+  termRows = 24;
+  sidebarWidth = 20;
+  config;
+  resizeTimer = null;
+  searchMode = false;
+  searchQuery = "";
+  searchMatches = [];
+  searchIndex = -1;
+  inputWaitTimers = new Map;
+  awaitingInput = new Set;
+  constructor(manager, config) {
+    this.manager = manager;
+    this.config = config;
+    this.names = manager.getProcessNames();
+  }
+  async start() {
+    this.renderer = await createCliRenderer({
+      exitOnCtrlC: false,
+      useMouse: true
+    });
+    const { width, height } = this.renderer;
+    const maxNameLen = Math.max(...this.names.map((n) => n.length));
+    this.sidebarWidth = Math.min(30, Math.max(16, maxNameLen + 5));
+    this.termCols = Math.max(40, width - this.sidebarWidth - 2);
+    this.termRows = Math.max(5, height - 2);
+    const { termCols, termRows } = this;
+    const layout = new BoxRenderable(this.renderer, {
+      id: "root",
+      flexDirection: "column",
+      width: "100%",
+      height: "100%",
+      border: false
+    });
+    const processHexColors = buildProcessHexColorMap(this.names, this.config);
+    this.tabBar = new TabBar(this.renderer, this.names, processHexColors);
+    const contentRow = new BoxRenderable(this.renderer, {
+      id: "content-row",
+      flexDirection: "row",
+      flexGrow: 1,
+      width: "100%",
+      border: false
+    });
+    const sidebar = new BoxRenderable(this.renderer, {
+      id: "sidebar",
+      width: this.sidebarWidth,
+      height: "100%",
+      border: ["right"],
+      borderColor: "#444"
+    });
+    sidebar.add(this.tabBar.renderable);
+    const paneContainer = new BoxRenderable(this.renderer, {
+      id: "pane-container",
+      flexGrow: 1,
+      border: false
+    });
+    for (const name of this.names) {
+      const interactive = this.config.processes[name].interactive === true;
+      const pane = new Pane(this.renderer, name, termCols, termRows, interactive);
+      this.panes.set(name, pane);
+      paneContainer.add(pane.scrollBox);
+    }
+    this.statusBar = new StatusBar(this.renderer);
+    contentRow.add(sidebar);
+    contentRow.add(paneContainer);
+    layout.add(contentRow);
+    layout.add(this.statusBar.renderable);
+    this.renderer.root.add(layout);
+    this.tabBar.onSelect((_index, name) => this.switchPane(name));
+    this.tabBar.onSelectionChanged((_index, name) => this.switchPane(name));
+    this.manager.on((event) => {
+      if (this.destroyed)
+        return;
+      if (event.type === "output") {
+        this.panes.get(event.name)?.feed(event.data);
+        if (this.config.processes[event.name]?.interactive) {
+          this.checkInputWaiting(event.name, event.data);
+        }
+      } else if (event.type === "status") {
+        const state = this.manager.getState(event.name);
+        this.tabBar.updateStatus(event.name, event.status, state?.exitCode, state?.restartCount);
+        if (event.status !== "running" && event.status !== "ready") {
+          this.clearInputWaiting(event.name);
+        }
+      }
+    });
+    this.renderer.on("resize", (w, h) => {
+      this.termCols = Math.max(40, w - this.sidebarWidth - 2);
+      this.termRows = Math.max(5, h - 2);
+      if (this.resizeTimer)
+        clearTimeout(this.resizeTimer);
+      this.resizeTimer = setTimeout(() => {
+        this.resizeTimer = null;
+        for (const pane of this.panes.values()) {
+          pane.resize(this.termCols, this.termRows);
+        }
+        this.manager.resizeAll(this.termCols, this.termRows);
+      }, 50);
+    });
+    this.renderer.keyInput.on("keypress", (key) => {
+      log(key);
+      if (key.ctrl && key.name === "c") {
+        if (this.searchMode) {
+          this.exitSearch();
+          return;
+        }
+        this.shutdown().then(() => {
+          process.exit(this.hasFailures() ? 1 : 0);
+        });
+        return;
+      }
+      if (this.searchMode) {
+        this.handleSearchInput(key);
+        return;
+      }
+      if (!this.activePane)
+        return;
+      const isInteractive = this.config.processes[this.activePane]?.interactive === true;
+      if (!isInteractive) {
+        const name = key.name.toLowerCase();
+        if (key.shift && name === "r") {
+          this.manager.restartAll(this.termCols, this.termRows);
+          return;
+        }
+        if (name === "f") {
+          this.enterSearch();
+          return;
+        }
+        if (name === "r") {
+          this.manager.restart(this.activePane, this.termCols, this.termRows);
+          return;
+        }
+        if (name === "s") {
+          const state = this.manager.getState(this.activePane);
+          if (state?.status === "stopped" || state?.status === "finished" || state?.status === "failed") {
+            this.manager.start(this.activePane, this.termCols, this.termRows);
+          } else {
+            this.manager.stop(this.activePane);
+          }
+          return;
+        }
+        if (name === "l") {
+          this.panes.get(this.activePane)?.clear();
+          return;
+        }
+        const num = Number.parseInt(name, 10);
+        if (num >= 1 && num <= 9 && num <= this.tabBar.count) {
+          this.tabBar.setSelectedIndex(num - 1);
+          this.switchPane(this.tabBar.getNameAtIndex(num - 1));
+          return;
+        }
+        if (name === "left" || name === "right") {
+          const current = this.tabBar.getSelectedIndex();
+          const count = this.tabBar.count;
+          const next = name === "right" ? (current + 1) % count : (current - 1 + count) % count;
+          this.tabBar.setSelectedIndex(next);
+          this.switchPane(this.tabBar.getNameAtIndex(next));
+          return;
+        }
+        if (name === "pageup" || name === "pagedown") {
+          const pane = this.panes.get(this.activePane);
+          const delta = this.termRows - 2;
+          pane?.scrollBy(name === "pageup" ? -delta : delta);
+          return;
+        }
+        if (name === "home") {
+          this.panes.get(this.activePane)?.scrollToTop();
+          return;
+        }
+        if (name === "end") {
+          this.panes.get(this.activePane)?.scrollToBottom();
+          return;
+        }
+        return;
+      }
+      if (key.sequence) {
+        this.manager.write(this.activePane, key.sequence);
+      }
+    });
+    if (this.names.length > 0) {
+      this.switchPane(this.names[0]);
+      this.tabBar.focus();
+    }
+    await this.manager.startAll(termCols, termRows);
+  }
+  switchPane(name) {
+    if (this.activePane === name)
+      return;
+    if (this.searchMode) {
+      this.exitSearch();
+    }
+    if (this.activePane) {
+      this.panes.get(this.activePane)?.hide();
+    }
+    this.activePane = name;
+    this.panes.get(name)?.show();
+  }
+  checkInputWaiting(name, data) {
+    const existing = this.inputWaitTimers.get(name);
+    if (existing)
+      clearTimeout(existing);
+    if (this.awaitingInput.has(name)) {
+      this.awaitingInput.delete(name);
+      this.tabBar.setInputWaiting(name, false);
+    }
+    const lastByte = data[data.length - 1];
+    if (lastByte !== 10 && lastByte !== 13) {
+      const timer = setTimeout(() => {
+        this.inputWaitTimers.delete(name);
+        const state = this.manager.getState(name);
+        if (state && (state.status === "running" || state.status === "ready")) {
+          this.awaitingInput.add(name);
+          this.tabBar.setInputWaiting(name, true);
+        }
+      }, 200);
+      this.inputWaitTimers.set(name, timer);
+    }
+  }
+  clearInputWaiting(name) {
+    const timer = this.inputWaitTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.inputWaitTimers.delete(name);
+    }
+    if (this.awaitingInput.has(name)) {
+      this.awaitingInput.delete(name);
+      this.tabBar.setInputWaiting(name, false);
+    }
+  }
+  enterSearch() {
+    this.searchMode = true;
+    this.searchQuery = "";
+    this.searchMatches = [];
+    this.searchIndex = -1;
+    this.statusBar.setSearchMode(true);
+  }
+  exitSearch() {
+    this.searchMode = false;
+    this.searchQuery = "";
+    this.searchMatches = [];
+    this.searchIndex = -1;
+    if (this.activePane) {
+      this.panes.get(this.activePane)?.clearHighlights();
+    }
+    this.statusBar.setSearchMode(false);
+  }
+  handleSearchInput(key) {
+    if (key.name === "escape") {
+      this.exitSearch();
+      return;
+    }
+    if (key.name === "return") {
+      if (this.searchMatches.length === 0)
+        return;
+      if (key.shift) {
+        this.searchIndex = (this.searchIndex - 1 + this.searchMatches.length) % this.searchMatches.length;
+      } else {
+        this.searchIndex = (this.searchIndex + 1) % this.searchMatches.length;
+      }
+      this.scrollToCurrentMatch();
+      this.updateSearchHighlights();
+      return;
+    }
+    if (key.name === "backspace") {
+      if (this.searchQuery.length > 0) {
+        this.searchQuery = this.searchQuery.slice(0, -1);
+        this.runSearch();
+      }
+      return;
+    }
+    if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta) {
+      this.searchQuery += key.sequence;
+      this.runSearch();
+    }
+  }
+  runSearch() {
+    if (!this.activePane)
+      return;
+    const pane = this.panes.get(this.activePane);
+    if (!pane)
+      return;
+    this.searchMatches = pane.search(this.searchQuery);
+    this.searchIndex = this.searchMatches.length > 0 ? 0 : -1;
+    this.updateSearchHighlights();
+    if (this.searchIndex >= 0) {
+      this.scrollToCurrentMatch();
+    }
+  }
+  updateSearchHighlights() {
+    if (!this.activePane)
+      return;
+    const pane = this.panes.get(this.activePane);
+    if (!pane)
+      return;
+    if (this.searchMatches.length > 0) {
+      pane.setHighlights(this.searchMatches, this.searchIndex);
+    } else {
+      pane.clearHighlights();
+    }
+    this.statusBar.setSearchMode(true, this.searchQuery, this.searchMatches.length, this.searchIndex);
+  }
+  scrollToCurrentMatch() {
+    if (!this.activePane || this.searchIndex < 0)
+      return;
+    const pane = this.panes.get(this.activePane);
+    if (!pane)
+      return;
+    const match = this.searchMatches[this.searchIndex];
+    pane.scrollToLine(match.line);
+  }
+  async shutdown() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    if (this.resizeTimer) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+    }
+    for (const timer of this.inputWaitTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.inputWaitTimers.clear();
+    await this.manager.stopAll();
+    for (const pane of this.panes.values()) {
+      pane.destroy();
+    }
+    if (!this.renderer.isDestroyed) {
+      this.renderer.destroy();
+    }
+  }
+  hasFailures() {
+    return this.manager.getAllStates().some((s) => s.status === "failed");
+  }
+}
+
+// src/ui/prefix.ts
+var RESET = ANSI_RESET;
+var DIM = "\x1B[90m";
+
+class PrefixDisplay {
+  manager;
+  colors;
+  noColor;
+  decoders = new Map;
+  buffers = new Map;
+  maxNameLen;
+  logWriter;
+  killOthers;
+  timestamps;
+  stopping = false;
+  constructor(manager, config, options = {}) {
+    this.manager = manager;
+    this.logWriter = options.logWriter;
+    this.killOthers = options.killOthers ?? false;
+    this.timestamps = options.timestamps ?? false;
+    this.noColor = "NO_COLOR" in process.env;
+    const names = manager.getProcessNames();
+    this.maxNameLen = Math.max(...names.map((n) => n.length));
+    this.colors = buildProcessColorMap(names, config);
+    for (const name of names) {
+      this.decoders.set(name, new TextDecoder("utf-8", { fatal: false }));
+      this.buffers.set(name, "");
+    }
+  }
+  async start() {
+    const handler = (event) => {
+      this.logWriter?.handleEvent(event);
+      this.handleEvent(event);
+    };
+    this.manager.on(handler);
+    process.on("SIGINT", () => this.shutdown());
+    process.on("SIGTERM", () => this.shutdown());
+    process.on("uncaughtException", (err) => {
+      process.stderr.write(`numux: unexpected error: ${err?.stack ?? err}
+`);
+      this.shutdown();
+    });
+    process.on("unhandledRejection", (reason) => {
+      const message = reason instanceof Error ? reason.message : String(reason);
+      process.stderr.write(`numux: unhandled rejection: ${message}
+`);
+      this.shutdown();
+    });
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    await this.manager.startAll(cols, rows);
+    this.checkAllDone();
+  }
+  handleEvent(event) {
+    if (event.type === "output") {
+      this.handleOutput(event.name, event.data);
+    } else if (event.type === "status") {
+      this.handleStatus(event.name, event.status);
+    } else if (event.type === "exit") {
+      this.flushBuffer(event.name);
+      if (this.killOthers) {
+        this.killAllAndExit(event.name);
+      } else {
+        this.checkAllDone();
+      }
+    }
+  }
+  handleOutput(name, data) {
+    const decoder = this.decoders.get(name) ?? new TextDecoder;
+    const text = decoder.decode(data, { stream: true });
+    const buffer = (this.buffers.get(name) ?? "") + text;
+    const lines = buffer.split(/\r?\n/);
+    this.buffers.set(name, lines.pop() ?? "");
+    for (const line of lines) {
+      this.printLine(name, line);
+    }
+  }
+  handleStatus(name, status) {
+    if (status === "ready" || status === "failed" || status === "finished" || status === "stopped" || status === "skipped") {
+      if (this.noColor) {
+        this.printLine(name, `\u2192 ${status}`);
+      } else {
+        const ansi = STATUS_ANSI[status];
+        const statusText = ansi ? `${ansi}${status}${RESET}` : status;
+        this.printLine(name, `${DIM}\u2192 ${statusText}${DIM}${RESET}`);
+      }
+    }
+  }
+  formatTimestamp() {
+    const now = new Date;
+    const h = String(now.getHours()).padStart(2, "0");
+    const m = String(now.getMinutes()).padStart(2, "0");
+    const s = String(now.getSeconds()).padStart(2, "0");
+    return `${h}:${m}:${s}`;
+  }
+  printLine(name, line) {
+    const padded = name.padEnd(this.maxNameLen);
+    const ts = this.timestamps ? `${DIM}[${this.formatTimestamp()}]${RESET} ` : "";
+    const tsPlain = this.timestamps ? `[${this.formatTimestamp()}] ` : "";
+    if (this.noColor) {
+      process.stdout.write(`${tsPlain}[${padded}] ${stripAnsi(line)}
+`);
+    } else {
+      const color = this.colors.get(name) ?? "";
+      process.stdout.write(`${ts}${color}[${padded}]${RESET} ${line}
+`);
+    }
+  }
+  flushBuffer(name) {
+    const remaining = this.buffers.get(name) ?? "";
+    if (remaining.length > 0) {
+      this.printLine(name, remaining);
+      this.buffers.set(name, "");
+    }
+  }
+  checkAllDone() {
+    if (this.stopping)
+      return;
+    const states = this.manager.getAllStates();
+    const allDone = states.every((s) => s.status === "stopped" || s.status === "finished" || s.status === "failed" || s.status === "skipped");
+    if (allDone) {
+      this.printSummary();
+      this.logWriter?.close();
+      const anyFailed = states.some((s) => s.status === "failed");
+      process.exit(anyFailed ? 1 : 0);
+    }
+  }
+  killAllAndExit(exitedName) {
+    if (this.stopping)
+      return;
+    this.stopping = true;
+    const state = this.manager.getState(exitedName);
+    const code = state?.exitCode ?? 1;
+    this.manager.stopAll().then(() => {
+      for (const name of this.manager.getProcessNames()) {
+        this.flushBuffer(name);
+      }
+      this.printSummary();
+      this.logWriter?.close();
+      process.exit(code === 0 ? 0 : 1);
+    });
+  }
+  printSummary() {
+    const states = this.manager.getAllStates();
+    const namePad = Math.max(...states.map((s) => s.name.length));
+    process.stdout.write(`
+`);
+    for (const s of states) {
+      const name = s.name.padEnd(namePad);
+      const exitStr = s.exitCode !== null ? `exit ${s.exitCode}` : "";
+      if (this.noColor) {
+        process.stdout.write(`  ${name}  ${s.status}${exitStr ? `  (${exitStr})` : ""}
+`);
+      } else {
+        const ansi = STATUS_ANSI[s.status] ?? "";
+        const statusText = ansi ? `${ansi}${s.status}${RESET}` : s.status;
+        process.stdout.write(`  ${name}  ${statusText}${exitStr ? `  ${DIM}(${exitStr})${RESET}` : ""}
+`);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.stopping)
+      return;
+    this.stopping = true;
+    await this.manager.stopAll();
+    for (const name of this.manager.getProcessNames()) {
+      this.flushBuffer(name);
+    }
+    this.logWriter?.close();
+    const anyFailed = this.manager.getAllStates().some((s) => s.status === "failed");
+    process.exit(anyFailed ? 1 : 0);
+  }
+}
+
+// src/utils/log-writer.ts
+import { closeSync, mkdirSync as mkdirSync2, openSync, writeSync } from "fs";
+import { join } from "path";
+class LogWriter {
+  dir;
+  files = new Map;
+  decoder = new TextDecoder;
+  encoder = new TextEncoder;
+  constructor(dir) {
+    this.dir = dir;
+    mkdirSync2(dir, { recursive: true });
+  }
+  errored = false;
+  handleEvent = (event) => {
+    if (event.type !== "output" || this.errored)
+      return;
+    try {
+      let fd = this.files.get(event.name);
+      if (fd === undefined) {
+        const path = join(this.dir, `${event.name}.log`);
+        fd = openSync(path, "w");
+        this.files.set(event.name, fd);
+      }
+      const text = this.decoder.decode(event.data, { stream: true });
+      const clean = stripAnsi(text);
+      writeSync(fd, this.encoder.encode(clean));
+    } catch {
+      this.errored = true;
+      process.stderr.write(`numux: log writing failed for ${this.dir}, disabling log output
+`);
+    }
+  };
+  close() {
+    for (const fd of this.files.values()) {
+      closeSync(fd);
+    }
+    this.files.clear();
+  }
+}
+
+// src/utils/shutdown.ts
+function setupShutdownHandlers(app, logWriter) {
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) {
+      process.exit(1);
+    }
+    shuttingDown = true;
+    app.shutdown().finally(() => {
+      logWriter?.close();
+      process.exit(app.hasFailures() ? 1 : 0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("uncaughtException", (err) => {
+    log("Uncaught exception:", err?.message ?? err);
+    process.stderr.write(`numux: unexpected error: ${err?.stack ?? err}
+`);
+    app.shutdown().finally(() => {
+      logWriter?.close();
+      process.exit(1);
+    });
+  });
+  process.on("unhandledRejection", (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    log("Unhandled rejection:", message);
+    process.stderr.write(`numux: unhandled rejection: ${message}
+`);
+    app.shutdown().finally(() => {
+      logWriter?.close();
+      process.exit(1);
+    });
+  });
+}
+
+// src/index.ts
+var HELP = `numux \u2014 terminal multiplexer with dependency orchestration
+
+Usage:
+  numux                          Run processes from config file
+  numux <cmd1> <cmd2> ...        Run ad-hoc commands in parallel
+  numux -n name1=cmd1 -n name2=cmd2  Named ad-hoc commands
+  numux init                     Create a starter config file
+  numux validate                 Validate config and show process graph
+  numux exec <name> [--] <cmd>   Run a command in a process's environment
+  numux completions <shell>      Generate shell completions (bash, zsh, fish)
+
+Options:
+  -n, --name <name=command>  Add a named process
+  -c, --color <colors>       Comma-separated colors for processes (hex, e.g. #ff0,#0f0)
+  --config <path>            Config file path (default: auto-detect)
+  -p, --prefix               Prefixed output mode (no TUI, for CI/scripts)
+  --only <a,b,...>           Only run these processes (+ their dependencies)
+  --exclude <a,b,...>        Exclude these processes
+  --kill-others              Kill all processes when any exits
+  --no-restart               Disable auto-restart for crashed processes
+  --no-watch                 Disable file watching even if config has watch patterns
+  -t, --timestamps           Add timestamps to prefixed output lines
+  --log-dir <path>           Write per-process logs to directory
+  --debug                    Enable debug logging to .numux/debug.log
+  -h, --help                 Show this help
+  -v, --version              Show version
+
+Config files (auto-detected):
+  numux.config.ts, numux.config.js`;
+var INIT_TEMPLATE = `import { defineConfig } from 'numux'
+
+export default defineConfig({
+  // Global options (inherited by all processes):
+  // cwd: './packages/backend',
+  // env: { NODE_ENV: 'development' },
+  // envFile: '.env',
+
+  processes: {
+    // dev: 'npm run dev',
+    // api: {
+    //   command: 'npm run dev:api',
+    //   readyPattern: 'listening on port',
+    //   watch: 'src/**/*.ts',
+    // },
+    // web: {
+    //   command: 'npm run dev:web',
+    //   dependsOn: ['api'],
+    // },
+  },
+})
+`;
+async function main() {
+  const parsed = parseArgs(process.argv);
+  if (parsed.help) {
+    console.info(HELP);
+    process.exit(0);
+  }
+  if (parsed.version) {
+    const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+    console.info(`numux v${(pkg.default ?? pkg).version}`);
+    process.exit(0);
+  }
+  if (parsed.init) {
+    const target = resolve7("numux.config.ts");
+    if (existsSync4(target)) {
+      console.error(`Already exists: ${target}`);
+      process.exit(1);
+    }
+    writeFileSync(target, INIT_TEMPLATE);
+    console.info(`Created ${target}`);
+    process.exit(0);
+  }
+  if (parsed.completions) {
+    console.info(generateCompletions(parsed.completions));
+    process.exit(0);
+  }
+  if (parsed.validate) {
+    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    const warnings2 = [];
+    let config2 = validateConfig(raw, warnings2);
+    if (parsed.only || parsed.exclude) {
+      config2 = filterConfig(config2, parsed.only, parsed.exclude);
+    }
+    const tiers = resolveDependencyTiers(config2);
+    const names = Object.keys(config2.processes);
+    const filterNote = parsed.only || parsed.exclude ? " (filtered)" : "";
+    console.info(`Config valid: ${names.length} process${names.length === 1 ? "" : "es"}${filterNote}
+`);
+    for (let i = 0;i < tiers.length; i++) {
+      console.info(`Tier ${i}:`);
+      for (const name of tiers[i]) {
+        const proc = config2.processes[name];
+        const flags = [];
+        if (proc.dependsOn?.length)
+          flags.push(`depends on: ${proc.dependsOn.join(", ")}`);
+        if (proc.readyPattern)
+          flags.push(`ready: /${proc.readyPattern}/`);
+        if (proc.persistent === false)
+          flags.push("one-shot");
+        if (proc.delay)
+          flags.push(`delay: ${proc.delay}ms`);
+        if (proc.condition)
+          flags.push(`if: ${proc.condition}`);
+        if (proc.watch) {
+          const patterns = Array.isArray(proc.watch) ? proc.watch : [proc.watch];
+          flags.push(`watch: ${patterns.join(", ")}`);
+        }
+        const suffix = flags.length > 0 ? `  (${flags.join(", ")})` : "";
+        console.info(`  ${name}: ${proc.command}${suffix}`);
+      }
+    }
+    printWarnings(warnings2);
+    process.exit(0);
+  }
+  if (parsed.exec) {
+    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    const config2 = validateConfig(raw);
+    const proc = config2.processes[parsed.execName];
+    if (!proc) {
+      const names = Object.keys(config2.processes);
+      throw new Error(`Unknown process "${parsed.execName}". Available: ${names.join(", ")}`);
+    }
+    const cwd = proc.cwd ? resolve7(proc.cwd) : process.cwd();
+    const envFromFile = proc.envFile ? loadEnvFiles(proc.envFile, cwd) : {};
+    const env = {
+      ...process.env,
+      ...envFromFile,
+      ...proc.env
+    };
+    const child = Bun.spawn(["sh", "-c", parsed.execCommand], {
+      cwd,
+      env,
+      stdout: "inherit",
+      stdin: "inherit",
+      stderr: "inherit"
+    });
+    process.exit(await child.exited);
+  }
+  if (parsed.debug) {
+    enableDebugLog();
+  }
+  let config;
+  const warnings = [];
+  if (parsed.commands.length > 0 || parsed.named.length > 0) {
+    const isScriptPattern = (c) => c.startsWith("npm:") || /[*?[]/.test(c);
+    const hasNpmPatterns = parsed.commands.some(isScriptPattern);
+    if (hasNpmPatterns) {
+      const npmPatterns = parsed.commands.filter(isScriptPattern);
+      const otherCommands = parsed.commands.filter((c) => !isScriptPattern(c));
+      const processes = {};
+      for (const pattern of npmPatterns) {
+        const entry = {};
+        if (parsed.colors?.length)
+          entry.color = parsed.colors;
+        processes[pattern] = entry;
+      }
+      for (let i = 0;i < otherCommands.length; i++) {
+        const cmd = otherCommands[i];
+        let name = cmd.split(/\s+/)[0].split("/").pop();
+        if (processes[name])
+          name = `${name}-${i}`;
+        processes[name] = cmd;
+      }
+      for (const { name, command } of parsed.named) {
+        processes[name] = command;
+      }
+      const expanded = expandScriptPatterns({ processes });
+      config = validateConfig(expanded, warnings);
+    } else {
+      config = buildConfigFromArgs(parsed.commands, parsed.named, {
+        noRestart: parsed.noRestart,
+        colors: parsed.colors
+      });
+    }
+  } else {
+    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    config = validateConfig(raw, warnings);
+    if (parsed.noRestart) {
+      for (const proc of Object.values(config.processes)) {
+        proc.maxRestarts = 0;
+      }
+    }
+  }
+  if (parsed.noWatch) {
+    for (const proc of Object.values(config.processes)) {
+      delete proc.watch;
+    }
+  }
+  if (parsed.only || parsed.exclude) {
+    config = filterConfig(config, parsed.only, parsed.exclude);
+  }
+  const manager = new ProcessManager(config);
+  let logWriter;
+  if (parsed.logDir) {
+    logWriter = new LogWriter(parsed.logDir);
+  }
+  printWarnings(warnings);
+  if (parsed.prefix) {
+    const display = new PrefixDisplay(manager, config, {
+      logWriter,
+      killOthers: parsed.killOthers,
+      timestamps: parsed.timestamps
+    });
+    await display.start();
+  } else {
+    if (logWriter) {
+      manager.on(logWriter.handleEvent);
+    }
+    const app = new App(manager, config);
+    setupShutdownHandlers(app, logWriter);
+    await app.start();
+  }
+}
+function printWarnings(warnings) {
+  for (const w of warnings) {
+    console.warn(`Warning: process "${w.process}": ${w.message}`);
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});