@gachlab/devup 0.7.1 → 0.8.1

package/dist/index.js

@@ -3,10 +3,10 @@
 // src/index.ts
 import React7 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname7, join as join9 } 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 existsSync5, 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";
@@ -459,6 +459,23 @@ function checkPort(port, host = "127.0.0.1", timeoutMs = 2e3) {
     socket.connect(port, host);
   });
 }
+async function isPortBindable(port) {
+  for (const host of ["0.0.0.0", "::"]) {
+    if (!await tryBind(port, host)) return false;
+  }
+  return true;
+}
+function tryBind(port, host) {
+  return new Promise((resolve4) => {
+    const server = net.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE" || err.code === "EACCES") resolve4(false);
+      else resolve4(true);
+    });
+    server.once("listening", () => server.close(() => resolve4(true)));
+    server.listen(port, host);
+  });
+}
 function checkHttp(port, opts = {}) {
   const path = opts.path ?? "/";
   const host = opts.host ?? "127.0.0.1";
@@ -668,386 +685,287 @@ 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;
+// 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`);
 }
-function logRoot(config, override) {
-  const root = override ?? join3(homedir(), ".devup", "logs");
-  return join3(root, sanitize(config.name));
+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 {
+    }
+  }
+  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 (existsSync5(path)) {
+        try {
+          unlinkSync(path);
+        } catch {
+        }
+      }
+    }
+  };
 }
-function sanitize(name) {
-  return name.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "devup";
+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) } });
+      }
+      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) } });
+    }
+  });
+  socket.on("error", () => {
+  });
 }
-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;
+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);
   }
-  const knownSvcs = opts.config.services.map((s) => s.name);
-  if (!knownSvcs.includes(svcArg)) {
-    out(`Unknown service "${svcArg}". Known: ${knownSvcs.join(", ")}`);
-    return 1;
+}
+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 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(serializeState(name, st));
+      }
+      return { services: out };
+    }
+    case "restart": {
+      const svc = stringOrThrow(params["svc"] ?? params["service"], "svc");
+      await ctx.restart(svc);
+      return { ok: true };
+    }
+    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(`unknown method: ${method}`);
   }
-  const file = join3(logRoot(opts.config, opts.logDir), `${sanitize(svcArg)}.log`);
-  if (!existsSync5(file)) {
-    out(`No log file yet for "${svcArg}" (${file})`);
-    return follow ? await followFile(file, out) : 1;
+}
+function stringOrThrow(v, paramName) {
+  if (typeof v !== "string" || !v.trim()) {
+    throw new Error(`param "${paramName}" must be a non-empty string`);
   }
-  await streamFile(file, out);
-  if (!follow) return 0;
-  return await followFile(file, out, statSync(file).size);
+  return v;
 }
-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);
-  });
+
+// src/control-plane/client.ts
+function resolveSocket(projectName, overridePath) {
+  return overridePath ?? defaultSocketPath(projectName);
 }
-async function followFile(file, out, startAt = 0) {
-  let pos = startAt;
-  while (!existsSync5(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;
+function assertSocketExists(socketPath, projectName) {
+  if (!existsSync6(socketPath)) {
+    throw new Error(
+      `devup is not running for project "${projectName}".
+Start it with \`devup\` first.`
+    );
+  }
+}
+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);
       }
-    };
-    watchFile(file, { interval: 500 }, () => {
-      void tick();
-    });
-    process.once("SIGINT", () => {
-      unwatchFile(file);
-      resolve4(0);
     });
+    c.write(JSON.stringify({ id: 1, method, params }) + "\n");
   });
 }
-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 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;
       }
-    };
-    pump();
+      if (msg.event) onFrame(msg);
+    } catch {
+    }
   });
-  if (failed.length) {
-    out(`
-failed: ${failed.join(", ")}`);
-    return 1;
-  }
-  out(`
-${items.length} services up to date`);
-  return 0;
+  return () => c.destroy();
 }
-function installOne(cwd, env) {
-  if (!existsSync5(cwd)) return Promise.resolve(false);
-  if (!needsInstall(cwd)) return Promise.resolve(true);
+
+// 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 { join as join5 } from "path";
+
+// src/process/installer.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+function installService(cwd, env, onLog) {
+  if (!existsSync7(cwd)) {
+    onLog?.(`\u26A0 directory not found: ${cwd}`);
+    return Promise.resolve(false);
+  }
+  if (!needsInstall(cwd)) {
+    onLog?.("\u2705 dependencies up to date");
+    return Promise.resolve(true);
+  }
+  onLog?.("\u{1F4E6} npm install...");
   return new Promise((resolve4) => {
     const command = process.platform === "win32" ? "npm.cmd" : "npm";
     const proc = spawn(command, ["install"], { cwd, env, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
     proc.on("close", (code) => {
-      if (code === 0) {
+      if (code !== 0) {
+        onLog?.(`\u26A0 npm install failed: ${stderr.split("\n")[0]}`);
+        resolve4(false);
+      } else {
         writeInstallStamp(cwd);
+        onLog?.("\u2705 dependencies ready");
         resolve4(true);
-      } else resolve4(false);
-    });
-    proc.on("error", () => resolve4(false));
-  });
-}
-async function runStatus(opts) {
-  const out = opts.out ?? ((l) => console.log(l));
-  out(`${opts.config.icon ?? "\u{1F4E6}"} ${opts.config.name} \u2014 ${opts.config.services.length} services`);
-  out("");
-  const maxLen = Math.max(...opts.config.services.map((s) => s.name.length), 12);
-  out(`${"Service".padEnd(maxLen)}  ${"Port".padStart(5)}  ${"Type".padEnd(4)}  Health`);
-  out("-".repeat(maxLen + 24));
-  for (const svc of opts.config.services) {
-    const up = await checkHealth(svc.port, svc.healthCheck);
-    const health = up ? "\u2713 up" : "\u2717 down";
-    out(`${svc.name.padEnd(maxLen)}  ${String(svc.port).padStart(5)}  ${svc.type.padEnd(4)}  ${health}`);
-  }
-  return 0;
-}
-function runHelp(argv, opts = {}) {
-  const out = opts.out ?? ((l) => console.log(l));
-  const sub = argv[0];
-  if (sub === "logs") {
-    out("Usage: devup logs <service> [--follow|-f]");
-    out("  Print the persisted log file for a service (works without devup running).");
-    out("  --follow tails new lines as they are appended.");
-    return 0;
-  }
-  if (sub === "install") {
-    out("Usage: devup install");
-    out("  Run `npm install` across every service.cwd in parallel (max 4 at a time).");
-    out("  Skips services whose .install-stamp matches package.json hash.");
-    return 0;
-  }
-  if (sub === "status") {
-    out("Usage: devup status");
-    out("  For each service, probes its health-check endpoint and prints up/down.");
-    return 0;
-  }
-  out("Subcommands:");
-  out("  devup logs <service> [--follow]   Read the persisted log file");
-  out("  devup install                     Concurrent npm install across services");
-  out("  devup status                      Health check every service in config");
-  out("  devup help [<subcommand>]         Show detailed help for a subcommand");
-  out("");
-  out("No subcommand \u2192 launch the interactive TUI.");
-  return 0;
-}
-
-// src/platform/detect.ts
-async function detectPlatform() {
-  switch (process.platform) {
-    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 existsSync6, 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 (!existsSync6(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync2(opts.confPath, content);
-  }
-  clear(opts) {
-    this.write(EMPTY_CONFIG, opts);
-  }
-};
-
-// src/proxy-config/nginx.ts
-import { existsSync as existsSync7, 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 (!existsSync7(dir)) mkdirSync2(dir, { recursive: true });
-    writeFileSync3(opts.confPath, content);
-  }
-  clear(opts) {
-    this.write(EMPTY_CONFIG2, opts);
-  }
-};
-
-// src/proxy-config/caddy.ts
-import { existsSync as existsSync8, 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}
-}`
-      );
-    }
-    if (!blocks.length) return EMPTY_CONFIG3;
-    return blocks.join("\n\n") + "\n";
-  }
-  write(content, opts) {
-    const dir = dirname4(opts.confPath);
-    if (!existsSync8(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();
-}
-
-// 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";
-
-// src/process/manager.ts
-import { join as join5 } from "path";
-
-// src/process/installer.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-function installService(cwd, env, onLog) {
-  if (!existsSync9(cwd)) {
-    onLog?.(`\u26A0 directory not found: ${cwd}`);
-    return Promise.resolve(false);
-  }
-  if (!needsInstall(cwd)) {
-    onLog?.("\u2705 dependencies up to date");
-    return Promise.resolve(true);
-  }
-  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"] });
-    let stderr = "";
-    proc.stderr?.on("data", (d) => {
-      stderr += d.toString();
-    });
-    proc.on("close", (code) => {
-      if (code !== 0) {
-        onLog?.(`\u26A0 npm install failed: ${stderr.split("\n")[0]}`);
-        resolve4(false);
-      } else {
-        writeInstallStamp(cwd);
-        onLog?.("\u2705 dependencies ready");
-        resolve4(true);
-      }
-    });
-    proc.on("error", (err) => {
-      onLog?.(`\u26A0 spawn error: ${err.message}`);
-      resolve4(false);
+      }
+    });
+    proc.on("error", (err) => {
+      onLog?.(`\u26A0 spawn error: ${err.message}`);
+      resolve4(false);
     });
   });
 }
 
 // src/process/spawner.ts
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+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
@@ -1125,9 +1043,10 @@ var Spawner = class {
   async start(svc, colorIdx, isRestart = false) {
     const cwd = join4(this.baseCwd, svc.cwd);
     if (svc.type === "api") {
-      const occupied = await checkPort(svc.port);
-      if (occupied && !isRestart) {
+      const bindable = await isPortBindable(svc.port);
+      if (!bindable && !isRestart) {
         this.log(svc.name, `\u26A0 port ${svc.port} already in use \u2014 skipping`, colorIdx);
+        this.recordCrashedState(svc, colorIdx);
         return;
       }
     }
@@ -1139,14 +1058,14 @@ var Spawner = class {
       }
     }
     const args = buildProcessArgs(svc);
-    const missingWatchPaths = extractWatchPaths(args).filter((p) => !existsSync10(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,
@@ -1224,7 +1143,7 @@ var Spawner = class {
       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));
@@ -1251,7 +1170,7 @@ var Spawner = 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,
@@ -1487,25 +1406,1317 @@ var ProcessManager = class {
   }
 };
 
-// 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: {
+// 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", () => {
+    });
+    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 {
+      }
+    }
+  }
+};
+
+// 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;
+    }
+    if (svc.healthCheck.type === "tcp" && !svc.port) {
+      opts.onLog?.(svc.name, "\u26A0 tcp healthCheck requires `port` \u2014 skipping wait");
+      continue;
+    }
+    const timeoutMs = (svc.startTimeout ?? DEFAULT_START_TIMEOUT_S) * 1e3;
+    const ok = await waitHealthy(svc, timeoutMs);
+    if (ok) {
+      opts.onLog?.(svc.name, "\u2705 healthy");
+    } else {
+      opts.onLog?.(svc.name, `\u274C never became healthy (timeout ${timeoutMs / 1e3}s)`);
+      failed.push(svc.name);
+    }
+  }
+  return { procs, allHealthy: failed.length === 0, failed };
+}
+async function stopExternals(procs, platform, opts = {}) {
+  for (const { svc, proc, pid } of procs) {
+    try {
+      if (pid) platform.killTree(pid);
+      if (svc.stopCmd) {
+        opts.onLog?.(svc.name, `\u{1F9F9} ${svc.stopCmd}`);
+        await new Promise((resolve4) => {
+          const isWin = process.platform === "win32";
+          const shell = isWin ? "cmd.exe" : "sh";
+          const flag = isWin ? "/c" : "-c";
+          const cwd = svc.cwd ? 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 {
+    }
+    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 ? 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"]
+  });
+  child.stdout?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.stderr?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.on("error", (err) => opts.onLog?.(svc.name, `\u274C spawn error: ${err.message}`));
+  return child;
+}
+async function waitHealthy(svc, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const port = svc.port;
+  while (Date.now() < deadline) {
+    if (await checkHealth(port, svc.healthCheck)) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+// src/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);
+    }
+  }
+  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/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 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);
+  }
+  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);
@@ -1519,7 +2730,10 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
             return next.length > 5e3 ? next.slice(-5e3) : next;
           });
         },
-        onStateChange: () => setStates(new Map(mgr2.state))
+        onStateChange: (name, state) => {
+          stateBus.current.emit({ name, state });
+          setStates(new Map(mgr2.state));
+        }
       }
     });
     mgrRef.current = mgr2;
@@ -1564,6 +2778,7 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
   }, []);
   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);
@@ -1600,7 +2815,9 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
     clearLogs,
     setPaused,
     pushLog,
-    manager: mgr
+    manager: mgr,
+    logBus: logBus.current,
+    stateBus: stateBus.current
   };
 }
 
@@ -1739,134 +2956,9 @@ function useLogsPause(setPaused, logsPaused, logsScrollOffset) {
 
 // src/tui/hooks/useControlPlane.ts
 import { useEffect as useEffect5, useRef as useRef3 } from "react";
-import { createInterface as createInterface3 } from "readline";
-import { createReadStream as createReadStream2, existsSync as existsSync12 } from "fs";
-
-// src/control-plane/socket-server.ts
-import { createServer } from "net";
-import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync11, 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 (existsSync11(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 (existsSync11(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}` } });
-      return;
-    }
-    if (typeof req.method !== "string") {
-      respond(socket, { id: req.id, error: { code: -32600, message: "method required" } });
-      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 };
-    }
-    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(`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/hooks/useControlPlane.ts
-function useControlPlane(manager, projectName, logSink, pushLog) {
+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;
@@ -1880,10 +2972,10 @@ function useControlPlane(manager, projectName, logSink, pushLog) {
           tailLogs: async (svcName, lines) => {
             if (!logSink) return [];
             const file = logSink.pathFor(svcName);
-            if (!existsSync12(file)) return [];
+            if (!existsSync15(file)) return [];
             return new Promise((resolve4, reject) => {
               const buf = [];
-              const rl = createInterface3({ input: createReadStream2(file, { encoding: "utf8" }) });
+              const rl = createInterface5({ input: createReadStream3(file, { encoding: "utf8" }) });
               rl.on("line", (l) => {
                 buf.push(l);
                 if (buf.length > lines) buf.shift();
@@ -1891,6 +2983,14 @@ function useControlPlane(manager, projectName, logSink, pushLog) {
               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;
@@ -1902,72 +3002,15 @@ function useControlPlane(manager, projectName, logSink, pushLog) {
       void handle?.close();
       handleRef.current = null;
     };
-  }, [manager, projectName, logSink, pushLog]);
+  }, [manager, projectName, logSink, pushLog, logBus, stateBus]);
   return handleRef;
 }
 
 // src/tui/hooks/useHotReload.ts
 import { useEffect as useEffect6 } from "react";
-import { 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;
-    }
-    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 };
-}
-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/hooks/useHotReload.ts
 function useHotReload(manager, cliArgs, baseCwd, pushLog) {
   useEffect6(() => {
     if (!cliArgs.watchConfig || !manager) return;
-    let watcher = null;
     let configPath;
     try {
       configPath = findConfigFile(baseCwd, cliArgs.configPath);
@@ -1975,64 +3018,13 @@ function useHotReload(manager, cliArgs, baseCwd, pushLog) {
       pushLog("devup", `\u26A0 watch-config disabled: ${e.message}`, 5);
       return;
     }
-    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) {
-          pushLog("devup", `\u26A0 config reload failed:
-${formatValidationErrors(errs)}`, 5);
-          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);
-        }
-        pushLog("devup", `\u{1F501} config reloaded: ${summariseDiff(diff)}`, 12);
-      } catch (e) {
-        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);
+    pushLog("devup", `\u{1F440} watching ${configPath}`, 12);
+    return watchConfig({
+      configPath,
+      baseCwd,
+      manager,
+      log: (msg) => pushLog("devup", msg, msg.startsWith("\u26A0") ? 5 : 12)
     });
-    return () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      watcher?.close();
-    };
   }, [cliArgs.watchConfig, cliArgs.configPath, baseCwd, manager, pushLog]);
 }
 
@@ -2289,201 +3281,6 @@ function useContextualTips(totalLogs, hasSearch, hasFilter, states) {
 
 // src/tui/hooks/useBootSequence.ts
 import { useEffect as useEffect9, useState as useState6 } from "react";
-
-// 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);
-    }
-  }
-  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/process/external.ts
-import { spawn as spawn4 } 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;
-    }
-    if (svc.healthCheck.type === "tcp" && !svc.port) {
-      opts.onLog?.(svc.name, "\u26A0 tcp healthCheck requires `port` \u2014 skipping wait");
-      continue;
-    }
-    const timeoutMs = (svc.startTimeout ?? DEFAULT_START_TIMEOUT_S) * 1e3;
-    const ok = await waitHealthy(svc, timeoutMs);
-    if (ok) {
-      opts.onLog?.(svc.name, "\u2705 healthy");
-    } else {
-      opts.onLog?.(svc.name, `\u274C never became healthy (timeout ${timeoutMs / 1e3}s)`);
-      failed.push(svc.name);
-    }
-  }
-  return { procs, allHealthy: failed.length === 0, failed };
-}
-async function stopExternals(procs, platform, opts = {}) {
-  for (const { svc, proc, pid } of procs) {
-    try {
-      if (pid) platform.killTree(pid);
-      if (svc.stopCmd) {
-        opts.onLog?.(svc.name, `\u{1F9F9} ${svc.stopCmd}`);
-        await new Promise((resolve4) => {
-          const isWin = process.platform === "win32";
-          const shell = isWin ? "cmd.exe" : "sh";
-          const flag = isWin ? "/c" : "-c";
-          const cwd = svc.cwd ? join7(opts.baseCwd, svc.cwd) : opts.baseCwd;
-          const env = { ...opts.env, ...svc.extraEnv ?? {} };
-          const child = spawn4(shell, [flag, svc.stopCmd], { cwd, env, stdio: "ignore" });
-          child.on("close", () => resolve4());
-          child.on("error", () => resolve4());
-          setTimeout(() => resolve4(), 1e4);
-        });
-      }
-    } catch {
-    }
-    void proc;
-  }
-}
-function spawnExternal(svc, opts) {
-  const isWin = process.platform === "win32";
-  const shell = isWin ? "cmd.exe" : "sh";
-  const flag = isWin ? "/c" : "-c";
-  const cwd = svc.cwd ? join7(opts.baseCwd, svc.cwd) : opts.baseCwd;
-  const env = { ...opts.env, ...svc.extraEnv ?? {} };
-  opts.onLog?.(svc.name, `\u{1F680} ${svc.cmd}`);
-  const child = spawn4(shell, [flag, svc.cmd], {
-    cwd,
-    env,
-    detached: true,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  child.stdout?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
-  child.stderr?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
-  child.on("error", (err) => opts.onLog?.(svc.name, `\u274C spawn error: ${err.message}`));
-  return child;
-}
-async function waitHealthy(svc, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  const port = svc.port;
-  while (Date.now() < deadline) {
-    if (await checkHealth(port, svc.healthCheck)) return true;
-    await new Promise((r) => setTimeout(r, 500));
-  }
-  return false;
-}
-
-// src/tui/hooks/useBootSequence.ts
 function useBootSequence(manager, config, services, cliArgs, platform, env, baseCwd, refs, pushLog) {
   const [booted, setBooted] = useState6(false);
   useEffect9(() => {
@@ -2813,7 +3610,7 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
     onToggleProxy: () => {
     }
   });
-  const socketServer = useControlPlane(pm.manager, config.name, logSink, pm.pushLog);
+  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();
@@ -2916,61 +3713,6 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   ] });
 }
 
-// src/process/log-sink.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, renameSync, createWriteStream } from "fs";
-import { join as join8, 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 ?? join8(homedir3(), ".devup", "logs");
-    this.dir = join8(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 join8(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) && existsSync13(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;
@@ -3141,8 +3883,8 @@ function defineConfig(config) {
 function readVersion() {
   try {
     const here = dirname7(fileURLToPath2(import.meta.url));
-    const pkgPath = join9(here, "..", "package.json");
-    return JSON.parse(readFileSync3(pkgPath, "utf8")).version ?? "unknown";
+    const pkgPath = join10(here, "..", "package.json");
+    return JSON.parse(readFileSync4(pkgPath, "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -3177,6 +3919,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 {
@@ -3209,7 +3953,7 @@ ${formatValidationWarnings(warnings)}`);
     process.exit(1);
   }
   const platform = await detectPlatform();
-  const envFile = config.envFile ? join9(cwd, config.envFile) : join9(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)) {
@@ -3226,7 +3970,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 ?? join9(homedir4(), ".traefik", "traefik_conf.yaml")
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join10(homedir5(), ".traefik", "traefik_conf.yaml")
     };
   }
   if (cliArgs.dryRun) {
@@ -3250,6 +3994,36 @@ ${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 daemonStatus = isDaemonRunning(config.name);
+  if (daemonStatus.pid && !daemonStatus.stale) {
+    console.error(`\u274C A devup daemon is already running for "${config.name}" (pid=${daemonStatus.pid}).`);
+    console.error("");
+    console.error("Stop it first with `devup down`, or interact via the control plane:");
+    console.error("  devup ctl status");
+    console.error("  devup ctl logs <svc> --follow");
+    console.error("  devup ctl restart <svc>");
+    process.exit(1);
+  }
   const isInteractive = process.stdin.isTTY ?? false;
   const { waitUntilExit } = render(
     React7.createElement(App, {