@gachlab/devup 0.7.0 → 0.8.0

package/dist/index.js

@@ -3,10 +3,10 @@
 // src/index.ts
 import React7 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname7, join as join8 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 
 // src/config/loader.ts
 import { existsSync } from "fs";
@@ -429,13 +429,13 @@ function filterServices(services, args, config) {
 }
 
 // src/orchestrator/subcommands.ts
-import { spawn } from "child_process";
-import { createReadStream, watchFile, unwatchFile, existsSync as existsSync4, statSync } from "fs";
+import { spawn as spawn5 } from "child_process";
+import { createReadStream as createReadStream2, watchFile as watchFile2, unwatchFile as unwatchFile2, existsSync as existsSync11, statSync as statSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { join as join3, dirname } from "path";
+import { join as join9, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
-import { createInterface } from "readline";
+import { homedir as homedir4 } from "os";
+import { createInterface as createInterface4 } from "readline";
 
 // src/process/health.ts
 import net from "net";
@@ -512,10 +512,8 @@ function deriveHealth(isUp, currentStatus) {
   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";
+// src/utils/env.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
 function parseEnvFile(filePath, baseEnv = {}) {
   const env = { ...baseEnv };
   if (!existsSync3(filePath)) return env;
@@ -533,25 +531,21 @@ function parseEnvFile(filePath, baseEnv = {}) {
   }
   return env;
 }
-function nextRamBannerVisibility(usagePct, previousVisible, highWatermark = 80, lowWatermark = 75) {
-  if (usagePct >= highWatermark) return true;
-  if (usagePct < lowWatermark) return false;
-  return previousVisible;
-}
-function redactSecrets(env) {
-  if (!env) return {};
-  const out = {};
-  for (const [k, v] of Object.entries(env)) {
-    out[k] = /secret|token|password|api[_-]?key|auth/i.test(k) ? "***" : v;
-  }
-  return out;
-}
-function detectLogLevel(line) {
-  const l = line.toLowerCase();
-  if (/\b(?:error|err|fail(?:ed|ure|ures|s)?|fatal|exception|crash(?:ed|es)?)\b/.test(l) || /❌|✗|⛔/.test(line)) return "error";
-  if (/\b(?:warn(?:ed|ing|s|ings)?|deprec)\b/.test(l) || /⚠/.test(line)) return "warn";
-  return "info";
+
+// src/utils/format.ts
+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`;
 }
+
+// src/utils/search.ts
 function compileSearchPattern(term) {
   if (!term) return null;
   const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(term);
@@ -568,51 +562,47 @@ function compileSearchPattern(term) {
   const lower = term.toLowerCase();
   return { test: (l) => l.toLowerCase().includes(lower) };
 }
-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 detectLogLevel(line) {
+  const l = line.toLowerCase();
+  if (/\b(?:error|err|fail(?:ed|ure|ures|s)?|fatal|exception|crash(?:ed|es)?)\b/.test(l) || /❌|✗|⛔/.test(line)) return "error";
+  if (/\b(?:warn(?:ed|ing|s|ings)?|deprec)\b/.test(l) || /⚠/.test(line)) return "warn";
+  return "info";
+}
+
+// src/utils/redact.ts
+function redactSecrets(env) {
+  if (!env) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    out[k] = /secret|token|password|api[_-]?key|auth/i.test(k) ? "***" : v;
+  }
+  return out;
 }
+
+// src/utils/install-stamp.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { createHash } from "crypto";
+import { join as join2 } from "path";
 function needsInstall(fullCwd) {
   const nm = join2(fullCwd, "node_modules");
-  if (!existsSync3(nm)) return true;
+  if (!existsSync4(nm)) return true;
   try {
-    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    const pkgHash = createHash("md5").update(readFileSync2(join2(fullCwd, "package.json"))).digest("hex");
     const stampFile = join2(nm, ".install-stamp");
-    if (existsSync3(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
+    if (existsSync4(stampFile) && readFileSync2(stampFile, "utf8") === pkgHash) return false;
   } catch {
   }
   return true;
 }
 function writeInstallStamp(fullCwd) {
   try {
-    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    const pkgHash = createHash("md5").update(readFileSync2(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;
-}
+
+// src/utils/process-args.ts
 function buildProcessArgs(svc) {
   const extra = svc.nodeArgs ?? [];
   if (!svc.maxMem) return [...extra, ...svc.args];
@@ -630,11 +620,38 @@ function buildProcessEnv(svc, baseEnv) {
   }
   return env;
 }
+
+// src/utils/stats.ts
+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 calcCpuPercent(totalCpuSec, prevCpu, prevTime) {
   const elapsed = (Date.now() - prevTime) / 1e3;
   const cpuDelta = totalCpuSec - prevCpu;
   return elapsed > 0 ? cpuDelta / elapsed * 100 : 0;
 }
+function nextRamBannerVisibility(usagePct, previousVisible, highWatermark = 80, lowWatermark = 75) {
+  if (usagePct >= highWatermark) return true;
+  if (usagePct < lowWatermark) return false;
+  return previousVisible;
+}
+
+// src/utils/phases.ts
+function groupByPhase(services) {
+  const phases = {};
+  for (const s of services) {
+    (phases[s.phase] ??= []).push(s);
+  }
+  return phases;
+}
+
+// src/utils/colors.ts
 var tagColors = [
   "cyan",
   "yellow",
@@ -651,353 +668,252 @@ var tagColors = [
   "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";
+// src/control-plane/client.ts
+import { createConnection } from "net";
+import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync6 } from "fs";
+
+// src/control-plane/socket-server.ts
+import { createServer } from "net";
+import { createInterface } from "readline";
+import { existsSync as existsSync5, unlinkSync, chmodSync, mkdirSync, statSync } from "fs";
+import { dirname } from "path";
+import { join as join3 } from "path";
+import { homedir } from "os";
+function defaultSocketPath(projectName) {
+  const safe = projectName.replace(/[^a-zA-Z0-9._-]+/g, "_") || "devup";
+  return join3(homedir(), ".devup", `sock-${safe}.sock`);
 }
-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;
+async function startSocketServer(projectName, ctx, opts = {}) {
+  const path = opts.path ?? defaultSocketPath(projectName);
+  mkdirSync(dirname(path), { recursive: true });
+  if (existsSync5(path)) {
+    try {
+      const st = statSync(path);
+      if (st.isSocket()) unlinkSync(path);
+    } catch {
+    }
   }
-  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;
+  const server = createServer((socket) => handleClient(socket, ctx));
+  await new Promise((resolve4, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.off("error", reject);
+      try {
+        chmodSync(path, 384);
+      } catch {
       }
-    };
-    watchFile(file, { interval: 500 }, () => {
-      void tick();
-    });
-    process.once("SIGINT", () => {
-      unwatchFile(file);
-      resolve4(0);
+      opts.onLog?.(`\u{1F50C} control plane at ${path}`);
+      resolve4();
     });
   });
+  return {
+    server,
+    path,
+    async close() {
+      await new Promise((resolve4) => server.close(() => resolve4()));
+      if (existsSync5(path)) {
+        try {
+          unlinkSync(path);
+        } catch {
+        }
+      }
+    }
+  };
 }
-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();
-        });
+function handleClient(socket, ctx) {
+  const rl = createInterface({ input: socket });
+  const unsubs = /* @__PURE__ */ new Set();
+  socket.on("close", () => {
+    for (const unsub of unsubs) unsub();
+    unsubs.clear();
+  });
+  rl.on("line", async (line) => {
+    if (!line.trim()) return;
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch (e) {
+      respond(socket, { error: { code: -32700, message: `parse error: ${e.message}` } });
+      return;
+    }
+    if (typeof req.method !== "string") {
+      respond(socket, { id: req.id, error: { code: -32600, message: "method required" } });
+      return;
+    }
+    const params = req.params ?? {};
+    if (req.method === "logs.follow" || req.method === "status.follow") {
+      try {
+        await handleFollow(socket, req, params, ctx, unsubs);
+      } catch (e) {
+        respond(socket, { id: req.id, error: { code: -32603, message: e.message ?? String(e) } });
       }
-    };
-    pump();
+      return;
+    }
+    try {
+      const result = await dispatch(req.method, params, ctx);
+      respond(socket, { id: req.id, result });
+    } catch (e) {
+      respond(socket, { id: req.id, error: { code: -32603, message: e.message ?? String(e) } });
+    }
   });
-  if (failed.length) {
-    out(`
-failed: ${failed.join(", ")}`);
-    return 1;
+  socket.on("error", () => {
+  });
+}
+async function handleFollow(socket, req, params, ctx, unsubs) {
+  if (req.method === "logs.follow") {
+    const rawSvc = params["svc"] ?? params["service"];
+    const svcName = rawSvc != null ? stringOrThrow(rawSvc, "svc") : null;
+    const tail = Math.max(0, Math.min(1e3, Number(params["tail"] ?? 50)));
+    respond(socket, { id: req.id, result: { ok: true } });
+    if (svcName) {
+      const lines = await ctx.tailLogs(svcName, tail);
+      for (const l of lines) {
+        respond(socket, { id: req.id, event: "log", data: l });
+      }
+    }
+    const unsub = ctx.watchLogs(svcName, (svc, line) => {
+      respond(socket, { id: req.id, event: "log", data: line, svc });
+    });
+    unsubs.add(unsub);
+  } else {
+    respond(socket, { id: req.id, result: { ok: true } });
+    const snapshot = [];
+    for (const [name, st] of ctx.states()) {
+      snapshot.push(serializeState(name, st));
+    }
+    if (snapshot.length) {
+      respond(socket, { id: req.id, event: "status", data: snapshot });
+    }
+    const unsub = ctx.watchStatus((name, state) => {
+      respond(socket, { id: req.id, event: "status", data: [serializeState(name, state)] });
+    });
+    unsubs.add(unsub);
   }
-  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 serializeState(name, st) {
+  return {
+    name,
+    status: st.status,
+    health: st.health,
+    port: st.svc.port,
+    type: st.svc.type,
+    errors: st.errors,
+    restarts: st.restarts,
+    pid: st.pid,
+    startedAt: st.startedAt
+  };
 }
-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;
+function respond(socket, payload) {
+  if (socket.writable) socket.write(JSON.stringify(payload) + "\n");
 }
-
-// src/platform/detect.ts
-async function detectPlatform() {
-  switch (process.platform) {
-    case "linux": {
-      const { LinuxPlatform } = await import("./linux-OQ3Q4Z2Z.js");
-      return new LinuxPlatform();
+async function dispatch(method, params, ctx) {
+  switch (method) {
+    case "status": {
+      const out = [];
+      for (const [name, st] of ctx.states()) {
+        out.push(serializeState(name, st));
+      }
+      return { services: out };
     }
-    case "darwin": {
-      const { DarwinPlatform } = await import("./darwin-3KJ3IEXN.js");
-      return new DarwinPlatform();
+    case "restart": {
+      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
+      await ctx.restart(svc);
+      return { ok: true };
     }
-    case "win32": {
-      const { Win32Platform } = await import("./win32-3X2OLSI6.js");
-      return new Win32Platform();
+    case "stop": {
+      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
+      ctx.stop(svc);
+      return { ok: true };
+    }
+    case "logs.tail": {
+      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
+      const lines = Math.max(1, Math.min(1e4, Number(params["lines"] ?? 100)));
+      return { lines: await ctx.tailLogs(svc, lines) };
     }
+    case "ping":
+      return { ok: true, ts: Date.now() };
     default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
+      throw new Error(`unknown method: ${method}`);
   }
 }
-
-// src/proxy-config/traefik.ts
-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";
-  generate(services, opts) {
-    const routers = [];
-    const svcs = [];
-    for (const [name, st] of services) {
-      if (st.health !== "up") continue;
-      const sub = opts.routes[name];
-      if (sub === void 0) continue;
-      const rule = sub ? `Host(\`${sub}.${opts.domain}\`)` : `Host(\`${opts.domain}\`)`;
-      const safe = name.replace(/[^a-z0-9-]/g, "-");
-      const port = st.realPort ?? st.port;
-      let router = `    ${safe}:
-      rule: "${rule}"
-      service: ${safe}
-      entryPoints:
-        - ${opts.entrypoint}`;
-      if (opts.tls) router += `
-      tls:
-        certResolver: le`;
-      routers.push(router);
-      svcs.push(`    ${safe}:
-      loadBalancer:
-        servers:
-          - url: "http://${opts.host}:${port}"`);
-    }
-    if (!routers.length) return EMPTY_CONFIG;
-    return `http:
-  routers:
-${routers.join("\n")}
-  services:
-${svcs.join("\n")}
-`;
-  }
-  write(content, opts) {
-    const dir = dirname2(opts.confPath);
-    if (!existsSync5(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync2(opts.confPath, content);
-  }
-  clear(opts) {
-    this.write(EMPTY_CONFIG, opts);
+function stringOrThrow(v, paramName) {
+  if (typeof v !== "string" || !v.trim()) {
+    throw new Error(`param "${paramName}" must be a non-empty string`);
   }
-};
+  return v;
+}
 
-// src/proxy-config/nginx.ts
-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";
-  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 = dirname3(opts.confPath);
-    if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
-    writeFileSync3(opts.confPath, content);
-  }
-  clear(opts) {
-    this.write(EMPTY_CONFIG2, opts);
+// src/control-plane/client.ts
+function resolveSocket(projectName, overridePath) {
+  return overridePath ?? defaultSocketPath(projectName);
+}
+function assertSocketExists(socketPath, projectName) {
+  if (!existsSync6(socketPath)) {
+    throw new Error(
+      `devup is not running for project "${projectName}".
+Start it with \`devup\` first.`
+    );
   }
-};
-
-// src/proxy-config/caddy.ts
-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";
-  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}
-}`
-      );
+}
+function sendRpc(socketPath, method, params = {}) {
+  return new Promise((resolve4, reject) => {
+    const c = createConnection(socketPath);
+    c.on("error", reject);
+    const rl = createInterface2({ input: c });
+    rl.once("line", (l) => {
+      c.end();
+      try {
+        const msg = JSON.parse(l);
+        if (msg.error) reject(new Error(msg.error.message ?? String(msg.error)));
+        else resolve4(msg.result);
+      } catch (e) {
+        reject(e);
+      }
+    });
+    c.write(JSON.stringify({ id: 1, method, params }) + "\n");
+  });
+}
+function openStream(socketPath, method, params, onFrame, onError) {
+  const c = createConnection(socketPath);
+  const rl = createInterface2({ input: c });
+  let ackDone = false;
+  c.on("error", (err) => onError?.(err));
+  c.write(JSON.stringify({ id: 1, method, params }) + "\n");
+  rl.on("line", (l) => {
+    try {
+      const msg = JSON.parse(l);
+      if (!ackDone) {
+        ackDone = true;
+        if (msg.error) {
+          onError?.(new Error(msg.error.message ?? String(msg.error)));
+          c.destroy();
+        }
+        return;
+      }
+      if (msg.event) onFrame(msg);
+    } catch {
     }
-    if (!blocks.length) return EMPTY_CONFIG3;
-    return blocks.join("\n\n") + "\n";
-  }
-  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();
+  });
+  return () => c.destroy();
 }
 
-// src/tui/App.tsx
-import { useEffect as useEffect5, useState as useState6, useCallback as useCallback3, useRef as useRef3 } from "react";
-import { Box as Box6, Text as Text6, useStdout } from "ink";
-
-// src/tui/hooks/useProcessManager.ts
-import { useState, useEffect, useRef, useCallback } from "react";
+// src/orchestrator/daemon.ts
+import { spawn as spawn4 } from "child_process";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync10, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, createReadStream } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+import { setTimeout as sleep } from "timers/promises";
+import { createInterface as createInterface3 } from "readline";
 
 // src/process/manager.ts
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { join as join5 } from "path";
 
 // src/process/installer.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { spawn } from "child_process";
+import { existsSync as existsSync7 } from "fs";
 function installService(cwd, env, onLog) {
-  if (!existsSync8(cwd)) {
+  if (!existsSync7(cwd)) {
     onLog?.(`\u26A0 directory not found: ${cwd}`);
     return Promise.resolve(false);
   }
@@ -1008,7 +924,7 @@ function installService(cwd, env, onLog) {
   onLog?.("\u{1F4E6} npm install...");
   return new Promise((resolve4) => {
     const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const proc = spawn2(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
+    const proc = spawn(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr?.on("data", (d) => {
       stderr += d.toString();
@@ -1030,9 +946,32 @@ function installService(cwd, env, onLog) {
   });
 }
 
-// src/process/manager.ts
-var MAX_RESTARTS = 3;
-var BACKOFF_BASE_MS = 2e3;
+// src/process/spawner.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
+
+// src/process/internals.ts
+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 = "";
+      }
+    }
+  };
+}
 function compileReadyPattern(pattern) {
   if (!pattern) return null;
   const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(pattern);
@@ -1063,43 +1002,26 @@ function extractWatchPaths(args) {
   }
   return out;
 }
-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();
+var MAX_RESTARTS = 3;
+var BACKOFF_BASE_MS = 2e3;
+
+// src/process/spawner.ts
+var Spawner = class {
   baseCwd;
   env;
-  platform;
+  state;
+  procs;
   events;
+  lifecycle;
+  onCrash;
   constructor(opts) {
     this.baseCwd = opts.baseCwd;
     this.env = opts.env;
-    this.platform = opts.platform;
+    this.state = opts.state;
+    this.procs = opts.procs;
     this.events = opts.events;
-  }
-  async install(svc, colorIdx) {
-    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));
+    this.lifecycle = opts.lifecycle;
+    this.onCrash = opts.onCrash;
   }
   async start(svc, colorIdx, isRestart = false) {
     const cwd = join4(this.baseCwd, svc.cwd);
@@ -1118,14 +1040,14 @@ var ProcessManager = class {
       }
     }
     const args = buildProcessArgs(svc);
-    const missingWatchPaths = extractWatchPaths(args).filter((p) => !existsSync9(resolve3(cwd, p)));
+    const missingWatchPaths = extractWatchPaths(args).filter((p) => !existsSync8(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 = spawn3(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const proc = spawn2(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
     const prev = this.state.get(svc.name);
     const state = {
       svc,
@@ -1142,6 +1064,14 @@ var ProcessManager = class {
     this.state.set(svc.name, state);
     this.procs.add(proc);
     this.events.onStateChange(svc.name, state);
+    this.wireStdio(proc, svc, state, colorIdx);
+    this.wireCloseHandler(proc, svc, state, 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);
+  }
+  wireStdio(proc, svc, state, colorIdx) {
     const readyRegex = compileReadyPattern(svc.readyPattern);
     const markReadyIfMatch = (line) => {
       if (!readyRegex || state.health === "up") return;
@@ -1166,9 +1096,11 @@ var ProcessManager = class {
     proc.stderr?.on("data", (d) => stderrBuf.push(d));
     proc.stdout?.on("end", () => stdoutBuf.flush());
     proc.stderr?.on("end", () => stderrBuf.flush());
+  }
+  wireCloseHandler(proc, svc, state, colorIdx) {
     proc.on("close", (code) => {
       this.procs.delete(proc);
-      this.stopWatchProc(state);
+      this.lifecycle.stopWatchProc(state);
       if (state.intentionalStop) {
         state.intentionalStop = false;
         return;
@@ -1183,45 +1115,34 @@ var ProcessManager = class {
       state.health = "down";
       this.log(svc.name, `\u274C exited with code ${code}`, colorIdx);
       this.events.onStateChange(svc.name, state);
-      if (state.restarts < MAX_RESTARTS) {
-        state.restarts++;
-        const delay = BACKOFF_BASE_MS * Math.pow(2, state.restarts - 1);
-        this.log(svc.name, `\u{1F504} auto-restart ${state.restarts}/${MAX_RESTARTS} in ${delay}ms...`, colorIdx);
-        setTimeout(() => this.start(svc, colorIdx, true), delay);
-      } else {
-        this.log(svc.name, "\u26D4 max restarts reached", colorIdx);
-      }
+      this.onCrash(svc, state, 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) => {
+    return new Promise((res) => {
       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 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);
-        resolve4(false);
+        res(false);
       });
       child.on("close", (code) => {
         outBuf.flush();
         errBuf.flush();
         if (code === 0) {
           this.log(svc.name, `[build] \u2705 done`, colorIdx);
-          resolve4(true);
+          res(true);
         } else {
           this.log(svc.name, `[build] \u274C exited with code ${code}`, colorIdx);
-          resolve4(false);
+          res(false);
         }
       });
     });
@@ -1231,7 +1152,7 @@ var ProcessManager = class {
     const isWin = process.platform === "win32";
     const shell = isWin ? "cmd.exe" : "sh";
     const shellFlag = isWin ? "/c" : "-c";
-    const child = spawn3(shell, [shellFlag, svc.watchBuild], {
+    const child = spawn2(shell, [shellFlag, svc.watchBuild], {
       cwd,
       env,
       detached: true,
@@ -1244,7 +1165,8 @@ var ProcessManager = class {
     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). */
+  /** Create a state entry in 'crashed' status without spawning a process
+   *  (used when preBuild fails or pre-flight checks fail). */
   recordCrashedState(svc, colorIdx) {
     const prev = this.state.get(svc.name);
     this.state.set(svc.name, {
@@ -1261,33 +1183,54 @@ var ProcessManager = class {
     });
     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);
+  log(name, text, colorIdx) {
+    this.events.onLog(name, text, colorIdx);
   }
-  stopWatchProc(state) {
-    const wp = state.watchProc;
-    if (!wp || !wp.pid) return;
-    try {
-      this.platform.killTree(wp.pid);
-    } catch {
-    }
-    state.watchProc = null;
+};
+
+// src/process/restarter.ts
+var Restarter = class {
+  state;
+  events;
+  spawner;
+  lifecycle;
+  constructor(opts) {
+    this.state = opts.state;
+    this.events = opts.events;
+    this.spawner = opts.spawner;
+    this.lifecycle = opts.lifecycle;
   }
   async restart(name) {
     const st = this.state.get(name);
     if (!st) return;
-    this.stop(name);
+    this.lifecycle.stop(name);
     st.restarts = 0;
     const delay = st.proc ? 1500 : 100;
     await new Promise((r) => setTimeout(r, delay));
-    await this.start(st.svc, st.colorIdx, true);
-    this.log(name, "\u{1F504} manual restart", st.colorIdx);
+    await this.spawner.start(st.svc, st.colorIdx, true);
+    this.events.onLog(name, "\u{1F504} manual restart", st.colorIdx);
+  }
+  scheduleAutoRestart(svc, state, colorIdx) {
+    if (state.restarts >= MAX_RESTARTS) {
+      this.events.onLog(svc.name, "\u26D4 max restarts reached", colorIdx);
+      return;
+    }
+    state.restarts++;
+    const delay = BACKOFF_BASE_MS * Math.pow(2, state.restarts - 1);
+    this.events.onLog(svc.name, `\u{1F504} auto-restart ${state.restarts}/${MAX_RESTARTS} in ${delay}ms...`, colorIdx);
+    setTimeout(() => void this.spawner.start(svc, colorIdx, true), delay);
+  }
+};
+
+// src/process/health-poller.ts
+var HealthPoller = class {
+  state;
+  events;
+  constructor(opts) {
+    this.state = opts.state;
+    this.events = opts.events;
   }
-  async checkAllHealth() {
+  async checkAll() {
     for (const [name, st] of this.state) {
       if (!st.pid || st.status === "idle") {
         st.health = st.status === "idle" ? "idle" : "down";
@@ -1304,6 +1247,41 @@ var ProcessManager = class {
       if (prev !== st.health) this.events.onStateChange(name, st);
     }
   }
+};
+
+// src/process/lifecycle.ts
+var Lifecycle = class {
+  state;
+  procs;
+  platform;
+  constructor(opts) {
+    this.state = opts.state;
+    this.procs = opts.procs;
+    this.platform = opts.platform;
+  }
+  /** Manual / external stop of a single service. Marks `intentionalStop` so the
+   *  close handler doesn't auto-restart, kills the process tree, tears down the
+   *  side-car watchBuild process if any. */
+  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);
+  }
+  /** Tears down the side-car `watchBuild` process for a service (if any) and
+   *  clears the reference. Safe to call repeatedly. */
+  stopWatchProc(state) {
+    const wp = state.watchProc;
+    if (!wp || !wp.pid) return;
+    try {
+      this.platform.killTree(wp.pid);
+    } catch {
+    }
+    state.watchProc = null;
+  }
+  /** Graceful shutdown of every spawned process. Waits `gracePeriodMs` (default
+   *  3000) for clean exits, then SIGKILLs anything still alive. */
   async cleanup(opts = {}) {
     const grace = opts.gracePeriodMs ?? 3e3;
     const procs = [...this.procs];
@@ -1344,1023 +1322,2245 @@ var ProcessManager = class {
     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);
+};
+
+// src/process/manager.ts
+var ProcessManager = class {
+  state = /* @__PURE__ */ new Map();
+  procs = /* @__PURE__ */ new Set();
+  baseCwd;
+  env;
+  events;
+  spawner;
+  restarter;
+  healthPoller;
+  lifecycle;
+  constructor(opts) {
+    this.baseCwd = opts.baseCwd;
+    this.env = opts.env;
+    this.events = opts.events;
+    this.lifecycle = new Lifecycle({
+      state: this.state,
+      procs: this.procs,
+      platform: opts.platform
+    });
+    let restarterRef = null;
+    this.spawner = new Spawner({
+      baseCwd: opts.baseCwd,
+      env: opts.env,
+      state: this.state,
+      procs: this.procs,
+      events: opts.events,
+      lifecycle: this.lifecycle,
+      onCrash: (svc, state, colorIdx) => restarterRef?.scheduleAutoRestart(svc, state, colorIdx)
+    });
+    this.restarter = new Restarter({
+      state: this.state,
+      events: opts.events,
+      spawner: this.spawner,
+      lifecycle: this.lifecycle
+    });
+    restarterRef = this.restarter;
+    this.healthPoller = new HealthPoller({
+      state: this.state,
+      events: opts.events
+    });
+  }
+  install(svc, colorIdx) {
+    const cwd = join5(this.baseCwd, svc.cwd);
+    const idx = colorIdx ?? this.state.get(svc.name)?.colorIdx ?? 0;
+    return installService(cwd, this.env, (msg) => this.events.onLog(svc.name, msg, idx));
+  }
+  start(svc, colorIdx, isRestart = false) {
+    return this.spawner.start(svc, colorIdx, isRestart);
+  }
+  stop(name) {
+    this.lifecycle.stop(name);
+  }
+  restart(name) {
+    return this.restarter.restart(name);
+  }
+  checkAllHealth() {
+    return this.healthPoller.checkAll();
+  }
+  cleanup(opts = {}) {
+    return this.lifecycle.cleanup(opts);
   }
 };
 
-// src/tui/hooks/useProcessManager.ts
-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,
-      env,
-      platform,
-      events: {
-        onLog: (svcName, text, colorIdx) => {
-          sinkRef.current?.write(svcName, text);
-          const entry = { svcName, text, colorIdx, ts: Date.now(), level: detectLogLevel(text) };
-          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;
-          });
-        },
-        onStateChange: () => setStates(new Map(mgr2.state))
+// src/process/log-sink.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, renameSync, createWriteStream } from "fs";
+import { join as join6, dirname as dirname2 } 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 ?? join6(homedir2(), ".devup", "logs");
+    this.dir = join6(root, sanitize(opts.projectName));
+    this.rotateOnStart = opts.rotateOnStart ?? true;
+    mkdirSync2(this.dir, { recursive: true });
+  }
+  /** Returns the file path for a service log (useful for tests / UI). */
+  pathFor(svcName) {
+    return join6(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) && existsSync9(file)) {
+      try {
+        mkdirSync2(dirname2(file), { recursive: true });
+        renameSync(file, file + ".prev");
+      } catch {
       }
+    }
+    this.seen.add(svcName);
+    s = createWriteStream(file, { flags: "a" });
+    s.on("error", () => {
     });
-    mgrRef.current = mgr2;
-    return () => {
-      mgr2.cleanup();
-    };
-  }, [baseCwd, env, platform]);
-  useEffect(() => {
-    const id = setInterval(async () => {
-      const mgr2 = mgrRef.current;
-      if (!mgr2) return;
-      await mgr2.checkAllHealth();
-      setStates(new Map(mgr2.state));
-      const pids = [];
-      const pidMap = /* @__PURE__ */ new Map();
-      for (const [name, st] of mgr2.state) {
-        if (st.pid) {
-          pids.push(st.pid);
-          pidMap.set(st.pid, name);
-        }
+    this.streams.set(svcName, s);
+    return s;
+  }
+};
+function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "devup";
+}
+
+// src/utils/broadcaster.ts
+var Broadcaster = class {
+  subs = /* @__PURE__ */ new Set();
+  subscribe(fn) {
+    this.subs.add(fn);
+    return () => this.subs.delete(fn);
+  }
+  emit(v) {
+    for (const fn of this.subs) {
+      try {
+        fn(v);
+      } catch {
       }
-      if (pids.length) {
-        const raw = await platform.getProcessStats(pids);
-        const next = /* @__PURE__ */ new Map();
-        for (const [pid, data] of raw) {
-          const name = pidMap.get(pid);
-          if (!name) continue;
-          const prev = prevCpu.current.get(name) ?? { time: Date.now(), cpu: 0 };
-          const cpuPct = calcCpuPercent(data.cpuSeconds, prev.cpu, prev.time);
-          prevCpu.current.set(name, { time: Date.now(), cpu: data.cpuSeconds });
-          next.set(name, { cpu: cpuPct.toFixed(1) + "%", mem: (data.rss / 1024).toFixed(1) + " MB" });
-        }
-        setStats(next);
-      }
-    }, 3e3);
-    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(), level: detectLogLevel(text) };
-    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,
-    stats,
-    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, colorIdx) => mgr?.install(svc, colorIdx), [mgr]),
-    cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
-    clearLogs,
-    setPaused,
-    pushLog,
-    manager: mgr
-  };
-}
+  }
+};
 
-// src/tui/hooks/useKeyBindings.ts
-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) };
+// src/process/external.ts
+import { spawn as spawn3 } from "child_process";
+import { join as join7 } 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;
     }
-    const next = s.statsScrollOffset + delta;
-    return { ...s, statsScrollOffset: Math.max(0, next) };
-  });
+    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 };
 }
-function scrollTo(setState, target) {
-  setState((s) => {
-    if (s.panel === "logs") {
-      return { ...s, logsScrollOffset: target === "top" ? Number.MAX_SAFE_INTEGER : 0 };
+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 ? join7(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", () => resolve4());
+          child.on("error", () => resolve4());
+          setTimeout(() => resolve4(), 1e4);
+        });
+      }
+    } catch {
     }
-    return { ...s, statsScrollOffset: target === "top" ? 0 : Number.MAX_SAFE_INTEGER };
-  });
+    void proc;
+  }
 }
-function useKeyBindings(opts) {
-  const [state, setState] = useState2({
-    panel: "logs",
-    modal: "none",
-    logFilter: null,
-    searchTerm: null,
-    logsPaused: false,
-    showTimestamps: false,
-    sortIdx: 0,
-    proxyEnabled: false,
-    logsScrollOffset: 0,
-    statsScrollOffset: 0,
-    levelFilter: "all",
-    verboseStats: false
+function spawnExternal(svc, opts) {
+  const isWin = process.platform === "win32";
+  const shell = isWin ? "cmd.exe" : "sh";
+  const flag = isWin ? "/c" : "-c";
+  const cwd = svc.cwd ? join7(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"]
   });
-  const LEVEL_CYCLE = ["all", "error", "warn"];
-  const setModal = useCallback2((modal) => setState((s) => ({ ...s, modal })), []);
-  const setFilter = useCallback2((f) => setState((s) => ({ ...s, logFilter: f, modal: "none" })), []);
-  const setSearch = useCallback2((t) => setState((s) => ({ ...s, searchTerm: t, modal: "none" })), []);
-  const isActive = process.stdin.isTTY ?? false;
-  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");
-    else if (input === "r") setModal("restart");
-    else if (input === "o") setModal("open");
-    else if (input === "/") setModal("search");
-    else if (input === "a") setState((s) => ({ ...s, logFilter: null, searchTerm: null, levelFilter: "all" }));
-    else if (input === "p") setState((s) => ({ ...s, logsPaused: !s.logsPaused }));
-    else if (input === "t") setState((s) => ({ ...s, showTimestamps: !s.showTimestamps }));
-    else if (input === "s") setState((s) => ({ ...s, sortIdx: (s.sortIdx + 1) % SORT_MODES.length }));
-    else if (input === "T") {
-      opts.onToggleProxy();
-      setState((s) => ({ ...s, proxyEnabled: !s.proxyEnabled }));
-    } else if (input === "L") setState((s) => ({ ...s, levelFilter: LEVEL_CYCLE[(LEVEL_CYCLE.indexOf(s.levelFilter) + 1) % LEVEL_CYCLE.length] }));
-    else if (input === "v") setState((s) => ({ ...s, verboseStats: !s.verboseStats }));
-  }, { isActive });
-  return {
-    ...state,
-    setModal,
-    setFilter,
-    setSearch,
-    sortMode: SORT_MODES[state.sortIdx],
-    // Funciones para resetear el scroll cuando cambia el contenido
-    resetLogsScroll: useCallback2(() => setState((s) => ({ ...s, logsScrollOffset: 0 })), []),
-    resetStatsScroll: useCallback2(() => setState((s) => ({ ...s, statsScrollOffset: 0 })), [])
-  };
+  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;
 }
-
-// src/tui/hooks/useProxySync.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-function useProxySync(provider, opts, states, enabled) {
-  const statesRef = useRef2(states);
-  const lastContentRef = useRef2(null);
-  statesRef.current = states;
-  useEffect2(() => {
-    if (!provider || !opts || !enabled) return;
-    const sync = () => {
-      const svcStates = /* @__PURE__ */ new Map();
-      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();
-    const id = setInterval(sync, 3e3);
-    return () => {
-      clearInterval(id);
-      lastContentRef.current = null;
-    };
-  }, [provider, opts, enabled]);
+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/LogsPanel.tsx
-import { useEffect as useEffect3, useMemo } from "react";
-import { Box, Text } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
-function resolveBorder(focused, filter, filteredColorIdx) {
-  if (focused) return "cyan";
-  if (filter && filteredColorIdx !== null && filteredColorIdx >= 0) {
-    return tagColors[filteredColorIdx % tagColors.length];
+// 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 = [];
+  const activeConns = /* @__PURE__ */ new Set();
+  function bumpActivity() {
+    lastActivity = Date.now();
   }
-  return "gray";
-}
-function LogsPanel({ logs, filter, searchTerm, paused, showTimestamps, maxNameLen, height, focused, scrollOffset, resetScroll, levelFilter = "all", filteredColorIdx = null }) {
-  const byService = filter ? logs.filter((l) => l.svcName === filter) : logs;
-  const filtered = levelFilter === "all" ? byService : levelFilter === "error" ? byService.filter((l) => l.level === "error") : byService.filter((l) => l.level === "error" || l.level === "warn");
-  const contentHeight = Math.max(1, height - 2);
-  const totalLines = filtered.length;
-  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 matcher = useMemo(() => compileSearchPattern(searchTerm), [searchTerm]);
-  const scrolled = effectiveOffset > 0;
-  const label = [
-    "Logs",
-    filter ? `[${filter}]` : "",
-    searchTerm ? `/${searchTerm}` : "",
-    matcher?.invalid ? "(invalid regex)" : "",
-    levelFilter !== "all" ? `[level: ${levelFilter}${levelFilter === "warn" ? "+error" : ""}]` : "",
-    paused ? "[PAUSED]" : "",
-    scrolled ? "[SCROLL]" : "",
-    `${filtered.length} lines`,
-    focused && totalLines > 0 ? `(${startIndex + 1}-${endIndex}/${totalLines})` : ""
-  ].filter(Boolean).join(" ");
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: resolveBorder(focused, filter, filteredColorIdx), height, children: [
-    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
-      " ",
-      label,
-      " "
-    ] }) }),
-    visible.map((entry, i) => {
-      const color = tagColors[entry.colorIdx % tagColors.length];
-      const ts = showTimestamps ? new Date(entry.ts).toLocaleTimeString("en-GB") + " " : "";
-      const line = entry.text;
-      const isMatch = matcher ? matcher.test(line) : false;
-      return /* @__PURE__ */ jsxs(Box, { children: [
-        showTimestamps && /* @__PURE__ */ jsx(Text, { dimColor: true, children: ts }),
-        /* @__PURE__ */ jsxs(Text, { color, children: [
-          "[",
-          entry.svcName.padEnd(maxNameLen),
-          "]"
-        ] }),
-        /* @__PURE__ */ jsx(Text, { children: " " }),
-        isMatch ? /* @__PURE__ */ jsx(Text, { backgroundColor: "yellow", color: "black", children: line }) : /* @__PURE__ */ jsx(Text, { children: line })
-      ] }, i);
-    })
-  ] });
+  function scheduleIdleCheck() {
+    if (idleTimer) clearTimeout(idleTimer);
+    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", () => {
+        if (!client.destroyed) client.end();
+      });
+      client.on("end", () => {
+        if (!target.destroyed) target.end();
+      });
+    });
+  }
+  async function handleConnection(client) {
+    bumpActivity();
+    client.on("error", () => {
+    });
+    if (serviceReady && isAlive()) {
+      pipeToTarget(client);
+      return;
+    }
+    pendingConns.push(client);
+    client.on("close", () => {
+      pendingConns = pendingConns.filter((s) => s !== client);
+    });
+    if (starting) return;
+    starting = true;
+    onLog?.("\u26A1 on-demand start");
+    let ok = false;
+    try {
+      await onDemandStart();
+      ok = await waitForPort(targetPort, { timeout: 45e3, interval: 500 });
+      if (ok) serviceReady = true;
+      else onLog?.("\u26A0 timeout waiting for service");
+    } catch (e) {
+      onLog?.(`\u274C start failed: ${e.message}`);
+    }
+    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");
+  scheduleIdleCheck();
+  return {
+    server,
+    resetTimer: bumpActivity,
+    destroy: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      pendingConns.forEach((s) => s.destroy());
+      activeConns.forEach((s) => s.destroy());
+      server.close();
+    }
+  };
 }
 
-// src/tui/StatsPanel.tsx
-import { useEffect as useEffect4, useState as useState3 } from "react";
-import { Box as Box2, Text as Text2 } from "ink";
-import os from "os";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var H = {
-  up: { c: "\u25CF", color: "green" },
-  wait: { c: "\u25CF", color: "yellow" },
-  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;
+// src/orchestrator/config-watcher.ts
+import { watchFile, unwatchFile } from "fs";
+
+// src/config/diff.ts
+var SPAWN_RELEVANT = [
+  "cwd",
+  "cmd",
+  "args",
+  "port",
+  "phase",
+  "maxMem",
+  "preBuild",
+  "watchBuild",
+  "nodeArgs",
+  "extraEnv",
+  "healthCheck",
+  "readyPattern",
+  "errorPattern",
+  "type"
+];
+function hasSpawnRelevantChange(prev, next) {
+  for (const k of SPAWN_RELEVANT) {
+    if (JSON.stringify(prev[k]) !== JSON.stringify(next[k])) return true;
+  }
+  return false;
 }
-function Row({ name, st, stat, ml, verbose }) {
-  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 = 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) : "-";
-  if (!verbose) {
-    return /* @__PURE__ */ jsxs2(Text2, { children: [
-      indicator,
-      " ",
-      /* @__PURE__ */ jsx2(Text2, { color, children: name.padEnd(ml) }),
-      " ",
-      String(st.svc.port).padStart(5),
-      " ",
-      /* @__PURE__ */ jsx2(Text2, { color: sc, bold: looped, children: statusLabel.padEnd(8) }),
-      " ",
-      (stat?.cpu ?? "-").padStart(6),
-      " ",
-      (stat?.mem ?? "-").padStart(8),
-      " ",
-      String(st.errors).padStart(3),
-      " ",
-      String(st.restarts).padStart(3),
-      " ",
-      up.padStart(6)
-    ] });
+function diffServices(prev, next) {
+  const prevByName = new Map(prev.map((s) => [s.name, s]));
+  const nextByName = new Map(next.map((s) => [s.name, s]));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  const unchanged = [];
+  for (const [name, p] of prevByName) {
+    if (!nextByName.has(name)) {
+      removed.push(name);
+      continue;
+    }
+    const n = nextByName.get(name);
+    if (hasSpawnRelevantChange(p, n)) changed.push({ prev: p, next: n });
+    else unchanged.push(name);
   }
-  const resolvedArgs = buildProcessArgs(st.svc).join(" ");
-  const env = redactSecrets(st.svc.extraEnv);
-  const envStr = Object.entries(env).map(([k, v]) => `${k}=${v}`).join(" ");
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      indicator,
-      " ",
-      /* @__PURE__ */ jsx2(Text2, { color, children: name.padEnd(ml) }),
-      " ",
-      String(st.svc.port).padStart(5),
-      " ",
-      /* @__PURE__ */ jsx2(Text2, { color: sc, bold: looped, children: statusLabel.padEnd(8) }),
-      " ",
-      (stat?.cpu ?? "-").padStart(6),
-      " ",
-      (stat?.mem ?? "-").padStart(8),
-      " ",
-      String(st.errors).padStart(3),
-      " ",
-      String(st.restarts).padStart(3),
-      " ",
-      up.padStart(6)
-    ] }),
-    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-      "   cmd: ",
-      st.svc.cmd,
-      " ",
-      resolvedArgs
-    ] }),
-    envStr && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-      "   env: ",
-      envStr
-    ] })
-  ] });
+  for (const [name, n] of nextByName) {
+    if (!prevByName.has(name)) added.push(n);
+  }
+  return { added, removed, changed, unchanged };
+}
+function summariseDiff(d) {
+  const parts = [];
+  if (d.added.length) parts.push(`+${d.added.length} added`);
+  if (d.removed.length) parts.push(`-${d.removed.length} removed`);
+  if (d.changed.length) parts.push(`~${d.changed.length} changed`);
+  if (!parts.length) parts.push("no changes");
+  return parts.join(", ");
+}
+
+// src/orchestrator/config-watcher.ts
+async function applyConfigChange(opts) {
+  const { configPath, baseCwd, manager, log } = opts;
+  try {
+    const nextCfg = await loadConfig(configPath);
+    const errs = validateConfig(nextCfg, baseCwd);
+    if (errs.length) {
+      log(`\u26A0 config reload failed:
+${formatValidationErrors(errs)}`);
+      return;
+    }
+    const currentSvcs = [...manager.state.values()].map((s) => s.svc);
+    const diff = diffServices(currentSvcs, nextCfg.services);
+    if (!diff.added.length && !diff.removed.length && !diff.changed.length) return;
+    for (const name of diff.removed) {
+      manager.stop(name);
+      manager.state.delete(name);
+    }
+    let colorIdx = currentSvcs.length;
+    for (const { next } of diff.changed) {
+      const prev = manager.state.get(next.name);
+      const ci = prev?.colorIdx ?? colorIdx++;
+      manager.stop(next.name);
+      await new Promise((r) => setTimeout(r, 800));
+      await manager.install(next, ci);
+      await manager.start(next, ci, true);
+    }
+    for (const next of diff.added) {
+      const ci = colorIdx++;
+      await manager.install(next, ci);
+      await manager.start(next, ci);
+    }
+    log(`\u{1F501} config reloaded: ${summariseDiff(diff)}`);
+  } catch (e) {
+    log(`\u26A0 config reload error: ${e.message}`);
+  }
+}
+function watchConfig(opts) {
+  let debounceTimer = null;
+  let reloadInFlight = false;
+  let reloadAgain = false;
+  const trigger = async () => {
+    if (reloadInFlight) {
+      reloadAgain = true;
+      return;
+    }
+    reloadInFlight = true;
+    try {
+      await applyConfigChange(opts);
+    } finally {
+      reloadInFlight = false;
+      if (reloadAgain) {
+        reloadAgain = false;
+        void trigger();
+      }
+    }
+  };
+  const listener = (curr, prev) => {
+    if (curr.mtimeMs === prev.mtimeMs && curr.size === prev.size) return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => void trigger(), 250);
+  };
+  watchFile(opts.configPath, { interval: 500 }, listener);
+  return () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    unwatchFile(opts.configPath, listener);
+  };
+}
+
+// src/orchestrator/daemon.ts
+var SAFE = /[^a-zA-Z0-9._-]+/g;
+var sanitize2 = (n) => n.replace(SAFE, "_").replace(/^_+|_+$/g, "") || "devup";
+var devupDir = () => join8(homedir3(), ".devup");
+function pidPathFor(projectName) {
+  return join8(devupDir(), `${sanitize2(projectName)}.pid`);
+}
+function bootErrorPathFor(projectName) {
+  return join8(devupDir(), `${sanitize2(projectName)}.boot-error`);
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDaemonRunning(projectName) {
+  const path = pidPathFor(projectName);
+  if (!existsSync10(path)) return { pid: null, stale: false };
+  let pid;
+  try {
+    pid = Number(readFileSync3(path, "utf8").trim());
+    if (!pid || !Number.isFinite(pid)) return { pid: null, stale: true };
+  } catch {
+    return { pid: null, stale: true };
+  }
+  return pidAlive(pid) ? { pid, stale: false } : { pid, stale: true };
+}
+async function daemonBody(opts) {
+  const { config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts } = opts;
+  const projectName = config.name;
+  const errPath = bootErrorPathFor(projectName);
+  const pidPath = pidPathFor(projectName);
+  mkdirSync3(devupDir(), { recursive: true });
+  if (existsSync10(errPath)) {
+    try {
+      unlinkSync2(errPath);
+    } catch {
+    }
+  }
+  const logSink = new LogSink({ projectName, rootDir: cliArgs.logDir });
+  const logBus = new Broadcaster();
+  const stateBus = new Broadcaster();
+  const lazyProxies = /* @__PURE__ */ new Map();
+  let externals = [];
+  let socket = null;
+  let healthTimer = null;
+  let proxyTimer = null;
+  let stopConfigWatcher = null;
+  const writeDevupLog = (text) => {
+    logSink.write("devup", text);
+    logBus.emit({ svc: "devup", text });
+  };
+  const mgr = new ProcessManager({
+    baseCwd,
+    env,
+    platform,
+    events: {
+      onLog: (svcName, text) => {
+        logSink.write(svcName, text);
+        logBus.emit({ svc: svcName, text });
+      },
+      onStateChange: (name, state) => stateBus.emit({ name, state })
+    }
+  });
+  const cleanup = async () => {
+    if (healthTimer) clearInterval(healthTimer);
+    if (proxyTimer) clearInterval(proxyTimer);
+    if (stopConfigWatcher) {
+      try {
+        stopConfigWatcher();
+      } catch {
+      }
+    }
+    for (const p of lazyProxies.values()) p.destroy();
+    if (socket) await socket.close().catch(() => {
+    });
+    await mgr.cleanup().catch(() => {
+    });
+    if (externals.length) {
+      await stopExternals(externals, platform, {
+        baseCwd,
+        env,
+        onLog: (svc, msg) => logSink.write(`ext:${svc}`, msg)
+      }).catch(() => {
+      });
+    }
+    if (proxyProvider && proxyOpts && cliArgs.proxy) {
+      try {
+        proxyProvider.clear(proxyOpts);
+      } catch {
+      }
+    }
+    await logSink.close().catch(() => {
+    });
+    if (existsSync10(pidPath)) {
+      try {
+        unlinkSync2(pidPath);
+      } catch {
+      }
+    }
+  };
+  let shuttingDown = false;
+  const onSignal = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    cleanup().then(() => process.exit(0), () => process.exit(1));
+  };
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+  try {
+    if (config.external?.length) {
+      writeDevupLog(`\u25B6 externals (${config.external.length})`);
+      const result = await startExternals(config.external, {
+        baseCwd,
+        env,
+        platform,
+        onLog: (svc, msg) => {
+          logSink.write(`ext:${svc}`, msg);
+          logBus.emit({ svc: `ext:${svc}`, text: msg });
+        }
+      });
+      externals = result.procs;
+      if (!result.allHealthy) {
+        throw new Error(`externals failed: ${result.failed.join(", ")}`);
+      }
+    }
+    if (cliArgs.lazy && config.lazy) {
+      await bootLazy(mgr, services, config.lazy, cliArgs.lazyTimeout, lazyProxies);
+    } else {
+      await bootNormal(mgr, services);
+    }
+    socket = await startSocketServer(projectName, {
+      states: () => mgr.state,
+      restart: (n) => mgr.restart(n),
+      stop: (n) => mgr.stop(n),
+      tailLogs: async (svcName, lines) => {
+        const file = logSink.pathFor(svcName);
+        if (!existsSync10(file)) return [];
+        return new Promise((resolve4, reject) => {
+          const buf = [];
+          const rl = createInterface3({ input: createReadStream(file, { encoding: "utf8" }) });
+          rl.on("line", (l) => {
+            buf.push(l);
+            if (buf.length > lines) buf.shift();
+          });
+          rl.on("close", () => resolve4(buf));
+          rl.on("error", reject);
+        });
+      },
+      watchLogs: (svcName, onLine) => logBus.subscribe(({ svc, text }) => {
+        if (svcName === null || svc === svcName) onLine(svc, text);
+      }),
+      watchStatus: (onUpdate) => stateBus.subscribe(({ name, state }) => onUpdate(name, state))
+    }, { onLog: (msg) => writeDevupLog(msg) });
+    healthTimer = setInterval(() => {
+      void mgr.checkAllHealth();
+    }, 3e3);
+    if (proxyProvider && proxyOpts && cliArgs.proxy) {
+      let lastContent = null;
+      const sync = () => {
+        const svcStates = /* @__PURE__ */ new Map();
+        for (const [n, st] of mgr.state) {
+          svcStates.set(n, { port: st.svc.port, health: st.health, realPort: st.svc.realPort });
+        }
+        const content = proxyProvider.generate(svcStates, proxyOpts);
+        if (content === lastContent) return;
+        lastContent = content;
+        try {
+          proxyProvider.write(content, proxyOpts);
+        } catch {
+        }
+      };
+      sync();
+      proxyTimer = setInterval(sync, 3e3);
+    }
+    if (cliArgs.watchConfig) {
+      try {
+        const configPath = findConfigFile(baseCwd, cliArgs.configPath);
+        writeDevupLog(`\u{1F440} watching ${configPath}`);
+        stopConfigWatcher = watchConfig({
+          configPath,
+          baseCwd,
+          manager: mgr,
+          log: (msg) => writeDevupLog(msg)
+        });
+      } catch (e) {
+        writeDevupLog(`\u26A0 watch-config disabled: ${e.message ?? String(e)}`);
+      }
+    }
+    writeFileSync2(pidPath, String(process.pid));
+    writeDevupLog(`\u2713 daemon ready (pid=${process.pid})`);
+  } catch (e) {
+    try {
+      writeFileSync2(errPath, e.message ?? String(e));
+    } catch {
+    }
+    try {
+      writeDevupLog(`\u274C boot failed: ${e.message ?? String(e)}`);
+    } catch {
+    }
+    await cleanup().catch(() => {
+    });
+    process.exit(1);
+  }
+}
+async function bootNormal(mgr, services) {
+  const phases = groupByPhase(services);
+  let colorIdx = 0;
+  for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
+    for (const svc of phases[num]) {
+      const ci = colorIdx++;
+      await mgr.install(svc, ci);
+      await mgr.start(svc, ci);
+    }
+    const apis = phases[num].filter((s) => s.type === "api");
+    if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
+    phases[num].filter((s) => s.type === "web").forEach((s) => {
+      const st = mgr.state.get(s.name);
+      if (st) st.status = "running";
+    });
+  }
+}
+async function bootLazy(mgr, services, lazyCfg, lazyTimeout, lazyProxies) {
+  const { alwaysOn, lazy } = classifyServices(services, lazyCfg);
+  const phases = groupByPhase(alwaysOn);
+  let colorIdx = 0;
+  for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
+    for (const svc of phases[num]) {
+      const ci = colorIdx++;
+      await mgr.install(svc, ci);
+      await mgr.start(svc, ci);
+    }
+    const apis = phases[num].filter((s) => s.type === "api");
+    if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
+    phases[num].filter((s) => s.type === "web").forEach((s) => {
+      const st = mgr.state.get(s.name);
+      if (st) st.status = "running";
+    });
+  }
+  for (const svc of lazy) {
+    const ci = colorIdx++;
+    const rewritten = rewriteServicePort(svc);
+    mgr.state.set(svc.name, {
+      svc: rewritten,
+      proc: null,
+      pid: null,
+      status: "idle",
+      health: "idle",
+      errors: 0,
+      restarts: 0,
+      startedAt: null,
+      intentionalStop: false,
+      colorIdx: ci
+    });
+    const proxy = createLazyProxy({
+      listenPort: svc.port,
+      targetPort: rewritten.realPort,
+      timeoutMin: lazyTimeout,
+      onDemandStart: async () => {
+        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);
+        if (st) {
+          st.status = ok ? "running" : "timeout";
+          if (ok) st.health = "up";
+        }
+      },
+      onIdleStop: () => {
+        mgr.stop(svc.name);
+        const st = mgr.state.get(svc.name);
+        if (st) {
+          st.status = "idle";
+          st.health = "idle";
+          st.pid = null;
+          st.proc = null;
+          st.startedAt = null;
+        }
+      },
+      isAlive: () => {
+        const st = mgr.state.get(svc.name);
+        return !!st && !!st.proc && !st.proc.killed && st.health === "up";
+      }
+    });
+    lazyProxies.set(svc.name, proxy);
+  }
+}
+async function runDetached(opts) {
+  const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
+  const projectName = opts.config.name;
+  if (process.platform === "win32") {
+    out("\u274C daemon mode (devup up -d) is not yet supported on Windows. Run `devup` to use the TUI instead.");
+    return 1;
+  }
+  const existing = isDaemonRunning(projectName);
+  if (existing.pid && !existing.stale) {
+    out(`\u274C daemon already running for "${projectName}" (pid=${existing.pid}). Run \`devup down\` to stop it.`);
+    return 1;
+  }
+  if (existing.stale) {
+    out(`\u2139 removing stale pid file for "${projectName}"`);
+    try {
+      unlinkSync2(pidPathFor(projectName));
+    } catch {
+    }
+  }
+  mkdirSync3(devupDir(), { recursive: true });
+  const errPath = bootErrorPathFor(projectName);
+  const pidPath = pidPathFor(projectName);
+  if (existsSync10(errPath)) {
+    try {
+      unlinkSync2(errPath);
+    } catch {
+    }
+  }
+  const filteredArgs = process.argv.slice(2).filter((arg, i) => {
+    if (i === 0 && arg === "up") return false;
+    if (arg === "-d" || arg === "--detach") return false;
+    return true;
+  });
+  out(`\u23F3 starting devup in detached mode for "${projectName}"...`);
+  const child = spawn4(process.execPath, [...process.execArgv, process.argv[1], ...filteredArgs], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, DEVUP_DAEMON_CHILD: "1" },
+    cwd: opts.baseCwd
+  });
+  child.unref();
+  const deadline = Date.now() + 9e4;
+  while (Date.now() < deadline) {
+    if (existsSync10(pidPath)) {
+      const pid = Number(readFileSync3(pidPath, "utf8").trim());
+      out("");
+      out(`\u{1F680} devup detached (PID ${pid})`);
+      out("   inspect:  devup ctl status");
+      out("   logs:     devup ctl logs <svc> --follow");
+      out("   stop:     devup down");
+      return 0;
+    }
+    if (existsSync10(errPath)) {
+      const msg = readFileSync3(errPath, "utf8").trim();
+      out(`\u274C daemon boot failed: ${msg}`);
+      try {
+        unlinkSync2(errPath);
+      } catch {
+      }
+      return 1;
+    }
+    await sleep(200);
+  }
+  out(`\u274C daemon did not become ready within 90s. Killing child (pid=${child.pid}).`);
+  if (child.pid) {
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  return 1;
+}
+async function stopDaemon(projectName, opts = {}) {
+  const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
+  const grace = opts.gracePeriodMs ?? 1e4;
+  const status = isDaemonRunning(projectName);
+  if (!status.pid) {
+    out(`\u2139 no daemon running for "${projectName}".`);
+    return 1;
+  }
+  if (status.stale) {
+    out(`\u2139 stale pid file for "${projectName}" (pid=${status.pid} not alive). Removing.`);
+    try {
+      unlinkSync2(pidPathFor(projectName));
+    } catch {
+    }
+    return 1;
+  }
+  out(`\u23F3 stopping daemon (pid=${status.pid})...`);
+  try {
+    process.kill(status.pid, "SIGTERM");
+  } catch (e) {
+    out(`\u274C cannot signal pid=${status.pid}: ${e.message}`);
+    return 1;
+  }
+  const deadline = Date.now() + grace;
+  while (Date.now() < deadline) {
+    if (!pidAlive(status.pid)) {
+      out(`\u2713 stopped daemon (pid=${status.pid})`);
+      const p2 = pidPathFor(projectName);
+      if (existsSync10(p2)) {
+        try {
+          unlinkSync2(p2);
+        } catch {
+        }
+      }
+      return 0;
+    }
+    await sleep(200);
+  }
+  out(`\u26A0 daemon did not exit within ${(grace / 1e3).toFixed(0)}s; sending SIGKILL.`);
+  try {
+    process.kill(status.pid, "SIGKILL");
+  } catch {
+  }
+  const p = pidPathFor(projectName);
+  if (existsSync10(p)) {
+    try {
+      unlinkSync2(p);
+    } catch {
+    }
+  }
+  return 0;
+}
+
+// src/orchestrator/subcommands.ts
+var KNOWN = /* @__PURE__ */ new Set(["logs", "install", "status", "help", "ctl", "up", "down"]);
+function detectSubcommand(argv) {
+  const first = argv[0];
+  return first && KNOWN.has(first) ? first : null;
+}
+function logRoot(config, override) {
+  const root = override ?? join9(homedir4(), ".devup", "logs");
+  return join9(root, sanitize3(config.name));
+}
+function sanitize3(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 = join9(logRoot(opts.config, opts.logDir), `${sanitize3(svcArg)}.log`);
+  if (!existsSync11(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, statSync2(file).size);
+}
+async function streamFile(file, out) {
+  return new Promise((resolve4, reject) => {
+    const rl = createInterface4({ input: createReadStream2(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 (!existsSync11(file)) await new Promise((r) => setTimeout(r, 500));
+  return new Promise((resolve4) => {
+    const tick = async () => {
+      const size = statSync2(file).size;
+      if (size > pos) {
+        await new Promise((res) => {
+          const rl = createInterface4({ input: createReadStream2(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;
+      }
+    };
+    watchFile2(file, { interval: 500 }, () => {
+      void tick();
+    });
+    process.once("SIGINT", () => {
+      unwatchFile2(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: join9(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 (!existsSync11(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 = spawn5(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 fmtStatus(rows, out) {
+  const maxLen = Math.max(...rows.map((r) => r.name.length), 8);
+  for (const r of rows) {
+    const pid = r.pid != null ? `pid=${r.pid}` : "        ";
+    const name = r.name.padEnd(maxLen);
+    const port = `:${r.port}`.padStart(6);
+    const status = r.status.padEnd(8);
+    const health = r.health.padEnd(4);
+    out(`${name}  ${port}  ${status}  ${health}  ${pid}  errors=${r.errors}  restarts=${r.restarts}`);
+  }
+}
+async function runCtl(argv, opts) {
+  const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
+  const method = argv[0];
+  const follow = argv.includes("--follow") || argv.includes("-f");
+  const socketPath = resolveSocket(opts.config.name, opts.socketPath);
+  if (!method || method === "help") {
+    out("Usage: devup ctl <method> [args] [--follow]");
+    out("  ping                         Check if devup is running");
+    out("  status [--follow]            Service snapshot, or live updates");
+    out("  logs <svc> [--follow]        Tail logs (last 100), or follow live stream");
+    out("  restart <svc>                Restart a service");
+    out("  stop <svc>                   Stop a service");
+    return 0;
+  }
+  try {
+    assertSocketExists(socketPath, opts.config.name);
+  } catch (e) {
+    out(e.message);
+    return 1;
+  }
+  try {
+    if (method === "ping") {
+      const res = await sendRpc(socketPath, "ping");
+      out(`pong  ts=${res.ts}`);
+      return 0;
+    }
+    if (method === "status" && !follow) {
+      const res = await sendRpc(socketPath, "status");
+      if (!res.services.length) {
+        out("(no services)");
+        return 0;
+      }
+      fmtStatus(res.services, out);
+      return 0;
+    }
+    if (method === "status" && follow) {
+      return await new Promise((resolve4) => {
+        const abort = openStream(socketPath, "status.follow", {}, (frame) => {
+          const rows = frame.data;
+          const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+          for (const r of rows) {
+            out(`[${ts}] ${r.name.padEnd(24)}  ${r.status}/${r.health}`);
+          }
+        }, (err) => {
+          out(`error: ${err.message}`);
+          resolve4(1);
+        });
+        process.once("SIGINT", () => {
+          abort();
+          resolve4(0);
+        });
+      });
+    }
+    if (method === "logs") {
+      const svc = argv.find((a, i) => i > 0 && !a.startsWith("-"));
+      if (!svc) {
+        out("usage: devup ctl logs <service> [--follow]");
+        return 1;
+      }
+      if (!follow) {
+        const res = await sendRpc(socketPath, "logs.tail", { svc, lines: 100 });
+        for (const l of res.lines) out(l);
+        return 0;
+      }
+      return await new Promise((resolve4) => {
+        const abort = openStream(socketPath, "logs.follow", { svc, tail: 100 }, (frame) => {
+          out(frame.data);
+        }, (err) => {
+          out(`error: ${err.message}`);
+          resolve4(1);
+        });
+        process.once("SIGINT", () => {
+          abort();
+          resolve4(0);
+        });
+      });
+    }
+    if (method === "restart") {
+      const svc = argv[1];
+      if (!svc) {
+        out("usage: devup ctl restart <service>");
+        return 1;
+      }
+      await sendRpc(socketPath, "restart", { svc });
+      out(`\u2713 restart sent to ${svc}`);
+      return 0;
+    }
+    if (method === "stop") {
+      const svc = argv[1];
+      if (!svc) {
+        out("usage: devup ctl stop <service>");
+        return 1;
+      }
+      await sendRpc(socketPath, "stop", { svc });
+      out(`\u2713 stop sent to ${svc}`);
+      return 0;
+    }
+    out(`unknown ctl method: ${method}. Run \`devup ctl help\` for usage.`);
+    return 1;
+  } catch (e) {
+    out(`error: ${e.message}`);
+    return 1;
+  }
+}
+async function runDown(opts) {
+  const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
+  return stopDaemon(opts.config.name, { out });
+}
+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;
+  }
+  if (sub === "ctl") {
+    out("Usage: devup ctl <method> [args] [--follow]");
+    out("  Send commands to a running devup process via the control plane socket.");
+    out("");
+    out("  ping                         Check if devup is running");
+    out("  status [--follow]            Service snapshot, or live state-change stream");
+    out("  logs <svc> [--follow]        Tail last 100 lines, or follow the live stream");
+    out("  restart <svc>                Restart the named service");
+    out("  stop <svc>                   Stop the named service");
+    out("");
+    out("  devup must be running in the same project directory.");
+    return 0;
+  }
+  if (sub === "up") {
+    out("Usage: devup up -d");
+    out("  Boot the stack in detached/daemon mode (like `docker compose up -d`).");
+    out("  Returns immediately once the stack is healthy; services keep running.");
+    out("  Use `devup ctl status`, `devup ctl logs`, or `devup down` to interact.");
+    out("  Not supported on Windows yet \u2014 use `devup` (TUI) instead.");
+    return 0;
+  }
+  if (sub === "down") {
+    out("Usage: devup down");
+    out("  Stop the daemon for the current project. SIGTERM with 10s grace,");
+    out("  then SIGKILL. Removes the PID file and the control-plane socket.");
+    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 up -d                       Boot the stack in detached/daemon mode");
+  out("  devup down                        Stop the running daemon");
+  out("  devup ctl <method> [args]         Control a running devup (restart/stop/logs/...)");
+  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) {
+    case "linux": {
+      const { LinuxPlatform } = await import("./linux-OQ3Q4Z2Z.js");
+      return new LinuxPlatform();
+    }
+    case "darwin": {
+      const { DarwinPlatform } = await import("./darwin-3KJ3IEXN.js");
+      return new DarwinPlatform();
+    }
+    case "win32": {
+      const { Win32Platform } = await import("./win32-3X2OLSI6.js");
+      return new Win32Platform();
+    }
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+
+// src/proxy-config/traefik.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4 } from "path";
+var EMPTY_CONFIG = "http:\n  routers: {}\n  services: {}\n";
+var TraefikProvider = class {
+  name = "traefik";
+  generate(services, opts) {
+    const routers = [];
+    const svcs = [];
+    for (const [name, st] of services) {
+      if (st.health !== "up") continue;
+      const sub = opts.routes[name];
+      if (sub === void 0) continue;
+      const rule = sub ? `Host(\`${sub}.${opts.domain}\`)` : `Host(\`${opts.domain}\`)`;
+      const safe = name.replace(/[^a-z0-9-]/g, "-");
+      const port = st.realPort ?? st.port;
+      let router = `    ${safe}:
+      rule: "${rule}"
+      service: ${safe}
+      entryPoints:
+        - ${opts.entrypoint}`;
+      if (opts.tls) router += `
+      tls:
+        certResolver: le`;
+      routers.push(router);
+      svcs.push(`    ${safe}:
+      loadBalancer:
+        servers:
+          - url: "http://${opts.host}:${port}"`);
+    }
+    if (!routers.length) return EMPTY_CONFIG;
+    return `http:
+  routers:
+${routers.join("\n")}
+  services:
+${svcs.join("\n")}
+`;
+  }
+  write(content, opts) {
+    const dir = dirname4(opts.confPath);
+    if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
+    writeFileSync3(opts.confPath, content);
+  }
+  clear(opts) {
+    this.write(EMPTY_CONFIG, opts);
+  }
+};
+
+// src/proxy-config/nginx.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5 } 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 = dirname5(opts.confPath);
+    if (!existsSync13(dir)) mkdirSync5(dir, { recursive: true });
+    writeFileSync4(opts.confPath, content);
+  }
+  clear(opts) {
+    this.write(EMPTY_CONFIG2, opts);
+  }
+};
+
+// src/proxy-config/caddy.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6 } 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 = dirname6(opts.confPath);
+    if (!existsSync14(dir)) mkdirSync6(dir, { recursive: true });
+    writeFileSync5(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/tui/App.tsx
+import { useCallback as useCallback3, useRef as useRef5 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/tui/hooks/useProcessManager.ts
+import { useState, useEffect, useRef, useCallback } from "react";
+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;
+  const logBus = useRef(new Broadcaster());
+  const stateBus = useRef(new Broadcaster());
+  useEffect(() => {
+    const mgr2 = new ProcessManager({
+      baseCwd,
+      env,
+      platform,
+      events: {
+        onLog: (svcName, text, colorIdx) => {
+          sinkRef.current?.write(svcName, text);
+          logBus.current.emit({ svc: svcName, text });
+          const entry = { svcName, text, colorIdx, ts: Date.now(), level: detectLogLevel(text) };
+          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;
+          });
+        },
+        onStateChange: (name, state) => {
+          stateBus.current.emit({ name, state });
+          setStates(new Map(mgr2.state));
+        }
+      }
+    });
+    mgrRef.current = mgr2;
+    return () => {
+      mgr2.cleanup();
+    };
+  }, [baseCwd, env, platform]);
+  useEffect(() => {
+    const id = setInterval(async () => {
+      const mgr2 = mgrRef.current;
+      if (!mgr2) return;
+      await mgr2.checkAllHealth();
+      setStates(new Map(mgr2.state));
+      const pids = [];
+      const pidMap = /* @__PURE__ */ new Map();
+      for (const [name, st] of mgr2.state) {
+        if (st.pid) {
+          pids.push(st.pid);
+          pidMap.set(st.pid, name);
+        }
+      }
+      if (pids.length) {
+        const raw = await platform.getProcessStats(pids);
+        const next = /* @__PURE__ */ new Map();
+        for (const [pid, data] of raw) {
+          const name = pidMap.get(pid);
+          if (!name) continue;
+          const prev = prevCpu.current.get(name) ?? { time: Date.now(), cpu: 0 };
+          const cpuPct = calcCpuPercent(data.cpuSeconds, prev.cpu, prev.time);
+          prevCpu.current.set(name, { time: Date.now(), cpu: data.cpuSeconds });
+          next.set(name, { cpu: cpuPct.toFixed(1) + "%", mem: (data.rss / 1024).toFixed(1) + " MB" });
+        }
+        setStats(next);
+      }
+    }, 3e3);
+    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);
+    logBus.current.emit({ svc: svcName, text });
+    const entry = { svcName, text, colorIdx, ts: Date.now(), level: detectLogLevel(text) };
+    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,
+    stats,
+    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, colorIdx) => mgr?.install(svc, colorIdx), [mgr]),
+    cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
+    clearLogs,
+    setPaused,
+    pushLog,
+    manager: mgr,
+    logBus: logBus.current,
+    stateBus: stateBus.current
+  };
+}
+
+// src/tui/hooks/useKeyBindings.ts
+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",
+    modal: "none",
+    logFilter: null,
+    searchTerm: null,
+    logsPaused: false,
+    showTimestamps: false,
+    sortIdx: 0,
+    proxyEnabled: false,
+    logsScrollOffset: 0,
+    statsScrollOffset: 0,
+    levelFilter: "all",
+    verboseStats: false
+  });
+  const LEVEL_CYCLE = ["all", "error", "warn"];
+  const setModal = useCallback2((modal) => setState((s) => ({ ...s, modal })), []);
+  const setFilter = useCallback2((f) => setState((s) => ({ ...s, logFilter: f, modal: "none" })), []);
+  const setSearch = useCallback2((t) => setState((s) => ({ ...s, searchTerm: t, modal: "none" })), []);
+  const isActive = process.stdin.isTTY ?? false;
+  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");
+    else if (input === "r") setModal("restart");
+    else if (input === "o") setModal("open");
+    else if (input === "/") setModal("search");
+    else if (input === "a") setState((s) => ({ ...s, logFilter: null, searchTerm: null, levelFilter: "all" }));
+    else if (input === "p") setState((s) => ({ ...s, logsPaused: !s.logsPaused }));
+    else if (input === "t") setState((s) => ({ ...s, showTimestamps: !s.showTimestamps }));
+    else if (input === "s") setState((s) => ({ ...s, sortIdx: (s.sortIdx + 1) % SORT_MODES.length }));
+    else if (input === "T") {
+      opts.onToggleProxy();
+      setState((s) => ({ ...s, proxyEnabled: !s.proxyEnabled }));
+    } else if (input === "L") setState((s) => ({ ...s, levelFilter: LEVEL_CYCLE[(LEVEL_CYCLE.indexOf(s.levelFilter) + 1) % LEVEL_CYCLE.length] }));
+    else if (input === "v") setState((s) => ({ ...s, verboseStats: !s.verboseStats }));
+  }, { isActive });
+  return {
+    ...state,
+    setModal,
+    setFilter,
+    setSearch,
+    sortMode: SORT_MODES[state.sortIdx],
+    // Funciones para resetear el scroll cuando cambia el contenido
+    resetLogsScroll: useCallback2(() => setState((s) => ({ ...s, logsScrollOffset: 0 })), []),
+    resetStatsScroll: useCallback2(() => setState((s) => ({ ...s, statsScrollOffset: 0 })), [])
+  };
+}
+
+// src/tui/hooks/useProxySync.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+function useProxySync(provider, opts, states, enabled) {
+  const statesRef = useRef2(states);
+  const lastContentRef = useRef2(null);
+  statesRef.current = states;
+  useEffect2(() => {
+    if (!provider || !opts || !enabled) return;
+    const sync = () => {
+      const svcStates = /* @__PURE__ */ new Map();
+      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();
+    const id = setInterval(sync, 3e3);
+    return () => {
+      clearInterval(id);
+      lastContentRef.current = null;
+    };
+  }, [provider, opts, enabled]);
 }
-function ColHeader({ ml }) {
-  return /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
-    "H ",
-    "Service".padEnd(ml),
-    " ",
-    "Port".padStart(5),
-    " ",
-    "Status".padEnd(8),
-    " ",
-    "CPU".padStart(6),
-    " ",
-    "Mem".padStart(8),
-    " Err Rst ",
-    "Up".padStart(6)
-  ] });
+
+// src/tui/hooks/useTerminalSize.ts
+import { useEffect as useEffect3, useState as useState3 } from "react";
+import { useStdout } from "ink";
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [rows, setRows] = useState3(stdout?.rows ?? 40);
+  useEffect3(() => {
+    if (!stdout) return;
+    const onResize = () => setRows(stdout.rows ?? 40);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return rows;
 }
-function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused, scrollOffset, resetScroll, verbose = false }) {
-  const names = [...states.keys()];
-  const stObj = Object.fromEntries([...states].map(([k, v]) => [k, { errors: v.errors }]));
-  const statsObj = Object.fromEntries([...stats].map(([k, v]) => [k, v]));
-  const apis = sortServiceNames(names.filter((n) => states.get(n).svc.type === "api"), sortMode, statsObj, stObj);
-  const webs = sortServiceNames(names.filter((n) => states.get(n).svc.type === "web"), sortMode, statsObj, stObj);
-  const cpus = os.cpus().length;
-  const totalGB = (os.totalmem() / 1024 / 1024 / 1024).toFixed(1);
-  const usedGB = (parseFloat(totalGB) - os.freemem() / 1024 / 1024 / 1024).toFixed(1);
-  const load = os.loadavg()[0].toFixed(2);
-  let totalCpu = 0, totalMemMB = 0, totalErrors = 0, totalRestarts = 0;
-  for (const name of names) {
-    const s = stats.get(name);
-    if (s) {
-      const c = parseFloat(s.cpu);
-      if (!isNaN(c)) totalCpu += c;
-      const m = parseFloat(s.mem);
-      if (!isNaN(m)) totalMemMB += m;
-    }
-    totalErrors += states.get(name)?.errors ?? 0;
-    totalRestarts += states.get(name)?.restarts ?? 0;
-  }
-  const stackMem = totalMemMB >= 1024 ? (totalMemMB / 1024).toFixed(2) + " GB" : totalMemMB.toFixed(1) + " MB";
-  const ml = maxNameLen;
-  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 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;
-  const ramPct = parseFloat(usedGB) / parseFloat(totalGB) * 100;
-  const [ramBanner, setRamBanner] = useState3(false);
+
+// src/tui/hooks/useLogsPause.ts
+import { useEffect as useEffect4 } from "react";
+function useLogsPause(setPaused, logsPaused, logsScrollOffset) {
   useEffect4(() => {
-    setRamBanner((prev) => nextRamBannerVisibility(ramPct, prev));
-  }, [ramPct]);
-  const topConsumers = ramBanner ? [...stats.entries()].map(([n, s]) => ({ name: n, mb: parseFloat(s.mem) || 0 })).sort((a, b) => b.mb - a.mb).slice(0, 3) : [];
-  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]" }),
-      loopedCount > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "red", bold: true, children: [
-        " \u26A0 ",
-        loopedCount,
-        " need attention"
-      ] }),
-      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        " System: ",
-        cpus,
-        "c Load ",
-        load,
-        " RAM ",
-        usedGB,
-        "/",
-        totalGB,
-        "GB"
-      ] }),
-      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \u2502 " }),
-      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        "Stack: CPU ",
-        totalCpu.toFixed(1),
-        "% RAM ",
-        stackMem,
-        " Err ",
-        totalErrors,
-        " Rst ",
-        totalRestarts,
-        " Svcs ",
-        names.length
-      ] }),
-      sortMode !== "name" && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        " \u2502 Sort: ",
-        sortMode
-      ] })
-    ] }),
-    ramBanner && /* @__PURE__ */ jsxs2(Box2, { children: [
-      /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
-        " \u26A0 RAM ",
-        ramPct.toFixed(0),
-        "% \u2014 top: "
-      ] }),
-      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: topConsumers.map((c) => `${c.name} ${c.mb.toFixed(0)}MB`).join(", ") })
-    ] }),
-    /* @__PURE__ */ jsxs2(Box2, { flexGrow: 1, children: [
-      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
-        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
-          " APIs (",
-          apis.length,
-          ")"
-        ] }),
-        /* @__PURE__ */ jsx2(ColHeader, { ml }),
-        visibleApis.map((n) => /* @__PURE__ */ jsx2(Row, { name: n, st: states.get(n), stat: stats.get(n), ml, verbose }, n))
-      ] }),
-      /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", width: 1, children: Array.from({ length: contentHeight }, (_, i) => /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2502" }, i)) }),
-      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
-        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "magenta", children: [
-          " Webs (",
-          webs.length,
-          ")"
-        ] }),
-        /* @__PURE__ */ jsx2(ColHeader, { ml }),
-        visibleWebs.map((n) => /* @__PURE__ */ jsx2(Row, { name: n, st: states.get(n), stat: stats.get(n), ml, verbose }, n))
-      ] })
-    ] })
-  ] });
+    setPaused(logsPaused || logsScrollOffset > 0);
+  }, [logsPaused, logsScrollOffset, setPaused]);
 }
 
-// src/tui/StatusBar.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function StatusBar() {
-  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "q" }),
-    " Quit  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Tab" }),
-    " Switch  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "\u2191\u2193" }),
-    " Scroll  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "PgUp/PgDn" }),
-    " Page  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Ctrl+A/E" }),
-    " Home/End  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "c" }),
-    " Clear  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "f" }),
-    " Filter  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "L" }),
-    " Level  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "a" }),
-    " All  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "r" }),
-    " Restart  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "/" }),
-    " Search  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "s" }),
-    " Sort  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "o" }),
-    " Open  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "p" }),
-    " Pause  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "t" }),
-    " Time  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "v" }),
-    " Verbose  ",
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "T" }),
-    " Proxy"
-  ] }) });
+// src/tui/hooks/useControlPlane.ts
+import { useEffect as useEffect5, useRef as useRef3 } from "react";
+import { createInterface as createInterface5 } from "readline";
+import { createReadStream as createReadStream3, existsSync as existsSync15 } from "fs";
+function useControlPlane(manager, projectName, logSink, pushLog, logBus, stateBus) {
+  const handleRef = useRef3(null);
+  useEffect5(() => {
+    if (!manager) return;
+    let handle = null;
+    (async () => {
+      try {
+        handle = await startSocketServer(projectName, {
+          states: () => manager.state,
+          restart: (name) => manager.restart(name),
+          stop: (name) => manager.stop(name),
+          tailLogs: async (svcName, lines) => {
+            if (!logSink) return [];
+            const file = logSink.pathFor(svcName);
+            if (!existsSync15(file)) return [];
+            return new Promise((resolve4, reject) => {
+              const buf = [];
+              const rl = createInterface5({ input: createReadStream3(file, { encoding: "utf8" }) });
+              rl.on("line", (l) => {
+                buf.push(l);
+                if (buf.length > lines) buf.shift();
+              });
+              rl.on("close", () => resolve4(buf));
+              rl.on("error", reject);
+            });
+          },
+          watchLogs: (svcName, onLine) => {
+            return logBus.subscribe(({ svc, text }) => {
+              if (svcName === null || svc === svcName) onLine(svc, text);
+            });
+          },
+          watchStatus: (onUpdate) => {
+            return stateBus.subscribe(({ name, state }) => onUpdate(name, state));
+          }
+        }, { onLog: (msg) => pushLog("devup", msg, 12) });
+        handleRef.current = handle;
+      } catch (e) {
+        pushLog("devup", `\u26A0 control plane disabled: ${e.message}`, 5);
+      }
+    })();
+    return () => {
+      void handle?.close();
+      handleRef.current = null;
+    };
+  }, [manager, projectName, logSink, pushLog, logBus, stateBus]);
+  return handleRef;
 }
 
-// src/tui/ServiceList.tsx
-import { useState as useState4, useMemo as useMemo2 } 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 allNames = useMemo2(
-    () => [...services.keys()].filter((n) => !filterType || services.get(n).svc.type === filterType),
-    [services, filterType]
-  );
-  const [idx, setIdx] = useState4(0);
-  const [query, setQuery] = useState4("");
-  const names = useMemo2(() => {
-    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) {
-      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);
+// src/tui/hooks/useHotReload.ts
+import { useEffect as useEffect6 } from "react";
+function useHotReload(manager, cliArgs, baseCwd, pushLog) {
+  useEffect6(() => {
+    if (!cliArgs.watchConfig || !manager) return;
+    let configPath;
+    try {
+      configPath = findConfigFile(baseCwd, cliArgs.configPath);
+    } catch (e) {
+      pushLog("devup", `\u26A0 watch-config disabled: ${e.message}`, 5);
       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: [
+    pushLog("devup", `\u{1F440} watching ${configPath}`, 12);
+    return watchConfig({
+      configPath,
+      baseCwd,
+      manager,
+      log: (msg) => pushLog("devup", msg, msg.startsWith("\u26A0") ? 5 : 12)
+    });
+  }, [cliArgs.watchConfig, cliArgs.configPath, baseCwd, manager, pushLog]);
+}
+
+// src/tui/hooks/useContextualTips.ts
+import { useEffect as useEffect8, useRef as useRef4, useState as useState5 } from "react";
+
+// 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/StatsPanel.tsx
+import { useEffect as useEffect7, useState as useState4 } from "react";
+import { Box, Text } from "ink";
+import os from "os";
+import { jsx, jsxs } from "react/jsx-runtime";
+var H = {
+  up: { c: "\u25CF", color: "green" },
+  wait: { c: "\u25CF", color: "yellow" },
+  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, verbose }) {
+  const looped = isCrashLooped(st);
+  const indicator = looped ? /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "\u2716" }) : /* @__PURE__ */ jsx(Text, { color: (H[st.health] ?? H["down"]).color, children: (H[st.health] ?? H["down"]).c });
+  const color = tagColors[st.colorIdx % tagColors.length];
+  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) : "-";
+  if (!verbose) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      indicator,
       " ",
-      title,
+      /* @__PURE__ */ jsx(Text, { color, children: name.padEnd(ml) }),
       " ",
-      query && /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
-        "[",
-        query,
-        "]"
-      ] })
+      String(st.svc.port).padStart(5),
+      " ",
+      /* @__PURE__ */ jsx(Text, { color: sc, bold: looped, children: statusLabel.padEnd(8) }),
+      " ",
+      (stat?.cpu ?? "-").padStart(6),
+      " ",
+      (stat?.mem ?? "-").padStart(8),
+      " ",
+      String(st.errors).padStart(3),
+      " ",
+      String(st.restarts).padStart(3),
+      " ",
+      up.padStart(6)
+    ] });
+  }
+  const resolvedArgs = buildProcessArgs(st.svc).join(" ");
+  const env = redactSecrets(st.svc.extraEnv);
+  const envStr = Object.entries(env).map(([k, v]) => `${k}=${v}`).join(" ");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      indicator,
+      " ",
+      /* @__PURE__ */ jsx(Text, { color, children: name.padEnd(ml) }),
+      " ",
+      String(st.svc.port).padStart(5),
+      " ",
+      /* @__PURE__ */ jsx(Text, { color: sc, bold: looped, children: statusLabel.padEnd(8) }),
+      " ",
+      (stat?.cpu ?? "-").padStart(6),
+      " ",
+      (stat?.mem ?? "-").padStart(8),
+      " ",
+      String(st.errors).padStart(3),
+      " ",
+      String(st.restarts).padStart(3),
+      " ",
+      up.padStart(6)
     ] }),
-    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: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "   cmd: ",
+      st.svc.cmd,
       " ",
-      name,
-      " :",
-      services.get(name).svc.port,
-      " "
-    ] }) }, name)),
-    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "type to filter  \u2191\u2193 navigate  Enter select  Esc clear/close" })
+      resolvedArgs
+    ] }),
+    envStr && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "   env: ",
+      envStr
+    ] })
   ] });
 }
-
-// src/tui/SearchInput.tsx
-import { useState as useState5 } from "react";
-import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-function SearchInput({ onSubmit, onClose }) {
-  const [value, setValue] = useState5("");
-  useInput3((input, key) => {
-    if (key.escape) onClose();
-    else if (key.return) onSubmit(value.trim() || null);
-    else if (key.backspace || key.delete) setValue((v) => v.slice(0, -1));
-    else if (input && !key.ctrl && !key.meta) setValue((v) => v + input);
-  }, { isActive: process.stdin.isTTY ?? false });
-  return /* @__PURE__ */ jsxs5(Box5, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "yellow", children: "Search: " }),
-    /* @__PURE__ */ jsx5(Text5, { children: value }),
-    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2588" })
+function ColHeader({ ml }) {
+  return /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+    "H ",
+    "Service".padEnd(ml),
+    " ",
+    "Port".padStart(5),
+    " ",
+    "Status".padEnd(8),
+    " ",
+    "CPU".padStart(6),
+    " ",
+    "Mem".padStart(8),
+    " Err Rst ",
+    "Up".padStart(6)
   ] });
 }
-
-// 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 = [];
-  const activeConns = /* @__PURE__ */ new Set();
-  function bumpActivity() {
-    lastActivity = Date.now();
-  }
-  function scheduleIdleCheck() {
-    if (idleTimer) clearTimeout(idleTimer);
-    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", () => {
-        if (!client.destroyed) client.end();
-      });
-      client.on("end", () => {
-        if (!target.destroyed) target.end();
-      });
-    });
-  }
-  async function handleConnection(client) {
-    bumpActivity();
-    client.on("error", () => {
-    });
-    if (serviceReady && isAlive()) {
-      pipeToTarget(client);
-      return;
-    }
-    pendingConns.push(client);
-    client.on("close", () => {
-      pendingConns = pendingConns.filter((s) => s !== client);
-    });
-    if (starting) return;
-    starting = true;
-    onLog?.("\u26A1 on-demand start");
-    let ok = false;
-    try {
-      await onDemandStart();
-      ok = await waitForPort(targetPort, { timeout: 45e3, interval: 500 });
-      if (ok) serviceReady = true;
-      else onLog?.("\u26A0 timeout waiting for service");
-    } catch (e) {
-      onLog?.(`\u274C start failed: ${e.message}`);
-    }
-    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);
+function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused, scrollOffset, resetScroll, verbose = false }) {
+  const names = [...states.keys()];
+  const stObj = Object.fromEntries([...states].map(([k, v]) => [k, { errors: v.errors }]));
+  const statsObj = Object.fromEntries([...stats].map(([k, v]) => [k, v]));
+  const apis = sortServiceNames(names.filter((n) => states.get(n).svc.type === "api"), sortMode, statsObj, stObj);
+  const webs = sortServiceNames(names.filter((n) => states.get(n).svc.type === "web"), sortMode, statsObj, stObj);
+  const cpus = os.cpus().length;
+  const totalGB = (os.totalmem() / 1024 / 1024 / 1024).toFixed(1);
+  const usedGB = (parseFloat(totalGB) - os.freemem() / 1024 / 1024 / 1024).toFixed(1);
+  const load = os.loadavg()[0].toFixed(2);
+  let totalCpu = 0, totalMemMB = 0, totalErrors = 0, totalRestarts = 0;
+  for (const name of names) {
+    const s = stats.get(name);
+    if (s) {
+      const c = parseFloat(s.cpu);
+      if (!isNaN(c)) totalCpu += c;
+      const m = parseFloat(s.mem);
+      if (!isNaN(m)) totalMemMB += m;
     }
+    totalErrors += states.get(name)?.errors ?? 0;
+    totalRestarts += states.get(name)?.restarts ?? 0;
   }
-  const server = net2.createServer({ allowHalfOpen: true }, (socket) => handleConnection(socket));
-  server.listen(listenPort, "0.0.0.0");
-  scheduleIdleCheck();
-  return {
-    server,
-    resetTimer: bumpActivity,
-    destroy: () => {
-      if (idleTimer) clearTimeout(idleTimer);
-      pendingConns.forEach((s) => s.destroy());
-      activeConns.forEach((s) => s.destroy());
-      server.close();
-    }
-  };
+  const stackMem = totalMemMB >= 1024 ? (totalMemMB / 1024).toFixed(2) + " GB" : totalMemMB.toFixed(1) + " MB";
+  const ml = maxNameLen;
+  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);
+  useEffect7(() => {
+    resetScroll();
+  }, [sortMode, resetScroll]);
+  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;
+  const ramPct = parseFloat(usedGB) / parseFloat(totalGB) * 100;
+  const [ramBanner, setRamBanner] = useState4(false);
+  useEffect7(() => {
+    setRamBanner((prev) => nextRamBannerVisibility(ramPct, prev));
+  }, [ramPct]);
+  const topConsumers = ramBanner ? [...stats.entries()].map(([n, s]) => ({ name: n, mb: parseFloat(s.mem) || 0 })).sort((a, b) => b.mb - a.mb).slice(0, 3) : [];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: focused ? "green" : "gray", height, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, color: "green", children: [
+        " Stats ",
+        positionInfo
+      ] }),
+      scrolled && /* @__PURE__ */ jsx(Text, { color: "yellow", children: " [SCROLL]" }),
+      loopedCount > 0 && /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
+        " \u26A0 ",
+        loopedCount,
+        " need attention"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " System: ",
+        cpus,
+        "c Load ",
+        load,
+        " RAM ",
+        usedGB,
+        "/",
+        totalGB,
+        "GB"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Stack: CPU ",
+        totalCpu.toFixed(1),
+        "% RAM ",
+        stackMem,
+        " Err ",
+        totalErrors,
+        " Rst ",
+        totalRestarts,
+        " Svcs ",
+        names.length
+      ] }),
+      sortMode !== "name" && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " \u2502 Sort: ",
+        sortMode
+      ] })
+    ] }),
+    ramBanner && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", bold: true, children: [
+        " \u26A0 RAM ",
+        ramPct.toFixed(0),
+        "% \u2014 top: "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: topConsumers.map((c) => `${c.name} ${c.mb.toFixed(0)}MB`).join(", ") })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
+        /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+          " APIs (",
+          apis.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx(ColHeader, { ml }),
+        visibleApis.map((n) => /* @__PURE__ */ jsx(Row, { name: n, st: states.get(n), stat: stats.get(n), ml, verbose }, n))
+      ] }),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: 1, children: Array.from({ length: contentHeight }, (_, i) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }, i)) }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
+        /* @__PURE__ */ jsxs(Text, { bold: true, color: "magenta", children: [
+          " Webs (",
+          webs.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx(ColHeader, { ml }),
+        visibleWebs.map((n) => /* @__PURE__ */ jsx(Row, { name: n, st: states.get(n), stat: stats.get(n), ml, verbose }, n))
+      ] })
+    ] })
+  ] });
 }
 
-// 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);
+// src/tui/hooks/useContextualTips.ts
+function useContextualTips(totalLogs, hasSearch, hasFilter, states) {
+  const shownTips = useRef4(/* @__PURE__ */ new Set());
+  const [activeTip, setActiveTip] = useState5(null);
+  useEffect8(() => {
+    const tip = pickTip({
+      totalLogs,
+      hasSearch,
+      hasFilter,
+      crashLoopedCount: [...states.values()].filter(isCrashLooped).length,
+      shown: shownTips.current
+    });
+    if (tip && tip.message !== activeTip) {
+      shownTips.current.add(tip.id);
+      setActiveTip(tip.message);
+      const timer = setTimeout(() => setActiveTip(null), 12e3);
+      return () => clearTimeout(timer);
     }
-  }
-  return { procs, allHealthy: failed.length === 0, failed };
+  }, [totalLogs, states, hasSearch, hasFilter, activeTip]);
+  return activeTip;
 }
-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);
+
+// src/tui/hooks/useBootSequence.ts
+import { useEffect as useEffect9, useState as useState6 } from "react";
+function useBootSequence(manager, config, services, cliArgs, platform, env, baseCwd, refs, pushLog) {
+  const [booted, setBooted] = useState6(false);
+  useEffect9(() => {
+    if (booted || !manager) return;
+    setBooted(true);
+    const mgr = manager;
+    (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) => pushLog(`ext:${svc}`, msg, 12)
         });
+        refs.externals.current = result.procs;
+        if (!result.allHealthy) {
+          pushLog("devup", `\u274C external(s) failed: ${result.failed.join(", ")}. Aborting boot.`, 5);
+          return;
+        }
       }
-    } 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;
+      if (lazyMode && config.lazy) {
+        const { alwaysOn, lazy } = classifyServices(services, config.lazy);
+        const aoPhases = groupByPhase(alwaysOn);
+        let colorIdx = 0;
+        for (const num of Object.keys(aoPhases).map(Number).sort((a, b) => a - b)) {
+          const svcs = aoPhases[num];
+          for (const svc of svcs) {
+            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 })));
+          svcs.filter((s) => s.type === "web").forEach((s) => {
+            const st = mgr.state.get(s.name);
+            if (st) st.status = "running";
+          });
+        }
+        for (const svc of lazy) {
+          const ci = colorIdx++;
+          const rewritten = rewriteServicePort(svc);
+          const idleState = {
+            svc: rewritten,
+            proc: null,
+            pid: null,
+            status: "idle",
+            health: "idle",
+            errors: 0,
+            restarts: 0,
+            startedAt: null,
+            intentionalStop: false,
+            colorIdx: ci
+          };
+          mgr.state.set(svc.name, idleState);
+          const proxy = createLazyProxy({
+            listenPort: svc.port,
+            targetPort: rewritten.realPort,
+            timeoutMin: lazyTimeout,
+            onDemandStart: async () => {
+              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);
+              if (st) {
+                st.status = ok ? "running" : "timeout";
+                if (ok) st.health = "up";
+              }
+            },
+            onIdleStop: () => {
+              mgr.stop(svc.name);
+              const st = mgr.state.get(svc.name);
+              if (st) {
+                st.status = "idle";
+                st.health = "idle";
+                st.pid = null;
+                st.proc = null;
+                st.startedAt = null;
+              }
+            },
+            isAlive: () => {
+              const st = mgr.state.get(svc.name);
+              return !!st && !!st.proc && !st.proc.killed && st.health === "up";
+            }
+          });
+          refs.lazyProxies.current.set(svc.name, proxy);
+        }
+      } else {
+        const phases = groupByPhase(services);
+        let colorIdx = 0;
+        for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
+          const svcs = phases[num];
+          for (const svc of svcs) {
+            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 })));
+          svcs.filter((s) => s.type === "web").forEach((s) => {
+            const st = mgr.state.get(s.name);
+            if (st) st.status = "running";
+          });
+        }
+      }
+    })();
+  }, [booted, manager, services, cliArgs, config.lazy, config.external, baseCwd, env, platform, refs, pushLog]);
 }
-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));
+
+// src/tui/LogsPanel.tsx
+import { useEffect as useEffect10, useMemo } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function resolveBorder(focused, filter, filteredColorIdx) {
+  if (focused) return "cyan";
+  if (filter && filteredColorIdx !== null && filteredColorIdx >= 0) {
+    return tagColors[filteredColorIdx % tagColors.length];
   }
-  return false;
+  return "gray";
+}
+function LogsPanel({ logs, filter, searchTerm, paused, showTimestamps, maxNameLen, height, focused, scrollOffset, resetScroll, levelFilter = "all", filteredColorIdx = null }) {
+  const byService = filter ? logs.filter((l) => l.svcName === filter) : logs;
+  const filtered = levelFilter === "all" ? byService : levelFilter === "error" ? byService.filter((l) => l.level === "error") : byService.filter((l) => l.level === "error" || l.level === "warn");
+  const contentHeight = Math.max(1, height - 2);
+  const totalLines = filtered.length;
+  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);
+  useEffect10(() => {
+    resetScroll();
+  }, [filter, searchTerm, resetScroll]);
+  const matcher = useMemo(() => compileSearchPattern(searchTerm), [searchTerm]);
+  const scrolled = effectiveOffset > 0;
+  const label = [
+    "Logs",
+    filter ? `[${filter}]` : "",
+    searchTerm ? `/${searchTerm}` : "",
+    matcher?.invalid ? "(invalid regex)" : "",
+    levelFilter !== "all" ? `[level: ${levelFilter}${levelFilter === "warn" ? "+error" : ""}]` : "",
+    paused ? "[PAUSED]" : "",
+    scrolled ? "[SCROLL]" : "",
+    `${filtered.length} lines`,
+    focused && totalLines > 0 ? `(${startIndex + 1}-${endIndex}/${totalLines})` : ""
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: resolveBorder(focused, filter, filteredColorIdx), height, children: [
+    /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
+      " ",
+      label,
+      " "
+    ] }) }),
+    visible.map((entry, i) => {
+      const color = tagColors[entry.colorIdx % tagColors.length];
+      const ts = showTimestamps ? new Date(entry.ts).toLocaleTimeString("en-GB") + " " : "";
+      const line = entry.text;
+      const isMatch = matcher ? matcher.test(line) : false;
+      return /* @__PURE__ */ jsxs2(Box2, { children: [
+        showTimestamps && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: ts }),
+        /* @__PURE__ */ jsxs2(Text2, { color, children: [
+          "[",
+          entry.svcName.padEnd(maxNameLen),
+          "]"
+        ] }),
+        /* @__PURE__ */ jsx2(Text2, { children: " " }),
+        isMatch ? /* @__PURE__ */ jsx2(Text2, { backgroundColor: "yellow", color: "black", children: line }) : /* @__PURE__ */ jsx2(Text2, { children: line })
+      ] }, i);
+    })
+  ] });
 }
 
-// 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/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function StatusBar() {
+  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "q" }),
+    " Quit  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Tab" }),
+    " Switch  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "\u2191\u2193" }),
+    " Scroll  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "PgUp/PgDn" }),
+    " Page  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Ctrl+A/E" }),
+    " Home/End  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "c" }),
+    " Clear  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "f" }),
+    " Filter  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "L" }),
+    " Level  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "a" }),
+    " All  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "r" }),
+    " Restart  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "/" }),
+    " Search  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "s" }),
+    " Sort  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "o" }),
+    " Open  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "p" }),
+    " Pause  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "t" }),
+    " Time  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "v" }),
+    " Verbose  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "T" }),
+    " Proxy"
+  ] }) });
 }
 
-// src/control-plane/socket-server.ts
-import { createServer } from "net";
-import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync10, unlinkSync, chmodSync, mkdirSync as mkdirSync4, statSync as statSync2 } from "fs";
-import { dirname as dirname5 } from "path";
-import { join as join6 } from "path";
-import { homedir as homedir2 } from "os";
-function defaultSocketPath(projectName) {
-  const safe = projectName.replace(/[^a-zA-Z0-9._-]+/g, "_") || "devup";
-  return join6(homedir2(), ".devup", `sock-${safe}.sock`);
-}
-async function startSocketServer(projectName, ctx, opts = {}) {
-  const path = opts.path ?? defaultSocketPath(projectName);
-  mkdirSync4(dirname5(path), { recursive: true });
-  if (existsSync10(path)) {
-    try {
-      const st = statSync2(path);
-      if (st.isSocket()) unlinkSync(path);
-    } catch {
-    }
-  }
-  const server = createServer((socket) => handleClient(socket, ctx));
-  await new Promise((resolve4, reject) => {
-    server.once("error", reject);
-    server.listen(path, () => {
-      server.off("error", reject);
-      try {
-        chmodSync(path, 384);
-      } catch {
-      }
-      opts.onLog?.(`\u{1F50C} control plane at ${path}`);
-      resolve4();
-    });
-  });
-  return {
-    server,
-    path,
-    async close() {
-      await new Promise((resolve4) => server.close(() => resolve4()));
-      if (existsSync10(path)) {
-        try {
-          unlinkSync(path);
-        } catch {
-        }
-      }
-    }
-  };
-}
-function handleClient(socket, ctx) {
-  const rl = createInterface2({ input: socket });
-  rl.on("line", async (line) => {
-    if (!line.trim()) return;
-    let req;
-    try {
-      req = JSON.parse(line);
-    } catch (e) {
-      respond(socket, { error: { code: -32700, message: `parse error: ${e.message}` } });
+// src/tui/ServiceList.tsx
+import { useState as useState7, useMemo as useMemo2 } 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 allNames = useMemo2(
+    () => [...services.keys()].filter((n) => !filterType || services.get(n).svc.type === filterType),
+    [services, filterType]
+  );
+  const [idx, setIdx] = useState7(0);
+  const [query, setQuery] = useState7("");
+  const names = useMemo2(() => {
+    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) {
+      if (query) setQuery("");
+      else onClose();
       return;
     }
-    if (typeof req.method !== "string") {
-      respond(socket, { id: req.id, error: { code: -32600, message: "method required" } });
+    if (key.return) {
+      if (names[clamped]) onSelect(names[clamped]);
       return;
     }
-    try {
-      const result = await dispatch(req.method, req.params ?? {}, ctx);
-      respond(socket, { id: req.id, result });
-    } catch (e) {
-      respond(socket, { id: req.id, error: { code: -32603, message: e.message ?? String(e) } });
-    }
-  });
-  socket.on("error", () => {
-  });
-}
-function respond(socket, payload) {
-  if (socket.writable) socket.write(JSON.stringify(payload) + "\n");
-}
-async function dispatch(method, params, ctx) {
-  switch (method) {
-    case "status": {
-      const out = [];
-      for (const [name, st] of ctx.states()) {
-        out.push({
-          name,
-          status: st.status,
-          health: st.health,
-          port: st.svc.port,
-          type: st.svc.type,
-          errors: st.errors,
-          restarts: st.restarts,
-          pid: st.pid,
-          startedAt: st.startedAt
-        });
-      }
-      return { services: out };
-    }
-    case "restart": {
-      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
-      await ctx.restart(svc);
-      return { ok: true };
+    if (key.upArrow) {
+      setIdx((i) => Math.max(0, i - 1));
+      return;
     }
-    case "stop": {
-      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
-      ctx.stop(svc);
-      return { ok: true };
+    if (key.downArrow) {
+      setIdx((i) => Math.min(names.length - 1, i + 1));
+      return;
     }
-    case "logs.tail": {
-      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
-      const lines = Math.max(1, Math.min(1e4, Number(params["lines"] ?? 100)));
-      return { lines: await ctx.tailLogs(svc, lines) };
+    if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setIdx(0);
+      return;
     }
-    case "ping":
-      return { ok: true, ts: Date.now() };
-    default:
-      throw new Error(`unknown method: ${method}`);
-  }
-}
-function stringOrThrow(v, paramName) {
-  if (typeof v !== "string" || !v.trim()) {
-    throw new Error(`param "${paramName}" must be a non-empty string`);
-  }
-  return v;
-}
-
-// src/tui/App.tsx
-import { createInterface as createInterface3 } from "readline";
-import { createReadStream as createReadStream2, existsSync as existsSync11, watch as fsWatch } from "fs";
-
-// src/config/diff.ts
-var SPAWN_RELEVANT = [
-  "cwd",
-  "cmd",
-  "args",
-  "port",
-  "phase",
-  "maxMem",
-  "preBuild",
-  "watchBuild",
-  "nodeArgs",
-  "extraEnv",
-  "healthCheck",
-  "readyPattern",
-  "errorPattern",
-  "type"
-];
-function hasSpawnRelevantChange(prev, next) {
-  for (const k of SPAWN_RELEVANT) {
-    if (JSON.stringify(prev[k]) !== JSON.stringify(next[k])) return true;
-  }
-  return false;
-}
-function diffServices(prev, next) {
-  const prevByName = new Map(prev.map((s) => [s.name, s]));
-  const nextByName = new Map(next.map((s) => [s.name, s]));
-  const added = [];
-  const removed = [];
-  const changed = [];
-  const unchanged = [];
-  for (const [name, p] of prevByName) {
-    if (!nextByName.has(name)) {
-      removed.push(name);
-      continue;
+    if (input && !key.ctrl && !key.meta && input.length === 1) {
+      setQuery((q) => q + input);
+      setIdx(0);
     }
-    const n = nextByName.get(name);
-    if (hasSpawnRelevantChange(p, n)) changed.push({ prev: p, next: n });
-    else unchanged.push(name);
-  }
-  for (const [name, n] of nextByName) {
-    if (!prevByName.has(name)) added.push(n);
-  }
-  return { added, removed, changed, unchanged };
+  }, { 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.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: "type to filter  \u2191\u2193 navigate  Enter select  Esc clear/close" })
+  ] });
 }
-function summariseDiff(d) {
-  const parts = [];
-  if (d.added.length) parts.push(`+${d.added.length} added`);
-  if (d.removed.length) parts.push(`-${d.removed.length} removed`);
-  if (d.changed.length) parts.push(`~${d.changed.length} changed`);
-  if (!parts.length) parts.push("no changes");
-  return parts.join(", ");
+
+// src/tui/SearchInput.tsx
+import { useState as useState8 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function SearchInput({ onSubmit, onClose }) {
+  const [value, setValue] = useState8("");
+  useInput3((input, key) => {
+    if (key.escape) onClose();
+    else if (key.return) onSubmit(value.trim() || null);
+    else if (key.backspace || key.delete) setValue((v) => v.slice(0, -1));
+    else if (input && !key.ctrl && !key.meta) setValue((v) => v + input);
+  }, { isActive: process.stdin.isTTY ?? false });
+  return /* @__PURE__ */ jsxs5(Box5, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "yellow", children: "Search: " }),
+    /* @__PURE__ */ jsx5(Text5, { children: value }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2588" })
+  ] });
 }
 
 // src/tui/App.tsx
@@ -2377,26 +3577,13 @@ function buildServiceUrl(name, port, proxyActive, proxyOpts) {
   return `http://localhost:${port}`;
 }
 function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts, logSink }) {
-  const { stdout } = useStdout();
-  const [rows, setRows] = useState6(stdout?.rows ?? 40);
-  useEffect5(() => {
-    if (!stdout) return;
-    const onResize = () => setRows(stdout.rows ?? 40);
-    stdout.on("resize", onResize);
-    return () => {
-      stdout.off("resize", onResize);
-    };
-  }, [stdout]);
+  const rows = useTerminalSize();
   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, logSink);
-  const [booted, setBooted] = useState6(false);
-  const lazyProxies = useRef3(/* @__PURE__ */ new Map());
-  const externals = useRef3([]);
-  const socketServer = useRef3(null);
-  const shownTips = useRef3(/* @__PURE__ */ new Set());
-  const [activeTip, setActiveTip] = useState6(null);
+  const lazyProxies = useRef5(/* @__PURE__ */ new Map());
+  const externals = useRef5([]);
   const kb = useKeyBindings({
     onQuit: () => {
       void shutdown();
@@ -2405,10 +3592,10 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
     onToggleProxy: () => {
     }
   });
+  const socketServer = useControlPlane(pm.manager, config.name, logSink, pm.pushLog, pm.logBus, pm.stateBus);
   const shutdown = useCallback3(async () => {
     lazyProxies.current.forEach((p) => p.destroy());
     await socketServer.current?.close();
-    socketServer.current = null;
     await pm.cleanup();
     if (externals.current.length) {
       await stopExternals(externals.current, platform, {
@@ -2420,236 +3607,22 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
     }
     await logSink?.close();
     process.exit(0);
-  }, [pm, logSink, platform, baseCwd, env]);
-  useEffect5(() => {
-    if (!pm.manager) return;
-    let handle = null;
-    (async () => {
-      try {
-        handle = await startSocketServer(config.name, {
-          states: () => pm.manager.state,
-          restart: (name) => pm.manager.restart(name),
-          stop: (name) => pm.manager.stop(name),
-          tailLogs: async (svcName, lines) => {
-            if (!logSink) return [];
-            const file = logSink.pathFor(svcName);
-            if (!existsSync11(file)) return [];
-            return new Promise((resolve4, reject) => {
-              const buf = [];
-              const rl = createInterface3({ input: createReadStream2(file, { encoding: "utf8" }) });
-              rl.on("line", (l) => {
-                buf.push(l);
-                if (buf.length > lines) buf.shift();
-              });
-              rl.on("close", () => resolve4(buf));
-              rl.on("error", reject);
-            });
-          }
-        }, { onLog: (msg) => pm.pushLog("devup", msg, 12) });
-        socketServer.current = handle;
-      } catch (e) {
-        pm.pushLog("devup", `\u26A0 control plane disabled: ${e.message}`, 5);
-      }
-    })();
-    return () => {
-      void handle?.close();
-    };
-  }, [pm.manager, config.name, logSink]);
-  useEffect5(() => {
-    if (!cliArgs.watchConfig || !pm.manager) return;
-    let watcher = null;
-    let configPath;
-    try {
-      configPath = findConfigFile(baseCwd, cliArgs.configPath);
-    } catch (e) {
-      pm.pushLog("devup", `\u26A0 watch-config disabled: ${e.message}`, 5);
-      return;
-    }
-    pm.pushLog("devup", `\u{1F440} watching ${configPath}`, 12);
-    let reloadInFlight = false;
-    let reloadAgain = false;
-    const reload = async () => {
-      if (reloadInFlight) {
-        reloadAgain = true;
-        return;
-      }
-      reloadInFlight = true;
-      try {
-        const nextCfg = await loadConfig(configPath);
-        const errs = validateConfig(nextCfg, baseCwd);
-        if (errs.length) {
-          pm.pushLog("devup", `\u26A0 config reload failed:
-${formatValidationErrors(errs)}`, 5);
-          return;
-        }
-        const mgr = pm.manager;
-        const currentSvcs = [...mgr.state.values()].map((s) => s.svc);
-        const diff = diffServices(currentSvcs, nextCfg.services);
-        if (!diff.added.length && !diff.removed.length && !diff.changed.length) return;
-        for (const name of diff.removed) {
-          mgr.stop(name);
-          mgr.state.delete(name);
-        }
-        let colorIdx = currentSvcs.length;
-        for (const { next } of diff.changed) {
-          const prev = mgr.state.get(next.name);
-          const ci = prev?.colorIdx ?? colorIdx++;
-          mgr.stop(next.name);
-          await new Promise((r) => setTimeout(r, 800));
-          await mgr.install(next, ci);
-          await mgr.start(next, ci, true);
-        }
-        for (const next of diff.added) {
-          const ci = colorIdx++;
-          await mgr.install(next, ci);
-          await mgr.start(next, ci);
-        }
-        pm.pushLog("devup", `\u{1F501} config reloaded: ${summariseDiff(diff)}`, 12);
-      } catch (e) {
-        pm.pushLog("devup", `\u26A0 config reload error: ${e.message}`, 5);
-      } finally {
-        reloadInFlight = false;
-        if (reloadAgain) {
-          reloadAgain = false;
-          void reload();
-        }
-      }
-    };
-    let debounceTimer = null;
-    watcher = fsWatch(configPath, () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(() => void reload(), 250);
-    });
-    return () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      watcher?.close();
-    };
-  }, [cliArgs.watchConfig, cliArgs.configPath, baseCwd, pm.manager, pm]);
-  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]);
+  }, [pm, logSink, platform, baseCwd, env, socketServer]);
+  useHotReload(pm.manager, cliArgs, baseCwd, pm.pushLog);
+  useLogsPause(pm.setPaused, kb.logsPaused, kb.logsScrollOffset);
+  const activeTip = useContextualTips(pm.logs.length, !!kb.searchTerm, !!kb.logFilter, pm.states);
   useProxySync(proxyProvider, proxyOpts, pm.states, kb.proxyEnabled);
-  useEffect5(() => {
-    if (booted || !pm.manager) return;
-    setBooted(true);
-    const mgr = pm.manager;
-    (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);
-        let colorIdx = 0;
-        for (const num of Object.keys(aoPhases).map(Number).sort((a, b) => a - b)) {
-          const svcs = aoPhases[num];
-          for (const svc of svcs) {
-            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 })));
-          svcs.filter((s) => s.type === "web").forEach((s) => {
-            const st = mgr.state.get(s.name);
-            if (st) st.status = "running";
-          });
-        }
-        for (const svc of lazy) {
-          const ci = colorIdx++;
-          const rewritten = rewriteServicePort(svc);
-          const idleState = {
-            svc: rewritten,
-            proc: null,
-            pid: null,
-            status: "idle",
-            health: "idle",
-            errors: 0,
-            restarts: 0,
-            startedAt: null,
-            intentionalStop: false,
-            colorIdx: ci
-          };
-          mgr.state.set(svc.name, idleState);
-          const proxy = createLazyProxy({
-            listenPort: svc.port,
-            targetPort: rewritten.realPort,
-            timeoutMin: lazyTimeout,
-            onDemandStart: async () => {
-              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);
-              if (st) {
-                st.status = ok ? "running" : "timeout";
-                if (ok) st.health = "up";
-              }
-            },
-            onIdleStop: () => {
-              mgr.stop(svc.name);
-              const st = mgr.state.get(svc.name);
-              if (st) {
-                st.status = "idle";
-                st.health = "idle";
-                st.pid = null;
-                st.proc = null;
-                st.startedAt = null;
-              }
-            },
-            isAlive: () => {
-              const st = mgr.state.get(svc.name);
-              return !!st && !!st.proc && !st.proc.killed && st.health === "up";
-            }
-          });
-          lazyProxies.current.set(svc.name, proxy);
-        }
-      } else {
-        const phases = groupByPhase(services);
-        let colorIdx = 0;
-        for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
-          const svcs = phases[num];
-          for (const svc of svcs) {
-            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 })));
-          svcs.filter((s) => s.type === "web").forEach((s) => {
-            const st = mgr.state.get(s.name);
-            if (st) st.status = "running";
-          });
-        }
-      }
-    })();
-  }, [booted, pm.manager, services, cliArgs, config.lazy]);
+  useBootSequence(
+    pm.manager,
+    config,
+    services,
+    cliArgs,
+    platform,
+    env,
+    baseCwd,
+    { lazyProxies, externals },
+    pm.pushLog
+  );
   const handleFilterSelect = useCallback3((name) => kb.setFilter(name), [kb]);
   const handleRestartSelect = useCallback3((name) => {
     pm.restart(name);
@@ -2722,61 +3695,6 @@ ${formatValidationErrors(errs)}`, 5);
   ] });
 }
 
-// src/process/log-sink.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, renameSync, createWriteStream } from "fs";
-import { join as join7, dirname as dirname6 } from "path";
-import { homedir as homedir3 } from "os";
-var LogSink = class {
-  dir;
-  rotateOnStart;
-  streams = /* @__PURE__ */ new Map();
-  seen = /* @__PURE__ */ new Set();
-  constructor(opts) {
-    const root = opts.rootDir ?? join7(homedir3(), ".devup", "logs");
-    this.dir = join7(root, sanitize2(opts.projectName));
-    this.rotateOnStart = opts.rotateOnStart ?? true;
-    mkdirSync5(this.dir, { recursive: true });
-  }
-  /** Returns the file path for a service log (useful for tests / UI). */
-  pathFor(svcName) {
-    return join7(this.dir, `${sanitize2(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) && existsSync12(file)) {
-      try {
-        mkdirSync5(dirname6(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 sanitize2(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;
@@ -2947,8 +3865,8 @@ function defineConfig(config) {
 function readVersion() {
   try {
     const here = dirname7(fileURLToPath2(import.meta.url));
-    const pkgPath = join8(here, "..", "package.json");
-    return JSON.parse(readFileSync2(pkgPath, "utf8")).version ?? "unknown";
+    const pkgPath = join10(here, "..", "package.json");
+    return JSON.parse(readFileSync4(pkgPath, "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -2983,6 +3901,8 @@ async function main() {
     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));
+    if (subcmd === "ctl") process.exit(await runCtl(subArgs, subOpts));
+    if (subcmd === "down") process.exit(await runDown(subOpts));
   }
   let configPath;
   try {
@@ -3015,7 +3935,7 @@ ${formatValidationWarnings(warnings)}`);
     process.exit(1);
   }
   const platform = await detectPlatform();
-  const envFile = config.envFile ? join8(cwd, config.envFile) : join8(cwd, ".env");
+  const envFile = config.envFile ? join10(cwd, config.envFile) : join10(cwd, ".env");
   const env = parseEnvFile(envFile, process.env);
   if (config.env) {
     for (const [k, v] of Object.entries(config.env)) {
@@ -3032,7 +3952,7 @@ ${formatValidationWarnings(warnings)}`);
       routes: config.proxy.routes,
       tls: cliArgs.proxyTls ?? config.proxy.tls ?? true,
       entrypoint: cliArgs.proxyEntrypoint ?? config.proxy.entrypoint ?? "websecure",
-      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join8(homedir4(), ".traefik", "traefik_conf.yaml")
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join10(homedir5(), ".traefik", "traefik_conf.yaml")
     };
   }
   if (cliArgs.dryRun) {
@@ -3056,6 +3976,26 @@ ${formatValidationWarnings(warnings)}`);
     await logSink?.close();
     process.exit(code);
   }
+  if (process.env.DEVUP_DAEMON_CHILD === "1") {
+    await daemonBody({ config, services, cliArgs, platform, env, baseCwd: cwd, proxyProvider, proxyOpts });
+    return;
+  }
+  if (subcmd === "up") {
+    if (!raw.includes("-d") && !raw.includes("--detach")) {
+      console.error("usage: devup up -d  (use plain `devup` for the TUI)");
+      process.exit(1);
+    }
+    process.exit(await runDetached({
+      config,
+      services,
+      cliArgs,
+      platform,
+      env,
+      baseCwd: cwd,
+      proxyProvider,
+      proxyOpts
+    }));
+  }
   const isInteractive = process.stdin.isTTY ?? false;
   const { waitUntilExit } = render(
     React7.createElement(App, {