numux 1.5.1 → 1.5.2

package/dist/bin.js

@@ -1,2611 +1,23 @@
-#!/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.5.1",
-    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",
-      node: ">=18"
-    },
-    bin: {
-      numux: "dist/bin.js"
-    },
-    exports: {
-      ".": {
-        types: "./dist/config.d.ts",
-        import: "./dist/config.js"
-      }
-    },
-    scripts: {
-      build: "bun build src/index.ts --outfile dist/bin.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",
-      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 expandScriptPatterns(config, cwd) {
-  const entries = Object.entries(config.processes);
-  const hasWildcard = entries.some(([name]) => name.startsWith("npm:"));
-  if (!hasWildcard)
-    return config;
-  const dir = config.cwd ?? cwd ?? process.cwd();
-  const pkgPath = resolve(dir, "package.json");
-  if (!existsSync(pkgPath)) {
-    throw new Error(`npm: 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:")) {
-      expanded[name] = value;
-      continue;
-    }
-    const pattern = name.slice(4);
-    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'
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const child = spawn('bun', ['run', join(__dirname, 'numux.js'), ...process.argv.slice(2)], {
+	stdio: 'inherit'
+})
 
-export default defineConfig({
-  // Global options (inherited by all processes):
-  // cwd: './packages/backend',
-  // env: { NODE_ENV: 'development' },
-  // envFile: '.env',
+child.on('exit', (code, signal) => {
+	if (signal) process.kill(process.pid, signal)
+	else process.exit(code ?? 1)
+})
 
-  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'],
-    // },
-  },
+child.on('error', err => {
+	if (err.code === 'ENOENT') {
+		console.error('numux requires bun. Install it: https://bun.sh')
+	} else {
+		console.error(err.message)
+	}
+	process.exit(1)
 })
-`;
-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 hasNpmPatterns = parsed.commands.some((c) => c.startsWith("npm:"));
-    if (hasNpmPatterns) {
-      const npmPatterns = parsed.commands.filter((c) => c.startsWith("npm:"));
-      const otherCommands = parsed.commands.filter((c) => !c.startsWith("npm:"));
-      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);
-});