@gachlab/devup 0.2.0 → 0.4.0

package/dist/index.js

@@ -3,8 +3,10 @@
 // src/index.ts
 import React7 from "react";
 import { render } from "ink";
-import { join as join5 } from "path";
-import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname6, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { homedir as homedir3 } from "os";
 
 // src/config/loader.ts
 import { existsSync } from "fs";
@@ -112,6 +114,25 @@ function validateConfig(config, cwd) {
     if (svc.cwd && !existsSync2(resolve2(cwd, svc.cwd))) {
       errors.push({ field: `services[${svc.name}].cwd`, message: `Directory not found: ${svc.cwd}` });
     }
+    if (svc.readyPattern !== void 0) {
+      if (typeof svc.readyPattern !== "string" || !svc.readyPattern.length) {
+        errors.push({ field: `services[${svc.name}].readyPattern`, message: `readyPattern must be a non-empty string` });
+      } else {
+        const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(svc.readyPattern);
+        try {
+          if (slashed) new RegExp(slashed[1], slashed[2] || "i");
+          else new RegExp(svc.readyPattern, "i");
+        } catch (e) {
+          errors.push({ field: `services[${svc.name}].readyPattern`, message: `Invalid regex: ${e.message}` });
+        }
+      }
+    }
+    if (svc.preBuild !== void 0 && (typeof svc.preBuild !== "string" || !svc.preBuild.trim())) {
+      errors.push({ field: `services[${svc.name}].preBuild`, message: `preBuild must be a non-empty string` });
+    }
+    if (svc.watchBuild !== void 0 && (typeof svc.watchBuild !== "string" || !svc.watchBuild.trim())) {
+      errors.push({ field: `services[${svc.name}].watchBuild`, message: `watchBuild must be a non-empty string` });
+    }
     if (svc.healthCheck) {
       const hc = svc.healthCheck;
       if (hc.type !== "tcp" && hc.type !== "http") {
@@ -145,6 +166,34 @@ function validateConfig(config, cwd) {
       }
     }
   }
+  if (config.external) {
+    const extNames = /* @__PURE__ */ new Set();
+    for (const ext of config.external) {
+      if (!ext.name?.trim()) {
+        errors.push({ field: "external[].name", message: "External service name is required" });
+        continue;
+      }
+      if (extNames.has(ext.name)) {
+        errors.push({ field: `external[${ext.name}].name`, message: `Duplicate external name: ${ext.name}` });
+      }
+      extNames.add(ext.name);
+      if (!ext.cmd?.trim()) {
+        errors.push({ field: `external[${ext.name}].cmd`, message: "cmd is required" });
+      }
+      if (ext.healthCheck) {
+        const hc = ext.healthCheck;
+        if (hc.type !== "tcp" && hc.type !== "http") {
+          errors.push({ field: `external[${ext.name}].healthCheck.type`, message: `Invalid healthCheck.type: ${hc.type}` });
+        }
+        if ((hc.type === "tcp" || hc.type === "http") && (typeof ext.port !== "number" || ext.port <= 0)) {
+          errors.push({ field: `external[${ext.name}].port`, message: `port is required when healthCheck is set (got ${ext.port})` });
+        }
+        if (hc.type === "http" && hc.path && !hc.path.startsWith("/")) {
+          errors.push({ field: `external[${ext.name}].healthCheck.path`, message: `must start with "/"` });
+        }
+      }
+    }
+  }
   if (config.proxy?.routes) {
     for (const ref of Object.keys(config.proxy.routes)) {
       if (!names.has(ref)) {
@@ -152,6 +201,19 @@ function validateConfig(config, cwd) {
       }
     }
   }
+  if (config.profiles) {
+    for (const [profile, svcNames] of Object.entries(config.profiles)) {
+      if (!Array.isArray(svcNames) || !svcNames.length) {
+        errors.push({ field: `profiles.${profile}`, message: `Profile "${profile}" must be a non-empty array of service names` });
+        continue;
+      }
+      for (const ref of svcNames) {
+        if (!names.has(ref)) {
+          errors.push({ field: `profiles.${profile}`, message: `Unknown service: ${ref}` });
+        }
+      }
+    }
+  }
   return errors;
 }
 function formatValidationErrors(errors) {
@@ -161,6 +223,44 @@ function formatValidationErrors(errors) {
 // src/config/cli.ts
 var DEFAULT_LAZY_TIMEOUT = 10;
 var DEFAULT_ONCE_TIMEOUT = 90;
+var USAGE = `devup \u2014 terminal UI dev stack runner
+
+Usage: devup [options]
+
+Service selection:
+  --only apis | webs       Start only APIs or only webs
+  --services a,b,c         Start only the named services
+  --profile <name>         Start the services in a named profile (see ROADMAP)
+  --skip a,b,c             Start everything except these
+  --config <path>          Use a custom config file
+
+Lazy mode:
+  --lazy                   Enable lazy mode (default)
+  --no-lazy                Start every service immediately
+  --timeout <minutes>      Idle timeout for lazy services. Default: 10
+
+Reverse proxy:
+  --proxy                  Enable proxy config generation
+  --proxy-host <host>      Override the target host (Docker/local)
+  --proxy-conf <path>      Override the generated config file path
+  --proxy-tls              Enable TLS in the generated config (default)
+  --no-proxy-tls           Disable TLS
+  --proxy-entrypoint <n>   Override entrypoint name (Traefik only)
+
+CI / scripting:
+  --dry-run                Print the resolved boot plan and exit
+  --once                   Boot, wait for readiness, exit 0/1 (no TUI)
+  --once-timeout <s>       Max seconds to wait in --once mode. Default: 90
+
+Log files:
+  --no-log-file            Disable persistent log files
+  --log-dir <path>         Override log root (default: ~/.devup/logs)
+
+Other:
+  -h, --help               Show this help and exit
+  -v, --version            Show version and exit
+
+See https://github.com/gachlab/devup for the full documentation.`;
 function parseCliArgs(argv) {
   const args = {
     skip: [],
@@ -194,6 +294,10 @@ function parseCliArgs(argv) {
         args.services = next?.split(",");
         i++;
         break;
+      case "--profile":
+        args.profile = next;
+        i++;
+        break;
       case "--lazy":
         args.lazy = true;
         break;
@@ -246,9 +350,18 @@ function parseCliArgs(argv) {
   }
   return args;
 }
-function filterServices(services, args) {
+function filterServices(services, args, config) {
   let result = services;
-  if (args.services) {
+  if (args.profile) {
+    const profileNames = config?.profiles?.[args.profile];
+    if (!profileNames) {
+      const available = Object.keys(config?.profiles ?? {});
+      const hint = available.length ? `Available: ${available.join(", ")}` : "No profiles defined in config.";
+      throw new Error(`Unknown profile: "${args.profile}". ${hint}`);
+    }
+    const set = new Set(profileNames);
+    result = result.filter((s) => set.has(s.name));
+  } else if (args.services) {
     const explicit = new Set(args.services);
     result = result.filter((s) => explicit.has(s.name));
   } else if (args.only) {
@@ -271,6 +384,359 @@ function filterServices(services, args) {
   return result;
 }
 
+// src/orchestrator/subcommands.ts
+import { spawn } from "child_process";
+import { createReadStream, watchFile, unwatchFile, existsSync as existsSync4, statSync } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { createInterface } from "readline";
+
+// src/process/health.ts
+import net from "net";
+import http from "http";
+function checkPort(port, host = "127.0.0.1", timeoutMs = 2e3) {
+  return new Promise((resolve4) => {
+    const socket = new net.Socket();
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve4(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve4(false);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve4(false);
+    });
+    socket.connect(port, host);
+  });
+}
+function checkHttp(port, opts = {}) {
+  const path = opts.path ?? "/";
+  const host = opts.host ?? "127.0.0.1";
+  const timeoutMs = opts.timeoutMs ?? 2e3;
+  const accept = (code) => {
+    if (opts.expect === void 0) return code >= 200 && code < 300;
+    if (Array.isArray(opts.expect)) return opts.expect.includes(code);
+    return code === opts.expect;
+  };
+  return new Promise((resolve4) => {
+    const req = http.get({ host, port, path, timeout: timeoutMs }, (res) => {
+      const ok = typeof res.statusCode === "number" && accept(res.statusCode);
+      res.resume();
+      resolve4(ok);
+    });
+    req.on("error", () => resolve4(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve4(false);
+    });
+  });
+}
+function checkHealth(port, hc) {
+  if (hc?.type === "http") {
+    return checkHttp(port, {
+      path: hc.path,
+      expect: hc.expect,
+      host: hc.host,
+      timeoutMs: hc.timeoutMs
+    });
+  }
+  return checkPort(port, "127.0.0.1", hc?.timeoutMs);
+}
+function waitForPort(port, opts = {}) {
+  const { timeout = 45e3, interval = 1e3 } = opts;
+  return new Promise((resolve4) => {
+    const start = Date.now();
+    const check = () => {
+      checkPort(port).then((ok) => {
+        if (ok) return resolve4(true);
+        if (Date.now() - start > timeout) return resolve4(false);
+        setTimeout(check, interval);
+      });
+    };
+    check();
+  });
+}
+function deriveHealth(isUp, currentStatus) {
+  if (currentStatus === "idle") return "idle";
+  if (isUp) return "up";
+  return currentStatus === "starting" ? "wait" : "down";
+}
+
+// src/utils.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { createHash } from "crypto";
+import { join as join2 } from "path";
+function parseEnvFile(filePath, baseEnv = {}) {
+  const env = { ...baseEnv };
+  if (!existsSync3(filePath)) return env;
+  for (const line of readFileSync(filePath, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    if (!env[key]) env[key] = val;
+  }
+  return env;
+}
+function fmtUptime(ms) {
+  if (!ms || ms < 0) return "-";
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60}s`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return `${d}d${h % 24}h`;
+}
+function needsInstall(fullCwd) {
+  const nm = join2(fullCwd, "node_modules");
+  if (!existsSync3(nm)) return true;
+  try {
+    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    const stampFile = join2(nm, ".install-stamp");
+    if (existsSync3(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
+  } catch {
+  }
+  return true;
+}
+function writeInstallStamp(fullCwd) {
+  try {
+    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    writeFileSync(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
+  } catch {
+  }
+}
+function sortServiceNames(names, sortMode, statsMap, procState) {
+  if (sortMode === "name") return names.slice().sort();
+  return names.slice().sort((a, b) => {
+    if (sortMode === "mem") {
+      return (parseFloat(statsMap[b]?.mem ?? "0") || 0) - (parseFloat(statsMap[a]?.mem ?? "0") || 0);
+    }
+    return (procState[b]?.errors ?? 0) - (procState[a]?.errors ?? 0);
+  });
+}
+function groupByPhase(services) {
+  const phases = {};
+  for (const s of services) {
+    (phases[s.phase] ??= []).push(s);
+  }
+  return phases;
+}
+function buildProcessArgs(svc) {
+  const extra = svc.nodeArgs ?? [];
+  if (!svc.maxMem) return [...extra, ...svc.args];
+  if (svc.cmd === "node") return [`--max-old-space-size=${svc.maxMem}`, ...extra, ...svc.args];
+  return [...extra, ...svc.args];
+}
+function buildProcessEnv(svc, baseEnv) {
+  const env = { ...baseEnv, ...svc.extraEnv ?? {} };
+  if (svc.maxMem && svc.cmd !== "node") {
+    const existing = env["NODE_OPTIONS"] ?? "";
+    const flag = `--max-old-space-size=${svc.maxMem}`;
+    if (!existing.includes("max-old-space-size")) {
+      env["NODE_OPTIONS"] = existing ? `${existing} ${flag}` : flag;
+    }
+  }
+  return env;
+}
+function calcCpuPercent(totalCpuSec, prevCpu, prevTime) {
+  const elapsed = (Date.now() - prevTime) / 1e3;
+  const cpuDelta = totalCpuSec - prevCpu;
+  return elapsed > 0 ? cpuDelta / elapsed * 100 : 0;
+}
+var tagColors = [
+  "cyan",
+  "yellow",
+  "green",
+  "magenta",
+  "blue",
+  "red",
+  "#5faf5f",
+  "#d7af5f",
+  "#5f87d7",
+  "#af5faf",
+  "#5fd7d7",
+  "#d75f5f",
+  "white"
+];
+
+// src/orchestrator/subcommands.ts
+var KNOWN = /* @__PURE__ */ new Set(["logs", "install", "status", "help"]);
+function detectSubcommand(argv) {
+  const first = argv[0];
+  return first && KNOWN.has(first) ? first : null;
+}
+function logRoot(config, override) {
+  const root = override ?? join3(homedir(), ".devup", "logs");
+  return join3(root, sanitize(config.name));
+}
+function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "devup";
+}
+async function runLogs(argv, opts) {
+  const out = opts.out ?? ((l) => console.log(l));
+  const follow = argv.includes("--follow") || argv.includes("-f");
+  const svcArg = argv.find((a) => !a.startsWith("-"));
+  if (!svcArg) {
+    out("usage: devup logs <service> [--follow]");
+    return 1;
+  }
+  const knownSvcs = opts.config.services.map((s) => s.name);
+  if (!knownSvcs.includes(svcArg)) {
+    out(`Unknown service "${svcArg}". Known: ${knownSvcs.join(", ")}`);
+    return 1;
+  }
+  const file = join3(logRoot(opts.config, opts.logDir), `${sanitize(svcArg)}.log`);
+  if (!existsSync4(file)) {
+    out(`No log file yet for "${svcArg}" (${file})`);
+    return follow ? await followFile(file, out) : 1;
+  }
+  await streamFile(file, out);
+  if (!follow) return 0;
+  return await followFile(file, out, statSync(file).size);
+}
+async function streamFile(file, out) {
+  return new Promise((resolve4, reject) => {
+    const rl = createInterface({ input: createReadStream(file, { encoding: "utf8" }) });
+    rl.on("line", (l) => out(l));
+    rl.on("close", () => resolve4());
+    rl.on("error", reject);
+  });
+}
+async function followFile(file, out, startAt = 0) {
+  let pos = startAt;
+  while (!existsSync4(file)) await new Promise((r) => setTimeout(r, 500));
+  return new Promise((resolve4) => {
+    const tick = async () => {
+      const size = statSync(file).size;
+      if (size > pos) {
+        await new Promise((res) => {
+          const rl = createInterface({ input: createReadStream(file, { encoding: "utf8", start: pos, end: size - 1 }) });
+          rl.on("line", (l) => out(l));
+          rl.on("close", () => {
+            pos = size;
+            res();
+          });
+        });
+      } else if (size < pos) {
+        pos = 0;
+      }
+    };
+    watchFile(file, { interval: 500 }, () => {
+      void tick();
+    });
+    process.once("SIGINT", () => {
+      unwatchFile(file);
+      resolve4(0);
+    });
+  });
+}
+async function runInstall(opts) {
+  const out = opts.out ?? ((l) => console.log(l));
+  const concurrency = opts.concurrency ?? 4;
+  const items = opts.config.services.map((s) => ({ name: s.name, cwd: join3(opts.baseCwd, s.cwd) }));
+  const queue = [...items];
+  const failed = [];
+  let inFlight = 0;
+  await new Promise((resolve4) => {
+    const pump = () => {
+      while (inFlight < concurrency && queue.length) {
+        const item = queue.shift();
+        inFlight++;
+        installOne(item.cwd, opts.env).then((ok) => {
+          inFlight--;
+          if (ok) out(`\u2713 ${item.name}`);
+          else {
+            failed.push(item.name);
+            out(`\u2717 ${item.name}`);
+          }
+          if (queue.length === 0 && inFlight === 0) resolve4();
+          else pump();
+        });
+      }
+    };
+    pump();
+  });
+  if (failed.length) {
+    out(`
+failed: ${failed.join(", ")}`);
+    return 1;
+  }
+  out(`
+${items.length} services up to date`);
+  return 0;
+}
+function installOne(cwd, env) {
+  if (!existsSync4(cwd)) return Promise.resolve(false);
+  if (!needsInstall(cwd)) return Promise.resolve(true);
+  return new Promise((resolve4) => {
+    const command = process.platform === "win32" ? "npm.cmd" : "npm";
+    const proc = spawn(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        writeInstallStamp(cwd);
+        resolve4(true);
+      } else resolve4(false);
+    });
+    proc.on("error", () => resolve4(false));
+  });
+}
+async function runStatus(opts) {
+  const out = opts.out ?? ((l) => console.log(l));
+  out(`${opts.config.icon ?? "\u{1F4E6}"} ${opts.config.name} \u2014 ${opts.config.services.length} services`);
+  out("");
+  const maxLen = Math.max(...opts.config.services.map((s) => s.name.length), 12);
+  out(`${"Service".padEnd(maxLen)}  ${"Port".padStart(5)}  ${"Type".padEnd(4)}  Health`);
+  out("-".repeat(maxLen + 24));
+  for (const svc of opts.config.services) {
+    const up = await checkHealth(svc.port, svc.healthCheck);
+    const health = up ? "\u2713 up" : "\u2717 down";
+    out(`${svc.name.padEnd(maxLen)}  ${String(svc.port).padStart(5)}  ${svc.type.padEnd(4)}  ${health}`);
+  }
+  return 0;
+}
+function runHelp(argv, opts = {}) {
+  const out = opts.out ?? ((l) => console.log(l));
+  const sub = argv[0];
+  if (sub === "logs") {
+    out("Usage: devup logs <service> [--follow|-f]");
+    out("  Print the persisted log file for a service (works without devup running).");
+    out("  --follow tails new lines as they are appended.");
+    return 0;
+  }
+  if (sub === "install") {
+    out("Usage: devup install");
+    out("  Run `npm install` across every service.cwd in parallel (max 4 at a time).");
+    out("  Skips services whose .install-stamp matches package.json hash.");
+    return 0;
+  }
+  if (sub === "status") {
+    out("Usage: devup status");
+    out("  For each service, probes its health-check endpoint and prints up/down.");
+    return 0;
+  }
+  out("Subcommands:");
+  out("  devup logs <service> [--follow]   Read the persisted log file");
+  out("  devup install                     Concurrent npm install across services");
+  out("  devup status                      Health check every service in config");
+  out("  devup help [<subcommand>]         Show detailed help for a subcommand");
+  out("");
+  out("No subcommand \u2192 launch the interactive TUI.");
+  return 0;
+}
+
 // src/platform/detect.ts
 async function detectPlatform() {
   switch (process.platform) {
@@ -292,8 +758,8 @@ async function detectPlatform() {
 }
 
 // src/proxy-config/traefik.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
-import { dirname } from "path";
+import { existsSync as existsSync5, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 var EMPTY_CONFIG = "http:\n  routers: {}\n  services: {}\n";
 var TraefikProvider = class {
   name = "traefik";
@@ -330,9 +796,9 @@ ${svcs.join("\n")}
 `;
   }
   write(content, opts) {
-    const dir = dirname(opts.confPath);
-    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(opts.confPath, content);
+    const dir = dirname2(opts.confPath);
+    if (!existsSync5(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync2(opts.confPath, content);
   }
   clear(opts) {
     this.write(EMPTY_CONFIG, opts);
@@ -340,8 +806,8 @@ ${svcs.join("\n")}
 };
 
 // src/proxy-config/nginx.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
 var EMPTY_CONFIG2 = "# devup: no healthy services\n";
 var NginxProvider = class {
   name = "nginx";
@@ -378,9 +844,9 @@ var NginxProvider = class {
     return blocks.join("\n\n") + "\n";
   }
   write(content, opts) {
-    const dir = dirname2(opts.confPath);
-    if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
-    writeFileSync2(opts.confPath, content);
+    const dir = dirname3(opts.confPath);
+    if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
+    writeFileSync3(opts.confPath, content);
   }
   clear(opts) {
     this.write(EMPTY_CONFIG2, opts);
@@ -388,8 +854,8 @@ var NginxProvider = class {
 };
 
 // src/proxy-config/caddy.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4 } from "path";
 var EMPTY_CONFIG3 = "# devup: no healthy services\n";
 var CaddyProvider = class {
   name = "caddy";
@@ -401,144 +867,40 @@ var CaddyProvider = class {
       if (sub === void 0) continue;
       const host = sub ? `${sub}.${opts.domain}` : opts.domain;
       const port = st.realPort ?? st.port;
-      const siteAddr = opts.tls ? host : `http://${host}`;
-      blocks.push(
-        `${siteAddr} {
-    reverse_proxy ${opts.host}:${port}
-}`
-      );
-    }
-    if (!blocks.length) return EMPTY_CONFIG3;
-    return blocks.join("\n\n") + "\n";
-  }
-  write(content, opts) {
-    const dir = dirname3(opts.confPath);
-    if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
-    writeFileSync3(opts.confPath, content);
-  }
-  clear(opts) {
-    this.write(EMPTY_CONFIG3, opts);
-  }
-};
-
-// src/proxy-config/detect.ts
-var providers = {
-  traefik: () => new TraefikProvider(),
-  nginx: () => new NginxProvider(),
-  caddy: () => new CaddyProvider()
-};
-function detectProxyProvider(name) {
-  const factory = providers[name];
-  if (!factory) {
-    const available = Object.keys(providers).join(", ");
-    throw new Error(`Unknown proxy provider: "${name}". Available: ${available}`);
-  }
-  return factory();
-}
-
-// src/utils.ts
-import { existsSync as existsSync6, readFileSync, writeFileSync as writeFileSync4 } from "fs";
-import { createHash } from "crypto";
-import { join as join2 } from "path";
-function parseEnvFile(filePath, baseEnv = {}) {
-  const env = { ...baseEnv };
-  if (!existsSync6(filePath)) return env;
-  for (const line of readFileSync(filePath, "utf8").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIdx = trimmed.indexOf("=");
-    if (eqIdx === -1) continue;
-    const key = trimmed.slice(0, eqIdx).trim();
-    let val = trimmed.slice(eqIdx + 1).trim();
-    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
-      val = val.slice(1, -1);
-    }
-    if (!env[key]) env[key] = val;
-  }
-  return env;
-}
-function fmtUptime(ms) {
-  if (!ms || ms < 0) return "-";
-  const s = Math.floor(ms / 1e3);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m${s % 60}s`;
-  const h = Math.floor(m / 60);
-  if (h < 24) return `${h}h${m % 60}m`;
-  const d = Math.floor(h / 24);
-  return `${d}d${h % 24}h`;
-}
-function needsInstall(fullCwd) {
-  const nm = join2(fullCwd, "node_modules");
-  if (!existsSync6(nm)) return true;
-  try {
-    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
-    const stampFile = join2(nm, ".install-stamp");
-    if (existsSync6(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
-  } catch {
-  }
-  return true;
-}
-function writeInstallStamp(fullCwd) {
-  try {
-    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
-    writeFileSync4(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
-  } catch {
-  }
-}
-function sortServiceNames(names, sortMode, statsMap, procState) {
-  if (sortMode === "name") return names.slice().sort();
-  return names.slice().sort((a, b) => {
-    if (sortMode === "mem") {
-      return (parseFloat(statsMap[b]?.mem ?? "0") || 0) - (parseFloat(statsMap[a]?.mem ?? "0") || 0);
-    }
-    return (procState[b]?.errors ?? 0) - (procState[a]?.errors ?? 0);
-  });
-}
-function groupByPhase(services) {
-  const phases = {};
-  for (const s of services) {
-    (phases[s.phase] ??= []).push(s);
-  }
-  return phases;
-}
-function buildProcessArgs(svc) {
-  const extra = svc.nodeArgs ?? [];
-  if (!svc.maxMem) return [...extra, ...svc.args];
-  if (svc.cmd === "node") return [`--max-old-space-size=${svc.maxMem}`, ...extra, ...svc.args];
-  return [...extra, ...svc.args];
-}
-function buildProcessEnv(svc, baseEnv) {
-  const env = { ...baseEnv, ...svc.extraEnv ?? {} };
-  if (svc.maxMem && svc.cmd !== "node") {
-    const existing = env["NODE_OPTIONS"] ?? "";
-    const flag = `--max-old-space-size=${svc.maxMem}`;
-    if (!existing.includes("max-old-space-size")) {
-      env["NODE_OPTIONS"] = existing ? `${existing} ${flag}` : flag;
+      const siteAddr = opts.tls ? host : `http://${host}`;
+      blocks.push(
+        `${siteAddr} {
+    reverse_proxy ${opts.host}:${port}
+}`
+      );
     }
+    if (!blocks.length) return EMPTY_CONFIG3;
+    return blocks.join("\n\n") + "\n";
   }
-  return env;
-}
-function calcCpuPercent(totalCpuSec, prevCpu, prevTime) {
-  const elapsed = (Date.now() - prevTime) / 1e3;
-  const cpuDelta = totalCpuSec - prevCpu;
-  return elapsed > 0 ? cpuDelta / elapsed * 100 : 0;
+  write(content, opts) {
+    const dir = dirname4(opts.confPath);
+    if (!existsSync7(dir)) mkdirSync3(dir, { recursive: true });
+    writeFileSync4(opts.confPath, content);
+  }
+  clear(opts) {
+    this.write(EMPTY_CONFIG3, opts);
+  }
+};
+
+// src/proxy-config/detect.ts
+var providers = {
+  traefik: () => new TraefikProvider(),
+  nginx: () => new NginxProvider(),
+  caddy: () => new CaddyProvider()
+};
+function detectProxyProvider(name) {
+  const factory = providers[name];
+  if (!factory) {
+    const available = Object.keys(providers).join(", ");
+    throw new Error(`Unknown proxy provider: "${name}". Available: ${available}`);
+  }
+  return factory();
 }
-var tagColors = [
-  "cyan",
-  "yellow",
-  "green",
-  "magenta",
-  "blue",
-  "red",
-  "#5faf5f",
-  "#d7af5f",
-  "#5f87d7",
-  "#af5faf",
-  "#5fd7d7",
-  "#d75f5f",
-  "white"
-];
 
 // src/tui/App.tsx
 import { useEffect as useEffect5, useState as useState5, useCallback as useCallback3, useRef as useRef3 } from "react";
@@ -548,89 +910,15 @@ import { Box as Box6, Text as Text6, useStdout } from "ink";
 import { useState, useEffect, useRef, useCallback } from "react";
 
 // src/process/manager.ts
-import { spawn as spawn2 } from "child_process";
-import { join as join3 } from "path";
-
-// src/process/health.ts
-import net from "net";
-import http from "http";
-function checkPort(port, host = "127.0.0.1", timeoutMs = 2e3) {
-  return new Promise((resolve3) => {
-    const socket = new net.Socket();
-    socket.setTimeout(timeoutMs);
-    socket.once("connect", () => {
-      socket.destroy();
-      resolve3(true);
-    });
-    socket.once("error", () => {
-      socket.destroy();
-      resolve3(false);
-    });
-    socket.once("timeout", () => {
-      socket.destroy();
-      resolve3(false);
-    });
-    socket.connect(port, host);
-  });
-}
-function checkHttp(port, opts = {}) {
-  const path = opts.path ?? "/";
-  const host = opts.host ?? "127.0.0.1";
-  const timeoutMs = opts.timeoutMs ?? 2e3;
-  const accept = (code) => {
-    if (opts.expect === void 0) return code >= 200 && code < 300;
-    if (Array.isArray(opts.expect)) return opts.expect.includes(code);
-    return code === opts.expect;
-  };
-  return new Promise((resolve3) => {
-    const req = http.get({ host, port, path, timeout: timeoutMs }, (res) => {
-      const ok = typeof res.statusCode === "number" && accept(res.statusCode);
-      res.resume();
-      resolve3(ok);
-    });
-    req.on("error", () => resolve3(false));
-    req.on("timeout", () => {
-      req.destroy();
-      resolve3(false);
-    });
-  });
-}
-function checkHealth(port, hc) {
-  if (hc?.type === "http") {
-    return checkHttp(port, {
-      path: hc.path,
-      expect: hc.expect,
-      host: hc.host,
-      timeoutMs: hc.timeoutMs
-    });
-  }
-  return checkPort(port, "127.0.0.1", hc?.timeoutMs);
-}
-function waitForPort(port, opts = {}) {
-  const { timeout = 45e3, interval = 1e3 } = opts;
-  return new Promise((resolve3) => {
-    const start = Date.now();
-    const check = () => {
-      checkPort(port).then((ok) => {
-        if (ok) return resolve3(true);
-        if (Date.now() - start > timeout) return resolve3(false);
-        setTimeout(check, interval);
-      });
-    };
-    check();
-  });
-}
-function deriveHealth(isUp, currentStatus) {
-  if (currentStatus === "idle") return "idle";
-  if (isUp) return "up";
-  return currentStatus === "starting" ? "wait" : "down";
-}
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
 
 // src/process/installer.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync7 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
 function installService(cwd, env, onLog) {
-  if (!existsSync7(cwd)) {
+  if (!existsSync8(cwd)) {
     onLog?.(`\u26A0 directory not found: ${cwd}`);
     return Promise.resolve(false);
   }
@@ -639,9 +927,9 @@ function installService(cwd, env, onLog) {
     return Promise.resolve(true);
   }
   onLog?.("\u{1F4E6} npm install...");
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const proc = spawn(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
+    const proc = spawn2(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr?.on("data", (d) => {
       stderr += d.toString();
@@ -649,16 +937,16 @@ function installService(cwd, env, onLog) {
     proc.on("close", (code) => {
       if (code !== 0) {
         onLog?.(`\u26A0 npm install failed: ${stderr.split("\n")[0]}`);
-        resolve3(false);
+        resolve4(false);
       } else {
         writeInstallStamp(cwd);
         onLog?.("\u2705 dependencies ready");
-        resolve3(true);
+        resolve4(true);
       }
     });
     proc.on("error", (err) => {
       onLog?.(`\u26A0 spawn error: ${err.message}`);
-      resolve3(false);
+      resolve4(false);
     });
   });
 }
@@ -666,6 +954,36 @@ function installService(cwd, env, onLog) {
 // src/process/manager.ts
 var MAX_RESTARTS = 3;
 var BACKOFF_BASE_MS = 2e3;
+function compileReadyPattern(pattern) {
+  if (!pattern) return null;
+  const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(pattern);
+  try {
+    if (slashed) return new RegExp(slashed[1], slashed[2] || "i");
+    return new RegExp(pattern, "i");
+  } catch {
+    return null;
+  }
+}
+function extractWatchPaths(args) {
+  const watchFlags = /* @__PURE__ */ new Set(["--watch", "--watch-path"]);
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (watchFlags.has(a)) {
+      const v = args[i + 1];
+      if (v && !v.startsWith("-")) {
+        out.push(v);
+        i++;
+      }
+      continue;
+    }
+    const eq = a.indexOf("=");
+    if (eq > 0 && watchFlags.has(a.slice(0, eq))) {
+      out.push(a.slice(eq + 1));
+    }
+  }
+  return out;
+}
 function lineBuffer(onLine) {
   let buf = "";
   return {
@@ -700,12 +1018,12 @@ var ProcessManager = class {
     this.events = opts.events;
   }
   async install(svc, colorIdx) {
-    const cwd = join3(this.baseCwd, svc.cwd);
+    const cwd = join4(this.baseCwd, svc.cwd);
     const idx = colorIdx ?? this.state.get(svc.name)?.colorIdx ?? 0;
     return installService(cwd, this.env, (msg) => this.log(svc.name, msg, idx));
   }
   async start(svc, colorIdx, isRestart = false) {
-    const cwd = join3(this.baseCwd, svc.cwd);
+    const cwd = join4(this.baseCwd, svc.cwd);
     if (svc.type === "api") {
       const occupied = await checkPort(svc.port);
       if (occupied && !isRestart) {
@@ -713,9 +1031,22 @@ var ProcessManager = class {
         return;
       }
     }
+    if (svc.preBuild) {
+      const built = await this.runPreBuild(svc, cwd, colorIdx);
+      if (!built) {
+        this.recordCrashedState(svc, colorIdx);
+        return;
+      }
+    }
     const args = buildProcessArgs(svc);
+    const missingWatchPaths = extractWatchPaths(args).filter((p) => !existsSync9(resolve3(cwd, p)));
+    if (missingWatchPaths.length) {
+      this.log(svc.name, `\u26A0 missing watch paths: ${missingWatchPaths.join(", ")}`, colorIdx);
+      this.recordCrashedState(svc, colorIdx);
+      return;
+    }
     const env = buildProcessEnv(svc, this.env);
-    const proc = spawn2(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const proc = spawn3(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
     const prev = this.state.get(svc.name);
     const state = {
       svc,
@@ -732,9 +1063,22 @@ var ProcessManager = class {
     this.state.set(svc.name, state);
     this.procs.add(proc);
     this.events.onStateChange(svc.name, state);
-    const stdoutBuf = lineBuffer((line) => this.log(svc.name, line, colorIdx));
+    const readyRegex = compileReadyPattern(svc.readyPattern);
+    const markReadyIfMatch = (line) => {
+      if (!readyRegex || state.health === "up") return;
+      if (readyRegex.test(line)) {
+        state.health = "up";
+        if (state.status === "starting") state.status = "running";
+        this.events.onStateChange(svc.name, state);
+      }
+    };
+    const stdoutBuf = lineBuffer((line) => {
+      markReadyIfMatch(line);
+      this.log(svc.name, line, colorIdx);
+    });
     const stderrBuf = lineBuffer((line) => {
       state.errors += 1;
+      markReadyIfMatch(line);
       this.log(svc.name, line, colorIdx);
     });
     proc.stdout?.on("data", (d) => stdoutBuf.push(d));
@@ -743,6 +1087,7 @@ var ProcessManager = class {
     proc.stderr?.on("end", () => stderrBuf.flush());
     proc.on("close", (code) => {
       this.procs.delete(proc);
+      this.stopWatchProc(state);
       if (state.intentionalStop) {
         state.intentionalStop = false;
         return;
@@ -766,13 +1111,90 @@ var ProcessManager = class {
         this.log(svc.name, "\u26D4 max restarts reached", colorIdx);
       }
     });
+    if (svc.watchBuild) {
+      state.watchProc = this.spawnWatchBuild(svc, cwd, env, colorIdx);
+    }
     this.log(svc.name, isRestart ? `\u{1F504} restarted (:${svc.port})` : `\u{1F680} started (:${svc.port})`, colorIdx);
   }
+  runPreBuild(svc, cwd, colorIdx) {
+    this.log(svc.name, `\u{1F528} preBuild: ${svc.preBuild}`, colorIdx);
+    return new Promise((resolve4) => {
+      const isWin = process.platform === "win32";
+      const shell = isWin ? "cmd.exe" : "sh";
+      const shellFlag = isWin ? "/c" : "-c";
+      const env = buildProcessEnv(svc, this.env);
+      const child = spawn3(shell, [shellFlag, svc.preBuild], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+      const outBuf = lineBuffer((line) => this.log(svc.name, `[build] ${line}`, colorIdx));
+      const errBuf = lineBuffer((line) => this.log(svc.name, `[build] ${line}`, colorIdx));
+      child.stdout?.on("data", (d) => outBuf.push(d));
+      child.stderr?.on("data", (d) => errBuf.push(d));
+      child.on("error", (err) => {
+        this.log(svc.name, `[build] \u274C ${err.message}`, colorIdx);
+        resolve4(false);
+      });
+      child.on("close", (code) => {
+        outBuf.flush();
+        errBuf.flush();
+        if (code === 0) {
+          this.log(svc.name, `[build] \u2705 done`, colorIdx);
+          resolve4(true);
+        } else {
+          this.log(svc.name, `[build] \u274C exited with code ${code}`, colorIdx);
+          resolve4(false);
+        }
+      });
+    });
+  }
+  spawnWatchBuild(svc, cwd, env, colorIdx) {
+    this.log(svc.name, `\u{1F440} watchBuild: ${svc.watchBuild}`, colorIdx);
+    const isWin = process.platform === "win32";
+    const shell = isWin ? "cmd.exe" : "sh";
+    const shellFlag = isWin ? "/c" : "-c";
+    const child = spawn3(shell, [shellFlag, svc.watchBuild], {
+      cwd,
+      env,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const outBuf = lineBuffer((line) => this.log(svc.name, `[watch] ${line}`, colorIdx));
+    const errBuf = lineBuffer((line) => this.log(svc.name, `[watch] ${line}`, colorIdx));
+    child.stdout?.on("data", (d) => outBuf.push(d));
+    child.stderr?.on("data", (d) => errBuf.push(d));
+    child.on("error", (err) => this.log(svc.name, `[watch] \u274C ${err.message}`, colorIdx));
+    return child;
+  }
+  /** Create a state entry in 'crashed' status without spawning a process (used when preBuild fails). */
+  recordCrashedState(svc, colorIdx) {
+    const prev = this.state.get(svc.name);
+    this.state.set(svc.name, {
+      svc,
+      proc: null,
+      pid: null,
+      status: "crashed",
+      health: "down",
+      errors: prev?.errors ?? 0,
+      restarts: prev?.restarts ?? 0,
+      startedAt: null,
+      intentionalStop: false,
+      colorIdx
+    });
+    this.events.onStateChange(svc.name, this.state.get(svc.name));
+  }
   stop(name) {
     const st = this.state.get(name);
     if (!st?.proc || !st.pid) return;
     st.intentionalStop = true;
     this.platform.killTree(st.pid);
+    this.stopWatchProc(st);
+  }
+  stopWatchProc(state) {
+    const wp = state.watchProc;
+    if (!wp || !wp.pid) return;
+    try {
+      this.platform.killTree(wp.pid);
+    } catch {
+    }
+    state.watchProc = null;
   }
   async restart(name) {
     const st = this.state.get(name);
@@ -803,18 +1225,22 @@ var ProcessManager = class {
     if (!procs.length) return;
     for (const proc of procs) {
       const st = this.findStateByProc(proc);
-      if (st) st.intentionalStop = true;
+      if (st) {
+        st.intentionalStop = true;
+        this.stopWatchProc(st);
+      }
       if (proc.pid) this.platform.killTree(proc.pid);
     }
+    for (const st of this.state.values()) this.stopWatchProc(st);
     const waits = procs.map(
-      (p) => p.exitCode !== null || p.signalCode !== null ? Promise.resolve() : new Promise((resolve3) => p.once("close", () => resolve3()))
+      (p) => p.exitCode !== null || p.signalCode !== null ? Promise.resolve() : new Promise((resolve4) => p.once("close", () => resolve4()))
     );
     let timedOut = false;
     await Promise.race([
       Promise.all(waits),
-      new Promise((resolve3) => setTimeout(() => {
+      new Promise((resolve4) => setTimeout(() => {
         timedOut = true;
-        resolve3();
+        resolve4();
       }, grace))
     ]);
     if (timedOut) {
@@ -825,7 +1251,7 @@ var ProcessManager = class {
       }
       await Promise.race([
         Promise.all(waits),
-        new Promise((resolve3) => setTimeout(resolve3, 1e3))
+        new Promise((resolve4) => setTimeout(resolve4, 1e3))
       ]);
     }
   }
@@ -913,6 +1339,21 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
     pendingLogsRef.current = [];
     setLogs([]);
   }, []);
+  const pushLog = useCallback((svcName, text, colorIdx = 0) => {
+    sinkRef.current?.write(svcName, text);
+    const entry = { svcName, text, colorIdx, ts: Date.now() };
+    if (pausedRef.current) {
+      pendingLogsRef.current.push(entry);
+      if (pendingLogsRef.current.length > 5e3) {
+        pendingLogsRef.current = pendingLogsRef.current.slice(-5e3);
+      }
+      return;
+    }
+    setLogs((prev) => {
+      const next = prev.concat(entry);
+      return next.length > 5e3 ? next.slice(-5e3) : next;
+    });
+  }, []);
   const setPaused = useCallback((paused) => {
     pausedRef.current = paused;
     if (!paused && pendingLogsRef.current.length) {
@@ -935,6 +1376,7 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
     cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
     clearLogs,
     setPaused,
+    pushLog,
     manager: mgr
   };
 }
@@ -1105,19 +1547,25 @@ var H = {
   down: { c: "\u25CF", color: "red" },
   idle: { c: "\u25CB", color: "blue" }
 };
+var MAX_RESTARTS2 = 3;
+function isCrashLooped(st) {
+  return st.status === "crashed" && st.restarts >= MAX_RESTARTS2;
+}
 function Row({ name, st, stat, ml }) {
-  const h = H[st.health] ?? H["down"];
+  const looped = isCrashLooped(st);
+  const indicator = looped ? /* @__PURE__ */ jsx2(Text2, { color: "red", bold: true, children: "\u2716" }) : /* @__PURE__ */ jsx2(Text2, { color: (H[st.health] ?? H["down"]).color, children: (H[st.health] ?? H["down"]).c });
   const color = tagColors[st.colorIdx % tagColors.length];
-  const sc = st.status === "running" ? "green" : st.status === "starting" ? "yellow" : st.status === "idle" ? "blue" : "red";
+  const sc = looped ? "red" : st.status === "running" ? "green" : st.status === "starting" ? "yellow" : st.status === "idle" ? "blue" : "red";
+  const statusLabel = looped ? "looping" : st.status;
   const up = st.startedAt ? fmtUptime(Date.now() - st.startedAt) : "-";
   return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { color: h.color, children: h.c }),
+    indicator,
     " ",
     /* @__PURE__ */ jsx2(Text2, { color, children: name.padEnd(ml) }),
     " ",
     String(st.svc.port).padStart(5),
     " ",
-    /* @__PURE__ */ jsx2(Text2, { color: sc, children: st.status.padEnd(8) }),
+    /* @__PURE__ */ jsx2(Text2, { color: sc, bold: looped, children: statusLabel.padEnd(8) }),
     " ",
     (stat?.cpu ?? "-").padStart(6),
     " ",
@@ -1184,6 +1632,7 @@ function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused, scro
   const totalRowsLong = Math.max(apis.length, webs.length);
   const positionInfo = focused && totalRowsLong > 0 ? `(${effectiveOffset + 1}-${Math.min(effectiveOffset + rowsPerCol, totalRowsLong)}/${totalRowsLong})` : "";
   const scrolled = effectiveOffset > 0;
+  const loopedCount = [...states.values()].filter(isCrashLooped).length;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: focused ? "green" : "gray", height, children: [
     /* @__PURE__ */ jsxs2(Box2, { children: [
       /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "green", children: [
@@ -1191,6 +1640,11 @@ function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused, scro
         positionInfo
       ] }),
       scrolled && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: " [SCROLL]" }),
+      loopedCount > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "red", bold: true, children: [
+        " \u26A0 ",
+        loopedCount,
+        " need attention"
+      ] }),
       /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
         " System: ",
         cpus,
@@ -1283,33 +1737,69 @@ function StatusBar() {
 }
 
 // src/tui/ServiceList.tsx
-import { useState as useState3 } from "react";
+import { useState as useState3, useMemo } from "react";
 import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function ServiceList({ title, services, onSelect, onClose, filterType }) {
-  const names = [...services.keys()].filter((n) => !filterType || services.get(n).svc.type === filterType);
+  const allNames = useMemo(
+    () => [...services.keys()].filter((n) => !filterType || services.get(n).svc.type === filterType),
+    [services, filterType]
+  );
   const [idx, setIdx] = useState3(0);
+  const [query, setQuery] = useState3("");
+  const names = useMemo(() => {
+    if (!query) return allNames;
+    const q = query.toLowerCase();
+    return allNames.filter((n) => n.toLowerCase().includes(q));
+  }, [allNames, query]);
+  const clamped = Math.min(idx, Math.max(0, names.length - 1));
   useInput2((input, key) => {
-    if (key.escape) onClose();
-    else if (key.return) {
-      if (names[idx]) onSelect(names[idx]);
-    } else if (key.upArrow) setIdx((i) => Math.max(0, i - 1));
-    else if (key.downArrow) setIdx((i) => Math.min(names.length - 1, i + 1));
+    if (key.escape) {
+      if (query) setQuery("");
+      else onClose();
+      return;
+    }
+    if (key.return) {
+      if (names[clamped]) onSelect(names[clamped]);
+      return;
+    }
+    if (key.upArrow) {
+      setIdx((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setIdx((i) => Math.min(names.length - 1, i + 1));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setIdx(0);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && input.length === 1) {
+      setQuery((q) => q + input);
+      setIdx(0);
+    }
   }, { isActive: process.stdin.isTTY ?? false });
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
     /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
       " ",
       title,
-      " "
+      " ",
+      query && /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
+        "[",
+        query,
+        "]"
+      ] })
     ] }),
-    names.map((name, i) => /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: i === idx ? "cyan" : void 0, inverse: i === idx, children: [
+    names.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " (no matches) " }) : names.map((name, i) => /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: i === clamped ? "cyan" : void 0, inverse: i === clamped, children: [
       " ",
       name,
       " :",
       services.get(name).svc.port,
       " "
     ] }) }, name)),
-    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191\u2193 navigate  Enter select  Esc close" })
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "type to filter  \u2191\u2193 navigate  Enter select  Esc clear/close" })
   ] });
 }
 
@@ -1445,8 +1935,113 @@ function createLazyProxy(opts) {
   };
 }
 
+// src/process/external.ts
+import { spawn as spawn4 } from "child_process";
+import { join as join5 } from "path";
+var DEFAULT_START_TIMEOUT_S = 60;
+async function startExternals(externals, opts) {
+  const procs = [];
+  const failed = [];
+  for (const svc of externals) {
+    const proc = spawnExternal(svc, opts);
+    procs.push({ svc, proc, pid: proc.pid ?? null });
+    if (!svc.healthCheck) {
+      opts.onLog?.(svc.name, "\u2705 started (no healthCheck)");
+      continue;
+    }
+    if (svc.healthCheck.type === "tcp" && !svc.port) {
+      opts.onLog?.(svc.name, "\u26A0 tcp healthCheck requires `port` \u2014 skipping wait");
+      continue;
+    }
+    const timeoutMs = (svc.startTimeout ?? DEFAULT_START_TIMEOUT_S) * 1e3;
+    const ok = await waitHealthy(svc, timeoutMs);
+    if (ok) {
+      opts.onLog?.(svc.name, "\u2705 healthy");
+    } else {
+      opts.onLog?.(svc.name, `\u274C never became healthy (timeout ${timeoutMs / 1e3}s)`);
+      failed.push(svc.name);
+    }
+  }
+  return { procs, allHealthy: failed.length === 0, failed };
+}
+async function stopExternals(procs, platform, opts = {}) {
+  for (const { svc, proc, pid } of procs) {
+    try {
+      if (pid) platform.killTree(pid);
+      if (svc.stopCmd) {
+        opts.onLog?.(svc.name, `\u{1F9F9} ${svc.stopCmd}`);
+        await new Promise((resolve4) => {
+          const isWin = process.platform === "win32";
+          const shell = isWin ? "cmd.exe" : "sh";
+          const flag = isWin ? "/c" : "-c";
+          const cwd = svc.cwd ? join5(opts.baseCwd, svc.cwd) : opts.baseCwd;
+          const env = { ...opts.env, ...svc.extraEnv ?? {} };
+          const child = spawn4(shell, [flag, svc.stopCmd], { cwd, env, stdio: "ignore" });
+          child.on("close", () => resolve4());
+          child.on("error", () => resolve4());
+          setTimeout(() => resolve4(), 1e4);
+        });
+      }
+    } catch {
+    }
+    void proc;
+  }
+}
+function spawnExternal(svc, opts) {
+  const isWin = process.platform === "win32";
+  const shell = isWin ? "cmd.exe" : "sh";
+  const flag = isWin ? "/c" : "-c";
+  const cwd = svc.cwd ? join5(opts.baseCwd, svc.cwd) : opts.baseCwd;
+  const env = { ...opts.env, ...svc.extraEnv ?? {} };
+  opts.onLog?.(svc.name, `\u{1F680} ${svc.cmd}`);
+  const child = spawn4(shell, [flag, svc.cmd], {
+    cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.stderr?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.on("error", (err) => opts.onLog?.(svc.name, `\u274C spawn error: ${err.message}`));
+  return child;
+}
+async function waitHealthy(svc, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const port = svc.port;
+  while (Date.now() < deadline) {
+    if (await checkHealth(port, svc.healthCheck)) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+// src/tui/tips.ts
+function pickTip(state) {
+  if (state.crashLoopedCount > 0 && !state.shown.has("crashed")) {
+    return { id: "crashed", message: "tip: press r to restart, or check the log of the failing service" };
+  }
+  if (state.totalLogs > 1e3 && !state.hasSearch && !state.shown.has("search")) {
+    return { id: "search", message: "tip: press / to search in logs" };
+  }
+  if (state.totalLogs > 500 && !state.hasFilter && !state.shown.has("filter")) {
+    return { id: "filter", message: "tip: press f to filter logs by service" };
+  }
+  return null;
+}
+
 // src/tui/App.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function buildServiceUrl(name, port, proxyActive, proxyOpts) {
+  if (proxyActive && proxyOpts) {
+    const sub = proxyOpts.routes[name];
+    if (sub !== void 0) {
+      const host = sub ? `${sub}.${proxyOpts.domain}` : proxyOpts.domain;
+      const scheme = proxyOpts.tls ? "https" : "http";
+      return `${scheme}://${host}`;
+    }
+  }
+  return `http://localhost:${port}`;
+}
 function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts, logSink }) {
   const { stdout } = useStdout();
   const [rows, setRows] = useState5(stdout?.rows ?? 40);
@@ -1464,6 +2059,9 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   const pm = useProcessManager(platform, baseCwd, env, logSink);
   const [booted, setBooted] = useState5(false);
   const lazyProxies = useRef3(/* @__PURE__ */ new Map());
+  const externals = useRef3([]);
+  const shownTips = useRef3(/* @__PURE__ */ new Set());
+  const [activeTip, setActiveTip] = useState5(null);
   const kb = useKeyBindings({
     onQuit: () => {
       void shutdown();
@@ -1475,12 +2073,35 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   const shutdown = useCallback3(async () => {
     lazyProxies.current.forEach((p) => p.destroy());
     await pm.cleanup();
+    if (externals.current.length) {
+      await stopExternals(externals.current, platform, {
+        baseCwd,
+        env,
+        onLog: (svc, msg) => pm.pushLog(`ext:${svc}`, msg, 12)
+      });
+      externals.current = [];
+    }
     await logSink?.close();
     process.exit(0);
-  }, [pm, logSink]);
+  }, [pm, logSink, platform, baseCwd, env]);
   useEffect5(() => {
     pm.setPaused(kb.logsPaused || kb.logsScrollOffset > 0);
   }, [kb.logsPaused, kb.logsScrollOffset, pm]);
+  useEffect5(() => {
+    const tip = pickTip({
+      totalLogs: pm.logs.length,
+      hasSearch: !!kb.searchTerm,
+      hasFilter: !!kb.logFilter,
+      crashLoopedCount: [...pm.states.values()].filter(isCrashLooped).length,
+      shown: shownTips.current
+    });
+    if (tip && tip.id !== activeTip) {
+      shownTips.current.add(tip.id);
+      setActiveTip(tip.message);
+      const timer = setTimeout(() => setActiveTip(null), 12e3);
+      return () => clearTimeout(timer);
+    }
+  }, [pm.logs.length, pm.states, kb.searchTerm, kb.logFilter, activeTip]);
   useProxySync(proxyProvider, proxyOpts, pm.states, kb.proxyEnabled);
   useEffect5(() => {
     if (booted || !pm.manager) return;
@@ -1489,6 +2110,19 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
     (async () => {
       const lazyMode = cliArgs.lazy;
       const lazyTimeout = cliArgs.lazyTimeout;
+      if (config.external?.length) {
+        const result = await startExternals(config.external, {
+          baseCwd,
+          env,
+          platform,
+          onLog: (svc, msg) => pm.pushLog(`ext:${svc}`, msg, 12)
+        });
+        externals.current = result.procs;
+        if (!result.allHealthy) {
+          pm.pushLog("devup", `\u274C external(s) failed: ${result.failed.join(", ")}. Aborting boot.`, 5);
+          return;
+        }
+      }
       if (lazyMode && config.lazy) {
         const { alwaysOn, lazy } = classifyServices(services, config.lazy);
         const aoPhases = groupByPhase(alwaysOn);
@@ -1582,23 +2216,32 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   }, [pm, kb]);
   const handleOpenSelect = useCallback3((name) => {
     const st = pm.states.get(name);
-    if (st) platform.openBrowser(`http://localhost:${st.svc.port}`);
+    if (st) {
+      const url = buildServiceUrl(name, st.svc.port, cliArgs.proxy, proxyOpts);
+      platform.openBrowser(url);
+    }
     kb.setModal("none");
-  }, [pm, platform, kb]);
+  }, [pm, platform, kb, cliArgs.proxy, proxyOpts]);
   const icon = config.icon ?? "\u{1F4E6}";
   const modeLabel = cliArgs.lazy && config.lazy ? "lazy" : "normal";
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "cyan", children: [
-      " ",
-      icon,
-      " ",
-      config.name,
-      " \u2014 devup \u2014 ",
-      services.length,
-      " services (",
-      modeLabel,
-      ") "
-    ] }) }),
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "cyan", children: [
+        " ",
+        icon,
+        " ",
+        config.name,
+        " \u2014 devup \u2014 ",
+        services.length,
+        " services (",
+        modeLabel,
+        ") "
+      ] }),
+      activeTip && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        " \xB7 ",
+        activeTip
+      ] })
+    ] }),
     /* @__PURE__ */ jsx6(
       LogsPanel,
       {
@@ -1636,23 +2279,23 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
 }
 
 // src/process/log-sink.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync, createWriteStream } from "fs";
-import { join as join4, dirname as dirname4 } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, renameSync, createWriteStream } from "fs";
+import { join as join6, dirname as dirname5 } from "path";
+import { homedir as homedir2 } from "os";
 var LogSink = class {
   dir;
   rotateOnStart;
   streams = /* @__PURE__ */ new Map();
   seen = /* @__PURE__ */ new Set();
   constructor(opts) {
-    const root = opts.rootDir ?? join4(homedir(), ".devup", "logs");
-    this.dir = join4(root, sanitize(opts.projectName));
+    const root = opts.rootDir ?? join6(homedir2(), ".devup", "logs");
+    this.dir = join6(root, sanitize2(opts.projectName));
     this.rotateOnStart = opts.rotateOnStart ?? true;
     mkdirSync4(this.dir, { recursive: true });
   }
   /** Returns the file path for a service log (useful for tests / UI). */
   pathFor(svcName) {
-    return join4(this.dir, `${sanitize(svcName)}.log`);
+    return join6(this.dir, `${sanitize2(svcName)}.log`);
   }
   write(svcName, line) {
     const stream = this.streamFor(svcName);
@@ -1671,9 +2314,9 @@ var LogSink = class {
     let s = this.streams.get(svcName);
     if (s) return s;
     const file = this.pathFor(svcName);
-    if (this.rotateOnStart && !this.seen.has(svcName) && existsSync8(file)) {
+    if (this.rotateOnStart && !this.seen.has(svcName) && existsSync10(file)) {
       try {
-        mkdirSync4(dirname4(file), { recursive: true });
+        mkdirSync4(dirname5(file), { recursive: true });
         renameSync(file, file + ".prev");
       } catch {
       }
@@ -1686,7 +2329,7 @@ var LogSink = class {
     return s;
   }
 };
-function sanitize(name) {
+function sanitize2(name) {
   return name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "devup";
 }
 
@@ -1696,8 +2339,18 @@ function renderDryRun(opts) {
   const lines = [];
   lines.push(`Project:  ${config.icon ?? "\u{1F4E6}"} ${config.name}`);
   lines.push(`Mode:     ${cliArgs.lazy && config.lazy ? "lazy" : "normal"}`);
+  if (cliArgs.profile) lines.push(`Profile:  ${cliArgs.profile}`);
   lines.push(`Services: ${services.length}`);
   lines.push("");
+  if (config.external?.length) {
+    lines.push(`Externals (${config.external.length}):`);
+    for (const ext of config.external) {
+      const hc = ext.healthCheck;
+      const hcTag = hc ? ` health=${hc.type}${hc.type === "http" ? " " + (hc.path ?? "/") : ""} :${ext.port ?? "?"}` : "";
+      lines.push(`  - ${ext.name.padEnd(20)} ${ext.cmd}${hcTag}`);
+    }
+    lines.push("");
+  }
   const lazyMode = cliArgs.lazy && !!config.lazy;
   let alwaysOn = services;
   let lazy = [];
@@ -1771,6 +2424,26 @@ async function runOnce(opts) {
       }
     }
   });
+  let externals = [];
+  if (config.external?.length) {
+    out(`\u25B6 externals (${config.external.length})`);
+    const result = await startExternals(config.external, {
+      baseCwd,
+      env,
+      platform,
+      onLog: (svc, msg) => {
+        logSink?.write(`ext:${svc}`, msg);
+        out(`[ext:${svc}] ${msg}`);
+      }
+    });
+    externals = result.procs;
+    if (!result.allHealthy) {
+      out(`\u2717 externals failed: ${result.failed.join(", ")}`);
+      await stopExternals(externals, platform, { baseCwd, env });
+      await mgr.cleanup();
+      return 1;
+    }
+  }
   const phases = groupByPhase(services);
   const phaseNums = Object.keys(phases).map(Number).sort((a, b) => a - b);
   const apiNames = services.filter((s) => s.type === "api").map((s) => s.name);
@@ -1784,16 +2457,18 @@ async function runOnce(opts) {
       if (!installed) {
         out(`\u2717 install failed for ${svc.name}`);
         await mgr.cleanup();
+        await stopExternals(externals, platform, { baseCwd, env });
         return 1;
       }
       await mgr.start(svc, ci);
     }
     const apis = phases[num].filter((s) => s.type === "api");
     for (const api of apis) {
-      const ok = await waitHealthy(api, deadline);
+      const ok = await waitHealthy2(api, deadline);
       if (!ok) {
         out(`\u2717 ${api.name} did not become healthy within ${cliArgs.onceTimeout}s`);
         await mgr.cleanup();
+        await stopExternals(externals, platform, { baseCwd, env });
         return 1;
       }
       out(`\u2713 ${api.name} ready`);
@@ -1807,9 +2482,10 @@ async function runOnce(opts) {
   const summary = `ready: ${apiNames.length} APIs in ${((cliArgs.onceTimeout * 1e3 - (deadline - Date.now())) / 1e3).toFixed(1)}s`;
   out(summary);
   await mgr.cleanup();
+  await stopExternals(externals, platform, { baseCwd, env });
   return 0;
 }
-async function waitHealthy(svc, deadline) {
+async function waitHealthy2(svc, deadline) {
   while (Date.now() < deadline) {
     const ok = await checkHealth(svc.port, svc.healthCheck);
     if (ok) return true;
@@ -1824,9 +2500,46 @@ function defineConfig(config) {
 }
 
 // src/index.ts
+function readVersion() {
+  try {
+    const here = dirname6(fileURLToPath2(import.meta.url));
+    const pkgPath = join7(here, "..", "package.json");
+    return JSON.parse(readFileSync2(pkgPath, "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 async function main() {
+  const raw = process.argv.slice(2);
+  if (raw.includes("-v") || raw.includes("--version")) {
+    console.log(readVersion());
+    return;
+  }
+  if (raw.includes("-h") || raw.includes("--help")) {
+    console.log(USAGE);
+    return;
+  }
+  const subcmd = detectSubcommand(raw);
+  if (subcmd === "help") {
+    process.exit(runHelp(raw.slice(1)));
+  }
   const cwd = process.cwd();
-  const cliArgs = parseCliArgs(process.argv.slice(2));
+  const cliArgs = parseCliArgs(raw);
+  if (subcmd) {
+    const subArgs = raw.slice(1);
+    let cfgPath;
+    try {
+      cfgPath = findConfigFile(cwd, cliArgs.configPath);
+    } catch (e) {
+      console.error(`\u274C ${e.message}`);
+      process.exit(1);
+    }
+    const cfg = await loadConfig(cfgPath);
+    const subOpts = { config: cfg, baseCwd: cwd, env: process.env, logDir: cliArgs.logDir };
+    if (subcmd === "logs") process.exit(await runLogs(subArgs, subOpts));
+    if (subcmd === "install") process.exit(await runInstall(subOpts));
+    if (subcmd === "status") process.exit(await runStatus(subOpts));
+  }
   let configPath;
   try {
     configPath = findConfigFile(cwd, cliArgs.configPath);
@@ -1841,13 +2554,19 @@ async function main() {
 ${formatValidationErrors(errors)}`);
     process.exit(1);
   }
-  const services = filterServices(config.services, cliArgs);
+  let services;
+  try {
+    services = filterServices(config.services, cliArgs, config);
+  } catch (e) {
+    console.error(`\u274C ${e.message}`);
+    process.exit(1);
+  }
   if (!services.length) {
     console.error("\u274C No services to run after filtering");
     process.exit(1);
   }
   const platform = await detectPlatform();
-  const envFile = config.envFile ? join5(cwd, config.envFile) : join5(cwd, ".env");
+  const envFile = config.envFile ? join7(cwd, config.envFile) : join7(cwd, ".env");
   const env = parseEnvFile(envFile, process.env);
   if (config.env) {
     for (const [k, v] of Object.entries(config.env)) {
@@ -1864,7 +2583,7 @@ ${formatValidationErrors(errors)}`);
       routes: config.proxy.routes,
       tls: cliArgs.proxyTls ?? config.proxy.tls ?? true,
       entrypoint: cliArgs.proxyEntrypoint ?? config.proxy.entrypoint ?? "websecure",
-      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join5(homedir2(), ".traefik", "traefik_conf.yaml")
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join7(homedir3(), ".traefik", "traefik_conf.yaml")
     };
   }
   if (cliArgs.dryRun) {