@gachlab/devup 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import React6 from "react";
+import React7 from "react";
 import { render } from "ink";
-import { join as join4 } from "path";
-import { homedir } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/config/loader.ts
 import { existsSync } from "fs";
@@ -48,6 +48,30 @@ async function loadConfig(configPath) {
 // src/config/validator.ts
 import { existsSync as existsSync2 } from "fs";
 import { resolve as resolve2 } from "path";
+
+// src/lazy/classifier.ts
+var LAZY_PORT_OFFSET = 1e4;
+function classifyServices(services, config) {
+  const alwaysOnSet = new Set(config?.alwaysOn ?? []);
+  const alwaysOn = [];
+  const lazy = [];
+  for (const svc of services) {
+    if (alwaysOnSet.has(svc.name)) alwaysOn.push(svc);
+    else lazy.push(svc);
+  }
+  return { alwaysOn, lazy };
+}
+function getLazyRealPort(originalPort) {
+  return originalPort + LAZY_PORT_OFFSET;
+}
+function rewriteServicePort(svc) {
+  const realPort = getLazyRealPort(svc.port);
+  const args = svc.args.map((a) => a === String(svc.port) ? String(realPort) : a);
+  const extraEnv = { ...svc.extraEnv, PORT_OVERRIDE: String(realPort) };
+  return { ...svc, port: realPort, args, extraEnv, realPort, originalPort: svc.port };
+}
+
+// src/config/validator.ts
 function validateConfig(config, cwd) {
   const errors = [];
   if (!config.name?.trim()) {
@@ -88,6 +112,34 @@ 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") {
+        errors.push({ field: `services[${svc.name}].healthCheck.type`, message: `Invalid healthCheck.type: ${hc.type} (must be "tcp" or "http")` });
+      }
+      if (hc.type === "http" && hc.path && !hc.path.startsWith("/")) {
+        errors.push({ field: `services[${svc.name}].healthCheck.path`, message: `healthCheck.path must start with "/": got "${hc.path}"` });
+      }
+    }
   }
   if (config.lazy?.alwaysOn) {
     for (const ref of config.lazy.alwaysOn) {
@@ -96,6 +148,50 @@ function validateConfig(config, cwd) {
       }
     }
   }
+  if (config.lazy) {
+    const alwaysOn = new Set(config.lazy.alwaysOn ?? []);
+    const portToSvc = /* @__PURE__ */ new Map();
+    for (const svc of config.services) portToSvc.set(svc.port, svc.name);
+    for (const svc of config.services) {
+      if (alwaysOn.has(svc.name)) continue;
+      const realPort = svc.port + LAZY_PORT_OFFSET;
+      const conflict = portToSvc.get(realPort);
+      if (conflict && conflict !== svc.name) {
+        errors.push({
+          field: `services[${svc.name}].port`,
+          message: `Lazy real port ${realPort} (= ${svc.port}+${LAZY_PORT_OFFSET}) collides with service ${conflict}`
+        });
+      }
+    }
+  }
+  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)) {
@@ -103,6 +199,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) {
@@ -111,6 +220,7 @@ function formatValidationErrors(errors) {
 
 // src/config/cli.ts
 var DEFAULT_LAZY_TIMEOUT = 10;
+var DEFAULT_ONCE_TIMEOUT = 90;
 function parseCliArgs(argv) {
   const args = {
     skip: [],
@@ -118,7 +228,11 @@ function parseCliArgs(argv) {
     lazyTimeout: DEFAULT_LAZY_TIMEOUT,
     proxy: false,
     proxyTls: true,
-    proxyEntrypoint: "websecure"
+    proxyEntrypoint: "websecure",
+    dryRun: false,
+    once: false,
+    onceTimeout: DEFAULT_ONCE_TIMEOUT,
+    logFile: true
   };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -140,6 +254,10 @@ function parseCliArgs(argv) {
         args.services = next?.split(",");
         i++;
         break;
+      case "--profile":
+        args.profile = next;
+        i++;
+        break;
       case "--lazy":
         args.lazy = true;
         break;
@@ -171,13 +289,39 @@ function parseCliArgs(argv) {
         args.proxyEntrypoint = next ?? "websecure";
         i++;
         break;
+      case "--dry-run":
+        args.dryRun = true;
+        break;
+      case "--once":
+        args.once = true;
+        break;
+      case "--once-timeout":
+        args.onceTimeout = parseInt(next ?? "", 10) || DEFAULT_ONCE_TIMEOUT;
+        i++;
+        break;
+      case "--no-log-file":
+        args.logFile = false;
+        break;
+      case "--log-dir":
+        args.logDir = next;
+        i++;
+        break;
     }
   }
   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) {
@@ -268,9 +412,93 @@ ${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";
+var EMPTY_CONFIG2 = "# devup: no healthy services\n";
+var NginxProvider = class {
+  name = "nginx";
+  generate(services, opts) {
+    const blocks = [];
+    for (const [name, st] of services) {
+      if (st.health !== "up") continue;
+      const sub = opts.routes[name];
+      if (sub === void 0) continue;
+      const serverName = sub ? `${sub}.${opts.domain}` : opts.domain;
+      const port = st.realPort ?? st.port;
+      const listen = opts.tls ? "443 ssl" : "80";
+      const tlsBlock = opts.tls ? `    ssl_certificate     /etc/nginx/certs/${serverName}.crt;
+    ssl_certificate_key /etc/nginx/certs/${serverName}.key;
+` : "";
+      blocks.push(
+        `server {
+    listen ${listen};
+    server_name ${serverName};
+` + tlsBlock + `    location / {
+        proxy_pass http://${opts.host}:${port};
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}`
+      );
+    }
+    if (!blocks.length) return EMPTY_CONFIG2;
+    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);
+  }
+  clear(opts) {
+    this.write(EMPTY_CONFIG2, opts);
+  }
+};
+
+// src/proxy-config/caddy.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var EMPTY_CONFIG3 = "# devup: no healthy services\n";
+var CaddyProvider = class {
+  name = "caddy";
+  generate(services, opts) {
+    const blocks = [];
+    for (const [name, st] of services) {
+      if (st.health !== "up") continue;
+      const sub = opts.routes[name];
+      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()
+  traefik: () => new TraefikProvider(),
+  nginx: () => new NginxProvider(),
+  caddy: () => new CaddyProvider()
 };
 function detectProxyProvider(name) {
   const factory = providers[name];
@@ -282,12 +510,12 @@ function detectProxyProvider(name) {
 }
 
 // src/utils.ts
-import { existsSync as existsSync4, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+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 (!existsSync4(filePath)) return env;
+  if (!existsSync6(filePath)) return env;
   for (const line of readFileSync(filePath, "utf8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -309,15 +537,17 @@ function fmtUptime(ms) {
   const m = Math.floor(s / 60);
   if (m < 60) return `${m}m${s % 60}s`;
   const h = Math.floor(m / 60);
-  return `${h}h${m % 60}m`;
+  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 (!existsSync4(nm)) return true;
+  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 (existsSync4(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
+    if (existsSync6(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
   } catch {
   }
   return true;
@@ -325,7 +555,7 @@ function needsInstall(fullCwd) {
 function writeInstallStamp(fullCwd) {
   try {
     const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
-    writeFileSync2(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
+    writeFileSync4(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
   } catch {
   }
 }
@@ -396,10 +626,11 @@ import { join as join3 } from "path";
 
 // src/process/health.ts
 import net from "net";
-function checkPort(port, host = "127.0.0.1") {
+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(2e3);
+    socket.setTimeout(timeoutMs);
     socket.once("connect", () => {
       socket.destroy();
       resolve3(true);
@@ -415,6 +646,39 @@ function checkPort(port, host = "127.0.0.1") {
     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) => {
@@ -437,9 +701,9 @@ function deriveHealth(isUp, currentStatus) {
 
 // src/process/installer.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 function installService(cwd, env, onLog) {
-  if (!existsSync5(cwd)) {
+  if (!existsSync7(cwd)) {
     onLog?.(`\u26A0 directory not found: ${cwd}`);
     return Promise.resolve(false);
   }
@@ -475,6 +739,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 lineBuffer(onLine) {
+  let buf = "";
+  return {
+    push(chunk) {
+      buf += chunk.toString();
+      let idx;
+      while ((idx = buf.indexOf("\n")) !== -1) {
+        const line = buf.slice(0, idx).replace(/\r$/, "");
+        buf = buf.slice(idx + 1);
+        if (line.length) onLine(line);
+      }
+    },
+    flush() {
+      if (buf.length) {
+        onLine(buf);
+        buf = "";
+      }
+    }
+  };
+}
 var ProcessManager = class {
   state = /* @__PURE__ */ new Map();
   procs = /* @__PURE__ */ new Set();
@@ -488,9 +782,10 @@ var ProcessManager = class {
     this.platform = opts.platform;
     this.events = opts.events;
   }
-  async install(svc) {
+  async install(svc, colorIdx) {
     const cwd = join3(this.baseCwd, svc.cwd);
-    return installService(cwd, this.env, (msg) => this.log(svc.name, msg, this.getColorIdx(svc.name)));
+    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);
@@ -501,6 +796,13 @@ 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 env = buildProcessEnv(svc, this.env);
     const proc = spawn2(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
@@ -520,13 +822,31 @@ var ProcessManager = class {
     this.state.set(svc.name, state);
     this.procs.add(proc);
     this.events.onStateChange(svc.name, state);
-    proc.stdout?.on("data", (d) => this.log(svc.name, d.toString(), colorIdx));
-    proc.stderr?.on("data", (d) => {
-      state.errors += d.toString().split("\n").filter(Boolean).length;
-      this.log(svc.name, d.toString(), 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));
+    proc.stderr?.on("data", (d) => stderrBuf.push(d));
+    proc.stdout?.on("end", () => stdoutBuf.flush());
+    proc.stderr?.on("end", () => stderrBuf.flush());
     proc.on("close", (code) => {
       this.procs.delete(proc);
+      this.stopWatchProc(state);
       if (state.intentionalStop) {
         state.intentionalStop = false;
         return;
@@ -550,19 +870,96 @@ 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((resolve3) => {
+      const isWin = process.platform === "win32";
+      const shell = isWin ? "cmd.exe" : "sh";
+      const shellFlag = isWin ? "/c" : "-c";
+      const env = buildProcessEnv(svc, this.env);
+      const child = spawn2(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);
+        resolve3(false);
+      });
+      child.on("close", (code) => {
+        outBuf.flush();
+        errBuf.flush();
+        if (code === 0) {
+          this.log(svc.name, `[build] \u2705 done`, colorIdx);
+          resolve3(true);
+        } else {
+          this.log(svc.name, `[build] \u274C exited with code ${code}`, colorIdx);
+          resolve3(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 = spawn2(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);
     if (!st) return;
     this.stop(name);
-    st.restarts++;
+    st.restarts = 0;
     const delay = st.proc ? 1500 : 100;
     await new Promise((r) => setTimeout(r, delay));
     await this.start(st.svc, st.colorIdx, true);
@@ -574,39 +971,69 @@ var ProcessManager = class {
         st.health = st.status === "idle" ? "idle" : "down";
         continue;
       }
-      const port = st.svc.port;
-      const isUp = await checkPort(port);
+      const isUp = await checkHealth(st.svc.port, st.svc.healthCheck);
       const prev = st.health;
       st.health = deriveHealth(isUp, st.status);
       if (st.health === "up" && st.status === "starting") st.status = "running";
       if (prev !== st.health) this.events.onStateChange(name, st);
     }
   }
-  cleanup() {
-    for (const proc of this.procs) {
+  async cleanup(opts = {}) {
+    const grace = opts.gracePeriodMs ?? 3e3;
+    const procs = [...this.procs];
+    if (!procs.length) return;
+    for (const proc of procs) {
+      const st = this.findStateByProc(proc);
+      if (st) {
+        st.intentionalStop = true;
+        this.stopWatchProc(st);
+      }
       if (proc.pid) this.platform.killTree(proc.pid);
     }
-    setTimeout(() => {
-      for (const proc of this.procs) {
-        if (proc.pid) this.platform.killTree(proc.pid, "SIGKILL");
+    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()))
+    );
+    let timedOut = false;
+    await Promise.race([
+      Promise.all(waits),
+      new Promise((resolve3) => setTimeout(() => {
+        timedOut = true;
+        resolve3();
+      }, grace))
+    ]);
+    if (timedOut) {
+      for (const proc of procs) {
+        if (proc.pid && proc.exitCode === null && proc.signalCode === null) {
+          this.platform.killTree(proc.pid, "SIGKILL");
+        }
       }
-    }, 3e3);
+      await Promise.race([
+        Promise.all(waits),
+        new Promise((resolve3) => setTimeout(resolve3, 1e3))
+      ]);
+    }
+  }
+  findStateByProc(proc) {
+    for (const st of this.state.values()) if (st.proc === proc) return st;
+    return void 0;
   }
   log(name, text, colorIdx) {
     this.events.onLog(name, text, colorIdx);
   }
-  getColorIdx(name) {
-    return this.state.get(name)?.colorIdx ?? 0;
-  }
 };
 
 // src/tui/hooks/useProcessManager.ts
-function useProcessManager(platform, baseCwd, env) {
+function useProcessManager(platform, baseCwd, env, logSink = null) {
   const [states, setStates] = useState(/* @__PURE__ */ new Map());
   const [logs, setLogs] = useState([]);
   const [stats, setStats] = useState(/* @__PURE__ */ new Map());
   const mgrRef = useRef(null);
   const prevCpu = useRef(/* @__PURE__ */ new Map());
+  const pausedRef = useRef(false);
+  const pendingLogsRef = useRef([]);
+  const sinkRef = useRef(logSink);
+  sinkRef.current = logSink;
   useEffect(() => {
     const mgr2 = new ProcessManager({
       baseCwd,
@@ -614,9 +1041,17 @@ function useProcessManager(platform, baseCwd, env) {
       platform,
       events: {
         onLog: (svcName, text, colorIdx) => {
-          const lines = text.split("\n").filter(Boolean);
+          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, ...lines.map((l) => ({ svcName, text: l, colorIdx, ts: Date.now() }))];
+            const next = prev.concat(entry);
             return next.length > 5e3 ? next.slice(-5e3) : next;
           });
         },
@@ -659,6 +1094,36 @@ function useProcessManager(platform, baseCwd, env) {
     return () => clearInterval(id);
   }, [platform]);
   const mgr = mgrRef.current;
+  const clearLogs = useCallback(() => {
+    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) {
+      const flush = pendingLogsRef.current;
+      pendingLogsRef.current = [];
+      setLogs((prev) => {
+        const next = prev.concat(flush);
+        return next.length > 5e3 ? next.slice(-5e3) : next;
+      });
+    }
+  }, []);
   return {
     states,
     logs,
@@ -666,8 +1131,11 @@ function useProcessManager(platform, baseCwd, env) {
     start: useCallback((svc, colorIdx) => mgr?.start(svc, colorIdx), [mgr]),
     stop: useCallback((name) => mgr?.stop(name), [mgr]),
     restart: useCallback((name) => mgr?.restart(name), [mgr]),
-    install: useCallback((svc) => mgr?.install(svc), [mgr]),
+    install: useCallback((svc, colorIdx) => mgr?.install(svc, colorIdx), [mgr]),
     cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
+    clearLogs,
+    setPaused,
+    pushLog,
     manager: mgr
   };
 }
@@ -676,6 +1144,24 @@ function useProcessManager(platform, baseCwd, env) {
 import { useInput } from "ink";
 import { useState as useState2, useCallback as useCallback2 } from "react";
 var SORT_MODES = ["name", "mem", "errors"];
+function scrollBy(setState, delta) {
+  setState((s) => {
+    if (s.panel === "logs") {
+      const next2 = s.logsScrollOffset - delta;
+      return { ...s, logsScrollOffset: Math.max(0, next2) };
+    }
+    const next = s.statsScrollOffset + delta;
+    return { ...s, statsScrollOffset: Math.max(0, next) };
+  });
+}
+function scrollTo(setState, target) {
+  setState((s) => {
+    if (s.panel === "logs") {
+      return { ...s, logsScrollOffset: target === "top" ? Number.MAX_SAFE_INTEGER : 0 };
+    }
+    return { ...s, statsScrollOffset: target === "top" ? 0 : Number.MAX_SAFE_INTEGER };
+  });
+}
 function useKeyBindings(opts) {
   const [state, setState] = useState2({
     panel: "logs",
@@ -696,6 +1182,14 @@ function useKeyBindings(opts) {
   useInput((input, key) => {
     if (state.modal !== "none") return;
     if (input === "q" || key.ctrl && input === "c") opts.onQuit();
+    else if (key.ctrl && input === "a") scrollTo(setState, "top");
+    else if (key.ctrl && input === "e") scrollTo(setState, "bottom");
+    else if (key.ctrl && input === "b") scrollBy(setState, -10);
+    else if (key.ctrl && input === "f") scrollBy(setState, 10);
+    else if (key.upArrow) scrollBy(setState, -1);
+    else if (key.downArrow) scrollBy(setState, 1);
+    else if (input === "[") scrollBy(setState, -10);
+    else if (input === "]") scrollBy(setState, 10);
     else if (input === "c") opts.onClearLogs();
     else if (key.tab) setState((s) => ({ ...s, panel: s.panel === "logs" ? "stats" : "logs" }));
     else if (input === "f") setModal("filter");
@@ -709,60 +1203,6 @@ function useKeyBindings(opts) {
     else if (input === "T") {
       opts.onToggleProxy();
       setState((s) => ({ ...s, proxyEnabled: !s.proxyEnabled }));
-    } else if (key.upArrow) {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: Math.max(0, s.logsScrollOffset - 1) };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: Math.max(0, s.statsScrollOffset - 1) };
-        }
-        return s;
-      });
-    } else if (key.downArrow) {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: s.logsScrollOffset + 1 };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: s.statsScrollOffset + 1 };
-        }
-        return s;
-      });
-    } else if (input === "[" || key.ctrl && input === "b") {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: Math.max(0, s.logsScrollOffset - 10) };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: Math.max(0, s.statsScrollOffset - 10) };
-        }
-        return s;
-      });
-    } else if (input === "]" || key.ctrl && input === "f") {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: s.logsScrollOffset + 10 };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: s.statsScrollOffset + 10 };
-        }
-        return s;
-      });
-    } else if (key.ctrl && input === "a") {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: 0 };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: 0 };
-        }
-        return s;
-      });
-    } else if (key.ctrl && input === "e") {
-      setState((s) => {
-        if (s.panel === "logs") {
-          return { ...s, logsScrollOffset: Number.MAX_SAFE_INTEGER };
-        } else if (s.panel === "stats") {
-          return { ...s, statsScrollOffset: Number.MAX_SAFE_INTEGER };
-        }
-        return s;
-      });
     }
   }, { isActive });
   return {
@@ -780,26 +1220,28 @@ function useKeyBindings(opts) {
 // src/tui/hooks/useProxySync.ts
 import { useEffect as useEffect2, useRef as useRef2 } from "react";
 function useProxySync(provider, opts, states, enabled) {
-  const intervalRef = useRef2(null);
+  const statesRef = useRef2(states);
+  const lastContentRef = useRef2(null);
+  statesRef.current = states;
   useEffect2(() => {
-    if (!provider || !opts || !enabled) {
-      if (intervalRef.current) clearInterval(intervalRef.current);
-      return;
-    }
+    if (!provider || !opts || !enabled) return;
     const sync = () => {
       const svcStates = /* @__PURE__ */ new Map();
-      for (const [name, st] of states) {
+      for (const [name, st] of statesRef.current) {
         svcStates.set(name, { port: st.svc.port, health: st.health, realPort: st.svc.realPort });
       }
       const content = provider.generate(svcStates, opts);
+      if (content === lastContentRef.current) return;
+      lastContentRef.current = content;
       provider.write(content, opts);
     };
     sync();
-    intervalRef.current = setInterval(sync, 3e3);
+    const id = setInterval(sync, 3e3);
     return () => {
-      if (intervalRef.current) clearInterval(intervalRef.current);
+      clearInterval(id);
+      lastContentRef.current = null;
     };
-  }, [provider, opts, enabled, states]);
+  }, [provider, opts, enabled]);
 }
 
 // src/tui/LogsPanel.tsx
@@ -808,27 +1250,25 @@ import { Box, Text } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
 function LogsPanel({ logs, filter, searchTerm, paused, showTimestamps, maxNameLen, height, focused, scrollOffset, resetScroll }) {
   const filtered = filter ? logs.filter((l) => l.svcName === filter) : logs;
-  const contentHeight = height - 2;
+  const contentHeight = Math.max(1, height - 2);
   const totalLines = filtered.length;
-  let startIndex = 0;
-  if (scrollOffset === Number.MAX_SAFE_INTEGER) {
-    startIndex = Math.max(0, totalLines - contentHeight);
-  } else if (scrollOffset > 0) {
-    startIndex = Math.min(scrollOffset, Math.max(0, totalLines - contentHeight));
-  } else {
-    startIndex = Math.max(0, totalLines - contentHeight);
-  }
-  const visible = filtered.slice(startIndex, startIndex + contentHeight);
+  const maxOffset = Math.max(0, totalLines - contentHeight);
+  const effectiveOffset = scrollOffset === Number.MAX_SAFE_INTEGER ? maxOffset : Math.min(scrollOffset, maxOffset);
+  const startIndex = Math.max(0, totalLines - contentHeight - effectiveOffset);
+  const endIndex = Math.min(startIndex + contentHeight, totalLines);
+  const visible = filtered.slice(startIndex, endIndex);
   useEffect3(() => {
     resetScroll();
   }, [filter, searchTerm, resetScroll]);
+  const scrolled = effectiveOffset > 0;
   const label = [
     "Logs",
     filter ? `[${filter}]` : "",
     searchTerm ? `/${searchTerm}` : "",
     paused ? "[PAUSED]" : "",
+    scrolled ? "[SCROLL]" : "",
     `${filtered.length} lines`,
-    focused ? `(${startIndex + 1}-${Math.min(startIndex + contentHeight, totalLines)}/${totalLines})` : ""
+    focused && totalLines > 0 ? `(${startIndex + 1}-${endIndex}/${totalLines})` : ""
   ].filter(Boolean).join(" ");
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: focused ? "cyan" : "gray", height, children: [
     /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
@@ -931,33 +1371,29 @@ function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused, scro
   }
   const stackMem = totalMemMB >= 1024 ? (totalMemMB / 1024).toFixed(2) + " GB" : totalMemMB.toFixed(1) + " MB";
   const ml = maxNameLen;
-  const contentHeight = height - 2;
-  const maxApiRows = Math.max(0, apis.length - (contentHeight - 2));
-  const maxWebRows = Math.max(0, webs.length - (contentHeight - 2));
-  let apiStartIndex = 0;
-  let webStartIndex = 0;
-  if (scrollOffset === Number.MAX_SAFE_INTEGER) {
-    apiStartIndex = maxApiRows;
-    webStartIndex = maxWebRows;
-  } else if (scrollOffset > 0) {
-    apiStartIndex = Math.min(scrollOffset, maxApiRows);
-    webStartIndex = Math.min(scrollOffset, maxWebRows);
-  }
-  const visibleApis = apis.slice(apiStartIndex, apiStartIndex + contentHeight - 2);
-  const visibleWebs = webs.slice(webStartIndex, webStartIndex + contentHeight - 2);
+  const contentHeight = Math.max(1, height - 2);
+  const rowsPerCol = Math.max(1, contentHeight - 2);
+  const maxRows = Math.max(0, Math.max(apis.length, webs.length) - rowsPerCol);
+  const effectiveOffset = scrollOffset === Number.MAX_SAFE_INTEGER ? maxRows : Math.min(scrollOffset, maxRows);
+  const apiStartIndex = Math.min(effectiveOffset, Math.max(0, apis.length - rowsPerCol));
+  const webStartIndex = Math.min(effectiveOffset, Math.max(0, webs.length - rowsPerCol));
+  const visibleApis = apis.slice(apiStartIndex, apiStartIndex + rowsPerCol);
+  const visibleWebs = webs.slice(webStartIndex, webStartIndex + rowsPerCol);
   useEffect4(() => {
     resetScroll();
   }, [sortMode, resetScroll]);
-  const totalServices = apis.length + webs.length;
-  const positionInfo = focused ? `(${Math.max(apiStartIndex, webStartIndex) + 1}-${Math.max(apiStartIndex, webStartIndex) + contentHeight - 2}/${totalServices})` : "";
+  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;
   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: [
         " Stats ",
         positionInfo
       ] }),
+      scrolled && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: " [SCROLL]" }),
       /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        "System: ",
+        " System: ",
         cpus,
         "c Load ",
         load,
@@ -1097,59 +1533,58 @@ function SearchInput({ onSubmit, onClose }) {
   ] });
 }
 
-// src/lazy/classifier.ts
-var LAZY_PORT_OFFSET = 1e4;
-function classifyServices(services, config) {
-  const alwaysOnSet = new Set(config?.alwaysOn ?? []);
-  const alwaysOn = [];
-  const lazy = [];
-  for (const svc of services) {
-    if (alwaysOnSet.has(svc.name)) alwaysOn.push(svc);
-    else lazy.push(svc);
-  }
-  return { alwaysOn, lazy };
-}
-function getLazyRealPort(originalPort) {
-  return originalPort + LAZY_PORT_OFFSET;
-}
-function rewriteServicePort(svc) {
-  const realPort = getLazyRealPort(svc.port);
-  const args = svc.args.map((a) => a === String(svc.port) ? String(realPort) : a);
-  const extraEnv = { ...svc.extraEnv, PORT_OVERRIDE: String(realPort) };
-  return { ...svc, port: realPort, args, extraEnv, realPort, originalPort: svc.port };
-}
-
 // src/lazy/proxy.ts
 import net2 from "net";
 function createLazyProxy(opts) {
   const { listenPort, targetPort, timeoutMin, onDemandStart, onIdleStop, isAlive, onLog } = opts;
   let idleTimer = null;
+  let lastActivity = Date.now();
   let starting = false;
   let serviceReady = false;
   let pendingConns = [];
-  function resetTimer() {
+  const activeConns = /* @__PURE__ */ new Set();
+  function bumpActivity() {
+    lastActivity = Date.now();
+  }
+  function scheduleIdleCheck() {
     if (idleTimer) clearTimeout(idleTimer);
-    if (timeoutMin > 0) {
-      idleTimer = setTimeout(() => {
-        serviceReady = false;
-        onLog?.(`\u{1F4A4} idle ${timeoutMin}min \u2014 stopping`);
-        onIdleStop();
-      }, timeoutMin * 6e4);
-    }
+    if (timeoutMin <= 0) return;
+    const periodMs = timeoutMin * 6e4;
+    idleTimer = setTimeout(() => {
+      const elapsed = Date.now() - lastActivity;
+      if (activeConns.size > 0 || elapsed < periodMs) {
+        scheduleIdleCheck();
+        return;
+      }
+      serviceReady = false;
+      onLog?.(`\u{1F4A4} idle ${timeoutMin}min \u2014 stopping`);
+      onIdleStop();
+    }, periodMs);
   }
   function pipeToTarget(client) {
     const target = net2.createConnection({ port: targetPort, host: "127.0.0.1", allowHalfOpen: true });
+    activeConns.add(client);
+    const cleanup = () => {
+      activeConns.delete(client);
+      bumpActivity();
+    };
     target.on("error", () => {
       client.destroy();
+      cleanup();
     });
     client.on("error", () => {
       target.destroy();
+      cleanup();
     });
+    client.on("close", cleanup);
+    target.on("close", cleanup);
     target.on("connect", () => {
       target.on("data", (chunk) => {
+        bumpActivity();
         if (!client.destroyed) client.write(chunk);
       });
       client.on("data", (chunk) => {
+        bumpActivity();
         if (!target.destroyed) target.write(chunk);
       });
       target.on("end", () => {
@@ -1161,7 +1596,7 @@ function createLazyProxy(opts) {
     });
   }
   async function handleConnection(client) {
-    resetTimer();
+    bumpActivity();
     client.on("error", () => {
     });
     if (serviceReady && isAlive()) {
@@ -1175,9 +1610,10 @@ function createLazyProxy(opts) {
     if (starting) return;
     starting = true;
     onLog?.("\u26A1 on-demand start");
+    let ok = false;
     try {
       await onDemandStart();
-      const ok = await waitForPort(targetPort, { timeout: 45e3, interval: 500 });
+      ok = await waitForPort(targetPort, { timeout: 45e3, interval: 500 });
       if (ok) serviceReady = true;
       else onLog?.("\u26A0 timeout waiting for service");
     } catch (e) {
@@ -1185,46 +1621,156 @@ function createLazyProxy(opts) {
     }
     starting = false;
     const conns = pendingConns.splice(0);
+    if (!ok) {
+      for (const conn of conns) {
+        if (!conn.destroyed) conn.destroy();
+      }
+      return;
+    }
     for (const conn of conns) {
       if (!conn.destroyed) pipeToTarget(conn);
     }
   }
   const server = net2.createServer({ allowHalfOpen: true }, (socket) => handleConnection(socket));
   server.listen(listenPort, "0.0.0.0");
-  resetTimer();
+  scheduleIdleCheck();
   return {
     server,
-    resetTimer,
+    resetTimer: bumpActivity,
     destroy: () => {
       if (idleTimer) clearTimeout(idleTimer);
       pendingConns.forEach((s) => s.destroy());
+      activeConns.forEach((s) => s.destroy());
       server.close();
     }
   };
 }
 
+// src/process/external.ts
+import { spawn as spawn3 } from "child_process";
+import { join as join4 } 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((resolve3) => {
+          const isWin = process.platform === "win32";
+          const shell = isWin ? "cmd.exe" : "sh";
+          const flag = isWin ? "/c" : "-c";
+          const cwd = svc.cwd ? join4(opts.baseCwd, svc.cwd) : opts.baseCwd;
+          const env = { ...opts.env, ...svc.extraEnv ?? {} };
+          const child = spawn3(shell, [flag, svc.stopCmd], { cwd, env, stdio: "ignore" });
+          child.on("close", () => resolve3());
+          child.on("error", () => resolve3());
+          setTimeout(() => resolve3(), 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 ? join4(opts.baseCwd, svc.cwd) : opts.baseCwd;
+  const env = { ...opts.env, ...svc.extraEnv ?? {} };
+  opts.onLog?.(svc.name, `\u{1F680} ${svc.cmd}`);
+  const child = spawn3(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/App.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts }) {
+function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts, logSink }) {
   const { stdout } = useStdout();
-  const rows = stdout?.rows ?? 40;
+  const [rows, setRows] = useState5(stdout?.rows ?? 40);
+  useEffect5(() => {
+    if (!stdout) return;
+    const onResize = () => setRows(stdout.rows ?? 40);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
   const logsHeight = Math.floor(rows * 0.65);
   const statsHeight = rows - logsHeight - 2;
   const maxNameLen = Math.max(...services.map((s) => s.name.length), 10);
-  const pm = useProcessManager(platform, baseCwd, env);
+  const pm = useProcessManager(platform, baseCwd, env, logSink);
   const [booted, setBooted] = useState5(false);
   const lazyProxies = useRef3(/* @__PURE__ */ new Map());
+  const externals = useRef3([]);
   const kb = useKeyBindings({
     onQuit: () => {
-      lazyProxies.current.forEach((p) => p.destroy());
-      pm.cleanup();
-      process.exit(0);
-    },
-    onClearLogs: () => {
+      void shutdown();
     },
+    onClearLogs: pm.clearLogs,
     onToggleProxy: () => {
     }
   });
+  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, platform, baseCwd, env]);
+  useEffect5(() => {
+    pm.setPaused(kb.logsPaused || kb.logsScrollOffset > 0);
+  }, [kb.logsPaused, kb.logsScrollOffset, pm]);
   useProxySync(proxyProvider, proxyOpts, pm.states, kb.proxyEnabled);
   useEffect5(() => {
     if (booted || !pm.manager) return;
@@ -1233,6 +1779,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);
@@ -1240,8 +1799,9 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
         for (const num of Object.keys(aoPhases).map(Number).sort((a, b) => a - b)) {
           const svcs = aoPhases[num];
           for (const svc of svcs) {
-            await mgr.install(svc);
-            await mgr.start(svc, colorIdx++);
+            const ci = colorIdx++;
+            await mgr.install(svc, ci);
+            await mgr.start(svc, ci);
           }
           const apis = svcs.filter((s) => s.type === "api");
           if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
@@ -1271,7 +1831,7 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
             targetPort: rewritten.realPort,
             timeoutMin: lazyTimeout,
             onDemandStart: async () => {
-              await mgr.install(rewritten);
+              await mgr.install(rewritten, ci);
               await mgr.start(rewritten, ci);
               const ok = await waitForPort(rewritten.realPort, { timeout: 45e3 });
               const st = mgr.state.get(svc.name);
@@ -1304,8 +1864,9 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
         for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
           const svcs = phases[num];
           for (const svc of svcs) {
-            await mgr.install(svc);
-            await mgr.start(svc, colorIdx++);
+            const ci = colorIdx++;
+            await mgr.install(svc, ci);
+            await mgr.start(svc, ci);
           }
           const apis = svcs.filter((s) => s.type === "api");
           if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
@@ -1377,6 +1938,222 @@ 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 join5, dirname as dirname4 } from "path";
+import { homedir } from "os";
+var LogSink = class {
+  dir;
+  rotateOnStart;
+  streams = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    const root = opts.rootDir ?? join5(homedir(), ".devup", "logs");
+    this.dir = join5(root, sanitize(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 join5(this.dir, `${sanitize(svcName)}.log`);
+  }
+  write(svcName, line) {
+    const stream = this.streamFor(svcName);
+    stream.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  }
+  async close() {
+    const closes = [...this.streams.values()].map(
+      (s) => new Promise((r) => s.end(() => r()))
+    );
+    this.streams.clear();
+    this.seen.clear();
+    await Promise.all(closes);
+  }
+  streamFor(svcName) {
+    let s = this.streams.get(svcName);
+    if (s) return s;
+    const file = this.pathFor(svcName);
+    if (this.rotateOnStart && !this.seen.has(svcName) && existsSync8(file)) {
+      try {
+        mkdirSync4(dirname4(file), { recursive: true });
+        renameSync(file, file + ".prev");
+      } catch {
+      }
+    }
+    this.seen.add(svcName);
+    s = createWriteStream(file, { flags: "a" });
+    s.on("error", () => {
+    });
+    this.streams.set(svcName, s);
+    return s;
+  }
+};
+function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "devup";
+}
+
+// src/orchestrator/dry-run.ts
+function renderDryRun(opts) {
+  const { config, services, cliArgs, env, proxyProvider, proxyOpts } = 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 = [];
+  if (lazyMode) {
+    const c = classifyServices(services, config.lazy);
+    alwaysOn = c.alwaysOn;
+    lazy = c.lazy;
+  }
+  const phases = groupByPhase(alwaysOn);
+  const phaseNums = Object.keys(phases).map(Number).sort((a, b) => a - b);
+  for (const num of phaseNums) {
+    lines.push(`Phase ${num}:`);
+    for (const svc of phases[num]) {
+      lines.push(formatService(svc, env, false));
+    }
+  }
+  if (lazy.length) {
+    lines.push("");
+    lines.push("Lazy (on-demand):");
+    for (const svc of lazy) {
+      const rewritten = rewriteServicePort(svc);
+      lines.push(formatService(rewritten, env, true));
+      lines.push(`    proxy   :${svc.port} \u2192 :${getLazyRealPort(svc.port)} (idle timeout ${cliArgs.lazyTimeout}m)`);
+    }
+  }
+  if (proxyProvider && proxyOpts) {
+    lines.push("");
+    lines.push(`Proxy:    ${proxyProvider.name} \u2192 ${proxyOpts.confPath}`);
+    const svcStates = /* @__PURE__ */ new Map();
+    for (const svc of services) {
+      const real = lazyMode && !alwaysOn.includes(svc) ? getLazyRealPort(svc.port) : void 0;
+      svcStates.set(svc.name, { port: svc.port, health: "up", realPort: real });
+    }
+    const content = proxyProvider.generate(svcStates, proxyOpts);
+    lines.push("");
+    lines.push("--- generated config ---");
+    lines.push(content);
+  }
+  return lines.join("\n");
+}
+function formatService(svc, env, isLazy) {
+  const args = buildProcessArgs(svc);
+  const cmdLine = [svc.cmd, ...args].join(" ");
+  const built = buildProcessEnv(svc, env);
+  const extraEnv = Object.keys(svc.extraEnv ?? {}).length ? "  env=" + Object.entries(svc.extraEnv).map(([k, v]) => `${k}=${v}`).join(" ") : "";
+  const memTag = svc.maxMem ? ` mem=${svc.maxMem}MB` : "";
+  const hc = svc.healthCheck;
+  const hcTag = hc?.type === "http" ? ` health=http ${hc.path ?? "/"}` : "";
+  const lazyTag = isLazy ? " [lazy]" : "";
+  void built;
+  return `  - ${svc.name.padEnd(20)} (${svc.type}) :${svc.port}  ${cmdLine}${memTag}${hcTag}${lazyTag}${extraEnv}`;
+}
+function runDryRun(opts) {
+  console.log(renderDryRun(opts));
+}
+
+// src/orchestrator/once.ts
+async function runOnce(opts) {
+  const out = opts.out ?? ((l) => console.log(l));
+  const { config, services, cliArgs, platform, env, baseCwd, logSink } = opts;
+  const mgr = new ProcessManager({
+    baseCwd,
+    env,
+    platform,
+    events: {
+      onLog: (svc, text) => {
+        logSink?.write(svc, text);
+        out(`[${svc}] ${text}`);
+      },
+      onStateChange: () => {
+      }
+    }
+  });
+  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);
+  const deadline = Date.now() + cliArgs.onceTimeout * 1e3;
+  let colorIdx = 0;
+  for (const num of phaseNums) {
+    out(`\u25B6 phase ${num}`);
+    for (const svc of phases[num]) {
+      const ci = colorIdx++;
+      const installed = await mgr.install(svc, ci);
+      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 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`);
+      const st = mgr.state.get(api.name);
+      if (st) {
+        st.status = "running";
+        st.health = "up";
+      }
+    }
+  }
+  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 waitHealthy2(svc, deadline) {
+  while (Date.now() < deadline) {
+    const ok = await checkHealth(svc.port, svc.healthCheck);
+    if (ok) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
 // src/config/types.ts
 function defineConfig(config) {
   return config;
@@ -1400,13 +2177,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 ? join4(cwd, config.envFile) : join4(cwd, ".env");
+  const envFile = config.envFile ? join6(cwd, config.envFile) : join6(cwd, ".env");
   const env = parseEnvFile(envFile, process.env);
   if (config.env) {
     for (const [k, v] of Object.entries(config.env)) {
@@ -1423,12 +2206,33 @@ ${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 ?? join4(homedir(), ".traefik", "traefik_conf.yaml")
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join6(homedir2(), ".traefik", "traefik_conf.yaml")
     };
   }
+  if (cliArgs.dryRun) {
+    runDryRun({ config, services, cliArgs, env, baseCwd: cwd, proxyProvider, proxyOpts });
+    return;
+  }
+  let logSink = null;
+  if (cliArgs.logFile) {
+    logSink = new LogSink({ projectName: config.name, rootDir: cliArgs.logDir });
+  }
+  if (cliArgs.once) {
+    const code = await runOnce({
+      config,
+      services,
+      cliArgs,
+      platform,
+      env,
+      baseCwd: cwd,
+      logSink
+    });
+    await logSink?.close();
+    process.exit(code);
+  }
   const isInteractive = process.stdin.isTTY ?? false;
   const { waitUntilExit } = render(
-    React6.createElement(App, {
+    React7.createElement(App, {
       config,
       services,
       cliArgs,
@@ -1436,7 +2240,8 @@ ${formatValidationErrors(errors)}`);
       env,
       baseCwd: cwd,
       proxyProvider,
-      proxyOpts
+      proxyOpts,
+      logSink
     }),
     { exitOnCtrlC: false, patchConsole: isInteractive, interactive: isInteractive }
   );