@gachlab/devup 0.1.0

package/dist/index.js

@@ -0,0 +1,1336 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import React4 from "react";
+import { render } from "ink";
+import { join as join4 } from "path";
+import { homedir } from "os";
+
+// src/config/loader.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { resolve, join } from "path";
+import { pathToFileURL } from "url";
+var CONFIG_NAMES = [
+  "devup.config.ts",
+  "devup.config.js",
+  "devup.config.json"
+];
+function findConfigFile(cwd, explicit) {
+  if (explicit) {
+    const full = resolve(cwd, explicit);
+    if (!existsSync(full)) throw new Error(`Config not found: ${full}`);
+    return full;
+  }
+  for (const name of CONFIG_NAMES) {
+    const full = join(cwd, name);
+    if (existsSync(full)) return full;
+  }
+  throw new Error(
+    `No config found. Create one of: ${CONFIG_NAMES.join(", ")}
+Or use --config <path>`
+  );
+}
+async function loadConfig(configPath) {
+  if (configPath.endsWith(".json")) {
+    const raw = await readFile(configPath, "utf8");
+    return JSON.parse(raw);
+  }
+  const url = pathToFileURL(configPath).href;
+  const mod = await import(url);
+  const config = mod.default ?? mod;
+  if (!config || typeof config !== "object" || !Array.isArray(config.services)) {
+    throw new Error(`Invalid config: must export a DevStackConfig (use defineConfig() from @gachlab/devup)`);
+  }
+  return config;
+}
+
+// src/config/validator.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function validateConfig(config, cwd) {
+  const errors = [];
+  if (!config.name?.trim()) {
+    errors.push({ field: "name", message: "Project name is required" });
+  }
+  if (!config.services?.length) {
+    errors.push({ field: "services", message: "At least one service is required" });
+    return errors;
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const svc of config.services) {
+    if (names.has(svc.name)) {
+      errors.push({ field: `services[${svc.name}].name`, message: `Duplicate service name: ${svc.name}` });
+    }
+    names.add(svc.name);
+  }
+  const ports = /* @__PURE__ */ new Map();
+  for (const svc of config.services) {
+    const existing = ports.get(svc.port);
+    if (existing) {
+      errors.push({ field: `services[${svc.name}].port`, message: `Port ${svc.port} already used by ${existing}` });
+    }
+    ports.set(svc.port, svc.name);
+  }
+  for (const svc of config.services) {
+    if (!svc.name?.trim()) errors.push({ field: "services[].name", message: "Service name is required" });
+    if (!svc.cwd?.trim()) errors.push({ field: `services[${svc.name}].cwd`, message: "cwd is required" });
+    if (!svc.cmd?.trim()) errors.push({ field: `services[${svc.name}].cmd`, message: "cmd is required" });
+    if (!svc.type || !["api", "web"].includes(svc.type)) {
+      errors.push({ field: `services[${svc.name}].type`, message: `Invalid type: ${svc.type} (must be "api" or "web")` });
+    }
+    if (typeof svc.port !== "number" || svc.port <= 0) {
+      errors.push({ field: `services[${svc.name}].port`, message: `Invalid port: ${svc.port}` });
+    }
+    if (typeof svc.phase !== "number" || svc.phase < 0) {
+      errors.push({ field: `services[${svc.name}].phase`, message: `Invalid phase: ${svc.phase}` });
+    }
+    if (svc.cwd && !existsSync2(resolve2(cwd, svc.cwd))) {
+      errors.push({ field: `services[${svc.name}].cwd`, message: `Directory not found: ${svc.cwd}` });
+    }
+  }
+  if (config.lazy?.alwaysOn) {
+    for (const ref of config.lazy.alwaysOn) {
+      if (!names.has(ref)) {
+        errors.push({ field: `lazy.alwaysOn`, message: `Unknown service: ${ref}` });
+      }
+    }
+  }
+  if (config.proxy?.routes) {
+    for (const ref of Object.keys(config.proxy.routes)) {
+      if (!names.has(ref)) {
+        errors.push({ field: `proxy.routes`, message: `Unknown service: ${ref}` });
+      }
+    }
+  }
+  return errors;
+}
+function formatValidationErrors(errors) {
+  return errors.map((e) => `  \u2717 ${e.field}: ${e.message}`).join("\n");
+}
+
+// src/config/cli.ts
+var DEFAULT_LAZY_TIMEOUT = 10;
+function parseCliArgs(argv) {
+  const args = {
+    skip: [],
+    lazy: true,
+    lazyTimeout: DEFAULT_LAZY_TIMEOUT,
+    proxy: false,
+    proxyTls: true,
+    proxyEntrypoint: "websecure"
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--config":
+        args.configPath = next;
+        i++;
+        break;
+      case "--only":
+        args.only = next;
+        i++;
+        break;
+      case "--skip":
+        args.skip = next?.split(",") ?? [];
+        i++;
+        break;
+      case "--services":
+        args.services = next?.split(",");
+        i++;
+        break;
+      case "--lazy":
+        args.lazy = true;
+        break;
+      case "--no-lazy":
+        args.lazy = false;
+        break;
+      case "--timeout":
+        args.lazyTimeout = parseInt(next ?? "", 10) || DEFAULT_LAZY_TIMEOUT;
+        i++;
+        break;
+      case "--proxy":
+        args.proxy = true;
+        break;
+      case "--proxy-host":
+        args.proxyHost = next;
+        i++;
+        break;
+      case "--proxy-conf":
+        args.proxyConf = next;
+        i++;
+        break;
+      case "--proxy-tls":
+        args.proxyTls = true;
+        break;
+      case "--no-proxy-tls":
+        args.proxyTls = false;
+        break;
+      case "--proxy-entrypoint":
+        args.proxyEntrypoint = next ?? "websecure";
+        i++;
+        break;
+    }
+  }
+  return args;
+}
+function filterServices(services, args) {
+  let result = services;
+  if (args.services) {
+    const explicit = new Set(args.services);
+    result = result.filter((s) => explicit.has(s.name));
+  } else if (args.only) {
+    switch (args.only) {
+      case "apis":
+        result = result.filter((s) => s.type === "api");
+        break;
+      case "webs":
+        result = result.filter((s) => s.type === "web");
+        break;
+      default:
+        result = result.filter((s) => s.name.startsWith(args.only));
+        break;
+    }
+  }
+  if (args.skip.length) {
+    const skipSet = new Set(args.skip);
+    result = result.filter((s) => !skipSet.has(s.name));
+  }
+  return result;
+}
+
+// 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 existsSync3, mkdirSync, writeFileSync } from "fs";
+import { dirname } 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 = dirname(opts.confPath);
+    if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(opts.confPath, content);
+  }
+  clear(opts) {
+    this.write(EMPTY_CONFIG, opts);
+  }
+};
+
+// src/proxy-config/detect.ts
+var providers = {
+  traefik: () => new TraefikProvider()
+};
+function detectProxyProvider(name) {
+  const factory = providers[name];
+  if (!factory) {
+    const available = Object.keys(providers).join(", ");
+    throw new Error(`Unknown proxy provider: "${name}". Available: ${available}`);
+  }
+  return factory();
+}
+
+// src/utils.ts
+import { existsSync as existsSync4, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { createHash } from "crypto";
+import { join as join2 } from "path";
+function parseEnvFile(filePath, baseEnv = {}) {
+  const env = { ...baseEnv };
+  if (!existsSync4(filePath)) return env;
+  for (const line of readFileSync(filePath, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    if (!env[key]) env[key] = val;
+  }
+  return env;
+}
+function fmtUptime(ms) {
+  if (!ms || ms < 0) return "-";
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60}m`;
+}
+function needsInstall(fullCwd) {
+  const nm = join2(fullCwd, "node_modules");
+  if (!existsSync4(nm)) return true;
+  try {
+    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    const stampFile = join2(nm, ".install-stamp");
+    if (existsSync4(stampFile) && readFileSync(stampFile, "utf8") === pkgHash) return false;
+  } catch {
+  }
+  return true;
+}
+function writeInstallStamp(fullCwd) {
+  try {
+    const pkgHash = createHash("md5").update(readFileSync(join2(fullCwd, "package.json"))).digest("hex");
+    writeFileSync2(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
+  } catch {
+  }
+}
+function sortServiceNames(names, sortMode, statsMap, procState) {
+  if (sortMode === "name") return names.slice().sort();
+  return names.slice().sort((a, b) => {
+    if (sortMode === "mem") {
+      return (parseFloat(statsMap[b]?.mem ?? "0") || 0) - (parseFloat(statsMap[a]?.mem ?? "0") || 0);
+    }
+    return (procState[b]?.errors ?? 0) - (procState[a]?.errors ?? 0);
+  });
+}
+function groupByPhase(services) {
+  const phases = {};
+  for (const s of services) {
+    (phases[s.phase] ??= []).push(s);
+  }
+  return phases;
+}
+function buildProcessArgs(svc) {
+  const extra = svc.nodeArgs ?? [];
+  if (!svc.maxMem) return [...extra, ...svc.args];
+  if (svc.cmd === "node") return [`--max-old-space-size=${svc.maxMem}`, ...extra, ...svc.args];
+  return [...extra, ...svc.args];
+}
+function buildProcessEnv(svc, baseEnv) {
+  const env = { ...baseEnv, ...svc.extraEnv ?? {} };
+  if (svc.maxMem && svc.cmd !== "node") {
+    const existing = env["NODE_OPTIONS"] ?? "";
+    const flag = `--max-old-space-size=${svc.maxMem}`;
+    if (!existing.includes("max-old-space-size")) {
+      env["NODE_OPTIONS"] = existing ? `${existing} ${flag}` : flag;
+    }
+  }
+  return env;
+}
+function calcCpuPercent(totalCpuSec, prevCpu, prevTime) {
+  const elapsed = (Date.now() - prevTime) / 1e3;
+  const cpuDelta = totalCpuSec - prevCpu;
+  return elapsed > 0 ? cpuDelta / elapsed * 100 : 0;
+}
+var tagColors = [
+  "cyan",
+  "yellow",
+  "green",
+  "magenta",
+  "blue",
+  "red",
+  "#5faf5f",
+  "#d7af5f",
+  "#5f87d7",
+  "#af5faf",
+  "#5fd7d7",
+  "#d75f5f",
+  "white"
+];
+
+// src/tui/App.tsx
+import { useEffect as useEffect3, useState as useState5, useCallback as useCallback3, useRef as useRef3 } from "react";
+import { Box as Box6, Text as Text6, useStdout } from "ink";
+
+// src/tui/hooks/useProcessManager.ts
+import { useState, useEffect, useRef, useCallback } from "react";
+
+// src/process/manager.ts
+import { spawn as spawn2 } from "child_process";
+import { join as join3 } from "path";
+
+// src/process/health.ts
+import net from "net";
+function checkPort(port, host = "127.0.0.1") {
+  return new Promise((resolve3) => {
+    const socket = new net.Socket();
+    socket.setTimeout(2e3);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve3(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve3(false);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve3(false);
+    });
+    socket.connect(port, host);
+  });
+}
+function waitForPort(port, opts = {}) {
+  const { timeout = 45e3, interval = 1e3 } = opts;
+  return new Promise((resolve3) => {
+    const start = Date.now();
+    const check = () => {
+      checkPort(port).then((ok) => {
+        if (ok) return resolve3(true);
+        if (Date.now() - start > timeout) return resolve3(false);
+        setTimeout(check, interval);
+      });
+    };
+    check();
+  });
+}
+function deriveHealth(isUp, currentStatus) {
+  if (currentStatus === "idle") return "idle";
+  if (isUp) return "up";
+  return currentStatus === "starting" ? "wait" : "down";
+}
+
+// src/process/installer.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+function installService(cwd, env, onLog) {
+  if (!existsSync5(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((resolve3) => {
+    const proc = spawn("npm", ["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]}`);
+        resolve3(false);
+      } else {
+        writeInstallStamp(cwd);
+        onLog?.("\u2705 dependencies ready");
+        resolve3(true);
+      }
+    });
+  });
+}
+
+// src/process/manager.ts
+var MAX_RESTARTS = 3;
+var BACKOFF_BASE_MS = 2e3;
+var ProcessManager = class {
+  state = /* @__PURE__ */ new Map();
+  procs = /* @__PURE__ */ new Set();
+  baseCwd;
+  env;
+  platform;
+  events;
+  constructor(opts) {
+    this.baseCwd = opts.baseCwd;
+    this.env = opts.env;
+    this.platform = opts.platform;
+    this.events = opts.events;
+  }
+  async install(svc) {
+    const cwd = join3(this.baseCwd, svc.cwd);
+    return installService(cwd, this.env, (msg) => this.log(svc.name, msg, this.getColorIdx(svc.name)));
+  }
+  async start(svc, colorIdx, isRestart = false) {
+    const cwd = join3(this.baseCwd, svc.cwd);
+    if (svc.type === "api") {
+      const occupied = await checkPort(svc.port);
+      if (occupied && !isRestart) {
+        this.log(svc.name, `\u26A0 port ${svc.port} already in use \u2014 skipping`, colorIdx);
+        return;
+      }
+    }
+    const args = buildProcessArgs(svc);
+    const env = buildProcessEnv(svc, this.env);
+    const proc = spawn2(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const prev = this.state.get(svc.name);
+    const state = {
+      svc,
+      proc,
+      pid: proc.pid ?? null,
+      status: "starting",
+      health: "wait",
+      errors: prev?.errors ?? 0,
+      restarts: prev?.restarts ?? 0,
+      startedAt: Date.now(),
+      intentionalStop: false,
+      colorIdx
+    };
+    this.state.set(svc.name, state);
+    this.procs.add(proc);
+    this.events.onStateChange(svc.name, state);
+    proc.stdout?.on("data", (d) => this.log(svc.name, d.toString(), colorIdx));
+    proc.stderr?.on("data", (d) => {
+      state.errors += d.toString().split("\n").filter(Boolean).length;
+      this.log(svc.name, d.toString(), colorIdx);
+    });
+    proc.on("close", (code) => {
+      this.procs.delete(proc);
+      if (state.intentionalStop) {
+        state.intentionalStop = false;
+        return;
+      }
+      if (code === 0) {
+        state.status = "stopped";
+        state.health = "down";
+        this.events.onStateChange(svc.name, state);
+        return;
+      }
+      state.status = "crashed";
+      state.health = "down";
+      this.log(svc.name, `\u274C exited with code ${code}`, colorIdx);
+      this.events.onStateChange(svc.name, state);
+      if (state.restarts < MAX_RESTARTS) {
+        state.restarts++;
+        const delay = BACKOFF_BASE_MS * Math.pow(2, state.restarts - 1);
+        this.log(svc.name, `\u{1F504} auto-restart ${state.restarts}/${MAX_RESTARTS} in ${delay}ms...`, colorIdx);
+        setTimeout(() => this.start(svc, colorIdx, true), delay);
+      } else {
+        this.log(svc.name, "\u26D4 max restarts reached", colorIdx);
+      }
+    });
+    this.log(svc.name, isRestart ? `\u{1F504} restarted (:${svc.port})` : `\u{1F680} started (:${svc.port})`, colorIdx);
+  }
+  stop(name) {
+    const st = this.state.get(name);
+    if (!st?.proc || !st.pid) return;
+    st.intentionalStop = true;
+    this.platform.killTree(st.pid);
+  }
+  async restart(name) {
+    const st = this.state.get(name);
+    if (!st) return;
+    this.stop(name);
+    st.restarts++;
+    const delay = st.proc ? 1500 : 100;
+    await new Promise((r) => setTimeout(r, delay));
+    await this.start(st.svc, st.colorIdx, true);
+    this.log(name, "\u{1F504} manual restart", st.colorIdx);
+  }
+  async checkAllHealth() {
+    for (const [name, st] of this.state) {
+      if (!st.pid || st.status === "idle") {
+        st.health = st.status === "idle" ? "idle" : "down";
+        continue;
+      }
+      const port = st.svc.port;
+      const isUp = await checkPort(port);
+      const prev = st.health;
+      st.health = deriveHealth(isUp, st.status);
+      if (st.health === "up" && st.status === "starting") st.status = "running";
+      if (prev !== st.health) this.events.onStateChange(name, st);
+    }
+  }
+  cleanup() {
+    for (const proc of this.procs) {
+      if (proc.pid) this.platform.killTree(proc.pid);
+    }
+    setTimeout(() => {
+      for (const proc of this.procs) {
+        if (proc.pid) this.platform.killTree(proc.pid, "SIGKILL");
+      }
+    }, 3e3);
+  }
+  log(name, text, colorIdx) {
+    this.events.onLog(name, text, colorIdx);
+  }
+  getColorIdx(name) {
+    return this.state.get(name)?.colorIdx ?? 0;
+  }
+};
+
+// src/tui/hooks/useProcessManager.ts
+function useProcessManager(platform, baseCwd, env) {
+  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());
+  useEffect(() => {
+    const mgr2 = new ProcessManager({
+      baseCwd,
+      env,
+      platform,
+      events: {
+        onLog: (svcName, text, colorIdx) => {
+          const lines = text.split("\n").filter(Boolean);
+          setLogs((prev) => {
+            const next = [...prev, ...lines.map((l) => ({ svcName, text: l, colorIdx, ts: Date.now() }))];
+            return next.length > 5e3 ? next.slice(-5e3) : next;
+          });
+        },
+        onStateChange: () => setStates(new Map(mgr2.state))
+      }
+    });
+    mgrRef.current = mgr2;
+    return () => {
+      mgr2.cleanup();
+    };
+  }, [baseCwd, env, platform]);
+  useEffect(() => {
+    const id = setInterval(async () => {
+      const mgr2 = mgrRef.current;
+      if (!mgr2) return;
+      await mgr2.checkAllHealth();
+      setStates(new Map(mgr2.state));
+      const pids = [];
+      const pidMap = /* @__PURE__ */ new Map();
+      for (const [name, st] of mgr2.state) {
+        if (st.pid) {
+          pids.push(st.pid);
+          pidMap.set(st.pid, name);
+        }
+      }
+      if (pids.length) {
+        const raw = await platform.getProcessStats(pids);
+        const next = /* @__PURE__ */ new Map();
+        for (const [pid, data] of raw) {
+          const name = pidMap.get(pid);
+          if (!name) continue;
+          const prev = prevCpu.current.get(name) ?? { time: Date.now(), cpu: 0 };
+          const cpuPct = calcCpuPercent(data.cpuSeconds, prev.cpu, prev.time);
+          prevCpu.current.set(name, { time: Date.now(), cpu: data.cpuSeconds });
+          next.set(name, { cpu: cpuPct.toFixed(1) + "%", mem: (data.rss / 1024).toFixed(1) + " MB" });
+        }
+        setStats(next);
+      }
+    }, 3e3);
+    return () => clearInterval(id);
+  }, [platform]);
+  const mgr = mgrRef.current;
+  return {
+    states,
+    logs,
+    stats,
+    start: useCallback((svc, colorIdx) => mgr?.start(svc, colorIdx), [mgr]),
+    stop: useCallback((name) => mgr?.stop(name), [mgr]),
+    restart: useCallback((name) => mgr?.restart(name), [mgr]),
+    install: useCallback((svc) => mgr?.install(svc), [mgr]),
+    cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
+    manager: mgr
+  };
+}
+
+// src/tui/hooks/useKeyBindings.ts
+import { useInput } from "ink";
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var SORT_MODES = ["name", "mem", "errors"];
+function useKeyBindings(opts) {
+  const [state, setState] = useState2({
+    panel: "logs",
+    modal: "none",
+    logFilter: null,
+    searchTerm: null,
+    logsPaused: false,
+    showTimestamps: false,
+    sortIdx: 0,
+    proxyEnabled: false
+  });
+  const setModal = useCallback2((modal) => setState((s) => ({ ...s, modal })), []);
+  const setFilter = useCallback2((f) => setState((s) => ({ ...s, logFilter: f, modal: "none" })), []);
+  const setSearch = useCallback2((t) => setState((s) => ({ ...s, searchTerm: t, modal: "none" })), []);
+  const isActive = process.stdin.isTTY ?? false;
+  useInput((input, key) => {
+    if (state.modal !== "none") return;
+    if (input === "q" || key.ctrl && input === "c") opts.onQuit();
+    else if (input === "c") opts.onClearLogs();
+    else if (key.tab) setState((s) => ({ ...s, panel: s.panel === "logs" ? "stats" : "logs" }));
+    else if (input === "f") setModal("filter");
+    else if (input === "r") setModal("restart");
+    else if (input === "o") setModal("open");
+    else if (input === "/") setModal("search");
+    else if (input === "a") setState((s) => ({ ...s, logFilter: null, searchTerm: null }));
+    else if (input === "p") setState((s) => ({ ...s, logsPaused: !s.logsPaused }));
+    else if (input === "t") setState((s) => ({ ...s, showTimestamps: !s.showTimestamps }));
+    else if (input === "s") setState((s) => ({ ...s, sortIdx: (s.sortIdx + 1) % SORT_MODES.length }));
+    else if (input === "T") {
+      opts.onToggleProxy();
+      setState((s) => ({ ...s, proxyEnabled: !s.proxyEnabled }));
+    }
+  }, { isActive });
+  return { ...state, setModal, setFilter, setSearch, sortMode: SORT_MODES[state.sortIdx] };
+}
+
+// src/tui/hooks/useProxySync.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+function useProxySync(provider, opts, states, enabled) {
+  const intervalRef = useRef2(null);
+  useEffect2(() => {
+    if (!provider || !opts || !enabled) {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+      return;
+    }
+    const sync = () => {
+      const svcStates = /* @__PURE__ */ new Map();
+      for (const [name, st] of states) {
+        svcStates.set(name, { port: st.svc.port, health: st.health, realPort: st.svc.realPort });
+      }
+      const content = provider.generate(svcStates, opts);
+      provider.write(content, opts);
+    };
+    sync();
+    intervalRef.current = setInterval(sync, 3e3);
+    return () => {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+    };
+  }, [provider, opts, enabled, states]);
+}
+
+// src/tui/LogsPanel.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function LogsPanel({ logs, filter, searchTerm, paused, showTimestamps, maxNameLen, height, focused }) {
+  const filtered = filter ? logs.filter((l) => l.svcName === filter) : logs;
+  const contentHeight = height - 2;
+  const visible = filtered.slice(-contentHeight);
+  const label = [
+    "Logs",
+    filter ? `[${filter}]` : "",
+    searchTerm ? `/${searchTerm}` : "",
+    paused ? "[PAUSED]" : "",
+    `${filtered.length} lines`
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: focused ? "cyan" : "gray", height, children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      " ",
+      label,
+      " "
+    ] }) }),
+    visible.map((entry, i) => {
+      const color = tagColors[entry.colorIdx % tagColors.length];
+      const ts = showTimestamps ? new Date(entry.ts).toLocaleTimeString("en-GB") + " " : "";
+      const line = entry.text;
+      const isMatch = searchTerm && line.toLowerCase().includes(searchTerm.toLowerCase());
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        showTimestamps && /* @__PURE__ */ jsx(Text, { dimColor: true, children: ts }),
+        /* @__PURE__ */ jsxs(Text, { color, children: [
+          "[",
+          entry.svcName.padEnd(maxNameLen),
+          "]"
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children: " " }),
+        isMatch ? /* @__PURE__ */ jsx(Text, { backgroundColor: "yellow", color: "black", children: line }) : /* @__PURE__ */ jsx(Text, { children: line })
+      ] }, i);
+    })
+  ] });
+}
+
+// src/tui/StatsPanel.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import os from "os";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var H = {
+  up: { c: "\u25CF", color: "green" },
+  wait: { c: "\u25CF", color: "yellow" },
+  down: { c: "\u25CF", color: "red" },
+  idle: { c: "\u25CB", color: "blue" }
+};
+function Row({ name, st, stat, ml }) {
+  const h = H[st.health] ?? H["down"];
+  const color = tagColors[st.colorIdx % tagColors.length];
+  const sc = st.status === "running" ? "green" : st.status === "starting" ? "yellow" : st.status === "idle" ? "blue" : "red";
+  const up = st.startedAt ? fmtUptime(Date.now() - st.startedAt) : "-";
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: h.color, children: h.c }),
+    " ",
+    /* @__PURE__ */ jsx2(Text2, { color, children: name.padEnd(ml) }),
+    " ",
+    String(st.svc.port).padStart(5),
+    " ",
+    /* @__PURE__ */ jsx2(Text2, { color: sc, children: st.status.padEnd(8) }),
+    " ",
+    (stat?.cpu ?? "-").padStart(6),
+    " ",
+    (stat?.mem ?? "-").padStart(8),
+    " ",
+    String(st.errors).padStart(3),
+    " ",
+    String(st.restarts).padStart(3),
+    " ",
+    up.padStart(6)
+  ] });
+}
+function ColHeader({ ml }) {
+  return /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+    "H ",
+    "Service".padEnd(ml),
+    " ",
+    "Port".padStart(5),
+    " ",
+    "Status".padEnd(8),
+    " ",
+    "CPU".padStart(6),
+    " ",
+    "Mem".padStart(8),
+    " Err Rst ",
+    "Up".padStart(6)
+  ] });
+}
+function StatsPanel({ states, stats, sortMode, maxNameLen, height, focused }) {
+  const names = [...states.keys()];
+  const stObj = Object.fromEntries([...states].map(([k, v]) => [k, { errors: v.errors }]));
+  const statsObj = Object.fromEntries([...stats].map(([k, v]) => [k, v]));
+  const apis = sortServiceNames(names.filter((n) => states.get(n).svc.type === "api"), sortMode, statsObj, stObj);
+  const webs = sortServiceNames(names.filter((n) => states.get(n).svc.type === "web"), sortMode, statsObj, stObj);
+  const cpus = os.cpus().length;
+  const totalGB = (os.totalmem() / 1024 / 1024 / 1024).toFixed(1);
+  const usedGB = (parseFloat(totalGB) - os.freemem() / 1024 / 1024 / 1024).toFixed(1);
+  const load = os.loadavg()[0].toFixed(2);
+  let totalCpu = 0, totalMemMB = 0, totalErrors = 0, totalRestarts = 0;
+  for (const name of names) {
+    const s = stats.get(name);
+    if (s) {
+      const c = parseFloat(s.cpu);
+      if (!isNaN(c)) totalCpu += c;
+      const m = parseFloat(s.mem);
+      if (!isNaN(m)) totalMemMB += m;
+    }
+    totalErrors += states.get(name)?.errors ?? 0;
+    totalRestarts += states.get(name)?.restarts ?? 0;
+  }
+  const stackMem = totalMemMB >= 1024 ? (totalMemMB / 1024).toFixed(2) + " GB" : totalMemMB.toFixed(1) + " MB";
+  const ml = maxNameLen;
+  const contentHeight = height - 2;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: focused ? "green" : "gray", height, children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: "green", children: " Stats " }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "System: ",
+        cpus,
+        "c Load ",
+        load,
+        " RAM ",
+        usedGB,
+        "/",
+        totalGB,
+        "GB"
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Stack: CPU ",
+        totalCpu.toFixed(1),
+        "% RAM ",
+        stackMem,
+        " Err ",
+        totalErrors,
+        " Rst ",
+        totalRestarts,
+        " Svcs ",
+        names.length
+      ] }),
+      sortMode !== "name" && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        " \u2502 Sort: ",
+        sortMode
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2(Box2, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
+        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
+          " APIs (",
+          apis.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx2(ColHeader, { ml }),
+        apis.slice(0, contentHeight - 2).map((n) => /* @__PURE__ */ jsx2(Row, { name: n, st: states.get(n), stat: stats.get(n), ml }, n))
+      ] }),
+      /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", width: 1, children: Array.from({ length: contentHeight }, (_, i) => /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2502" }, i)) }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, flexBasis: 0, children: [
+        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "magenta", children: [
+          " Webs (",
+          webs.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx2(ColHeader, { ml }),
+        webs.slice(0, contentHeight - 2).map((n) => /* @__PURE__ */ jsx2(Row, { name: n, st: states.get(n), stat: stats.get(n), ml }, n))
+      ] })
+    ] })
+  ] });
+}
+
+// src/tui/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function StatusBar() {
+  return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "q" }),
+    " Quit  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Tab" }),
+    " Switch  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "c" }),
+    " Clear  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "f" }),
+    " Filter  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "a" }),
+    " All  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "r" }),
+    " Restart  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "/" }),
+    " Search  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "s" }),
+    " Sort  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "o" }),
+    " Open  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "p" }),
+    " Pause  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "t" }),
+    " Time  ",
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "T" }),
+    " Proxy"
+  ] }) });
+}
+
+// src/tui/ServiceList.tsx
+import { useState as useState3 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ServiceList({ title, services, onSelect, onClose, filterType }) {
+  const names = [...services.keys()].filter((n) => !filterType || services.get(n).svc.type === filterType);
+  const [idx, setIdx] = useState3(0);
+  useInput2((input, key) => {
+    if (key.escape) onClose();
+    else if (key.return) {
+      if (names[idx]) onSelect(names[idx]);
+    } else if (key.upArrow) setIdx((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setIdx((i) => Math.min(names.length - 1, i + 1));
+  }, { isActive: process.stdin.isTTY ?? false });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
+      " ",
+      title,
+      " "
+    ] }),
+    names.map((name, i) => /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: i === idx ? "cyan" : void 0, inverse: i === idx, children: [
+      " ",
+      name,
+      " :",
+      services.get(name).svc.port,
+      " "
+    ] }) }, name)),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191\u2193 navigate  Enter select  Esc close" })
+  ] });
+}
+
+// src/tui/SearchInput.tsx
+import { useState as useState4 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function SearchInput({ onSubmit, onClose }) {
+  const [value, setValue] = useState4("");
+  useInput3((input, key) => {
+    if (key.escape) onClose();
+    else if (key.return) onSubmit(value.trim() || null);
+    else if (key.backspace || key.delete) setValue((v) => v.slice(0, -1));
+    else if (input && !key.ctrl && !key.meta) setValue((v) => v + input);
+  }, { isActive: process.stdin.isTTY ?? false });
+  return /* @__PURE__ */ jsxs5(Box5, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "yellow", children: "Search: " }),
+    /* @__PURE__ */ jsx5(Text5, { children: value }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2588" })
+  ] });
+}
+
+// src/lazy/classifier.ts
+var LAZY_PORT_OFFSET = 1e4;
+function classifyServices(services, config) {
+  const alwaysOnSet = new Set(config?.alwaysOn ?? []);
+  const alwaysOn = [];
+  const lazy = [];
+  for (const svc of services) {
+    if (alwaysOnSet.has(svc.name)) alwaysOn.push(svc);
+    else lazy.push(svc);
+  }
+  return { alwaysOn, lazy };
+}
+function getLazyRealPort(originalPort) {
+  return originalPort + LAZY_PORT_OFFSET;
+}
+function rewriteServicePort(svc) {
+  const realPort = getLazyRealPort(svc.port);
+  const args = svc.args.map((a) => a === String(svc.port) ? String(realPort) : a);
+  const extraEnv = { ...svc.extraEnv, PORT_OVERRIDE: String(realPort) };
+  return { ...svc, port: realPort, args, extraEnv, realPort, originalPort: svc.port };
+}
+
+// src/lazy/proxy.ts
+import net2 from "net";
+function createLazyProxy(opts) {
+  const { listenPort, targetPort, timeoutMin, onDemandStart, onIdleStop, isAlive, onLog } = opts;
+  let idleTimer = null;
+  let starting = false;
+  let serviceReady = false;
+  let pendingConns = [];
+  function resetTimer() {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (timeoutMin > 0) {
+      idleTimer = setTimeout(() => {
+        serviceReady = false;
+        onLog?.(`\u{1F4A4} idle ${timeoutMin}min \u2014 stopping`);
+        onIdleStop();
+      }, timeoutMin * 6e4);
+    }
+  }
+  function pipeToTarget(client) {
+    const target = net2.createConnection({ port: targetPort, host: "127.0.0.1", allowHalfOpen: true });
+    target.on("error", () => {
+      client.destroy();
+    });
+    client.on("error", () => {
+      target.destroy();
+    });
+    target.on("connect", () => {
+      target.on("data", (chunk) => {
+        if (!client.destroyed) client.write(chunk);
+      });
+      client.on("data", (chunk) => {
+        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) {
+    resetTimer();
+    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");
+    try {
+      await onDemandStart();
+      const 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);
+    for (const conn of conns) {
+      if (!conn.destroyed) pipeToTarget(conn);
+    }
+  }
+  const server = net2.createServer({ allowHalfOpen: true }, (socket) => handleConnection(socket));
+  server.listen(listenPort, "0.0.0.0");
+  resetTimer();
+  return {
+    server,
+    resetTimer,
+    destroy: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      pendingConns.forEach((s) => s.destroy());
+      server.close();
+    }
+  };
+}
+
+// src/tui/App.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts }) {
+  const { stdout } = useStdout();
+  const rows = stdout?.rows ?? 40;
+  const logsHeight = Math.floor(rows * 0.65);
+  const statsHeight = rows - logsHeight - 2;
+  const maxNameLen = Math.max(...services.map((s) => s.name.length), 10);
+  const pm = useProcessManager(platform, baseCwd, env);
+  const [booted, setBooted] = useState5(false);
+  const lazyProxies = useRef3(/* @__PURE__ */ new Map());
+  const kb = useKeyBindings({
+    onQuit: () => {
+      lazyProxies.current.forEach((p) => p.destroy());
+      pm.cleanup();
+      process.exit(0);
+    },
+    onClearLogs: () => {
+    },
+    onToggleProxy: () => {
+    }
+  });
+  useProxySync(proxyProvider, proxyOpts, pm.states, kb.proxyEnabled);
+  useEffect3(() => {
+    if (booted || !pm.manager) return;
+    setBooted(true);
+    const mgr = pm.manager;
+    (async () => {
+      const lazyMode = cliArgs.lazy;
+      const lazyTimeout = cliArgs.lazyTimeout;
+      if (lazyMode && config.lazy) {
+        const { alwaysOn, lazy } = classifyServices(services, config.lazy);
+        const aoPhases = groupByPhase(alwaysOn);
+        let colorIdx = 0;
+        for (const num of Object.keys(aoPhases).map(Number).sort((a, b) => a - b)) {
+          const svcs = aoPhases[num];
+          for (const svc of svcs) {
+            await mgr.install(svc);
+            await mgr.start(svc, colorIdx++);
+          }
+          const apis = svcs.filter((s) => s.type === "api");
+          if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
+          svcs.filter((s) => s.type === "web").forEach((s) => {
+            const st = mgr.state.get(s.name);
+            if (st) st.status = "running";
+          });
+        }
+        for (const svc of lazy) {
+          const ci = colorIdx++;
+          const rewritten = rewriteServicePort(svc);
+          const idleState = {
+            svc: rewritten,
+            proc: null,
+            pid: null,
+            status: "idle",
+            health: "idle",
+            errors: 0,
+            restarts: 0,
+            startedAt: null,
+            intentionalStop: false,
+            colorIdx: ci
+          };
+          mgr.state.set(svc.name, idleState);
+          const proxy = createLazyProxy({
+            listenPort: svc.port,
+            targetPort: rewritten.realPort,
+            timeoutMin: lazyTimeout,
+            onDemandStart: async () => {
+              await mgr.install(rewritten);
+              await mgr.start(rewritten, ci);
+              const ok = await waitForPort(rewritten.realPort, { timeout: 45e3 });
+              const st = mgr.state.get(svc.name);
+              if (st) {
+                st.status = ok ? "running" : "timeout";
+                if (ok) st.health = "up";
+              }
+            },
+            onIdleStop: () => {
+              mgr.stop(svc.name);
+              const st = mgr.state.get(svc.name);
+              if (st) {
+                st.status = "idle";
+                st.health = "idle";
+                st.pid = null;
+                st.proc = null;
+                st.startedAt = null;
+              }
+            },
+            isAlive: () => {
+              const st = mgr.state.get(svc.name);
+              return !!st && !!st.proc && !st.proc.killed && st.health === "up";
+            }
+          });
+          lazyProxies.current.set(svc.name, proxy);
+        }
+      } else {
+        const phases = groupByPhase(services);
+        let colorIdx = 0;
+        for (const num of Object.keys(phases).map(Number).sort((a, b) => a - b)) {
+          const svcs = phases[num];
+          for (const svc of svcs) {
+            await mgr.install(svc);
+            await mgr.start(svc, colorIdx++);
+          }
+          const apis = svcs.filter((s) => s.type === "api");
+          if (apis.length) await Promise.all(apis.map((s) => waitForPort(s.port, { timeout: 45e3 })));
+          svcs.filter((s) => s.type === "web").forEach((s) => {
+            const st = mgr.state.get(s.name);
+            if (st) st.status = "running";
+          });
+        }
+      }
+    })();
+  }, [booted, pm.manager, services, cliArgs, config.lazy]);
+  const handleFilterSelect = useCallback3((name) => kb.setFilter(name), [kb]);
+  const handleRestartSelect = useCallback3((name) => {
+    pm.restart(name);
+    kb.setModal("none");
+  }, [pm, kb]);
+  const handleOpenSelect = useCallback3((name) => {
+    const st = pm.states.get(name);
+    if (st) platform.openBrowser(`http://localhost:${st.svc.port}`);
+    kb.setModal("none");
+  }, [pm, platform, kb]);
+  const icon = config.icon ?? "\u{1F4E6}";
+  const modeLabel = cliArgs.lazy && config.lazy ? "lazy" : "normal";
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "cyan", children: [
+      " ",
+      icon,
+      " ",
+      config.name,
+      " \u2014 devup \u2014 ",
+      services.length,
+      " services (",
+      modeLabel,
+      ") "
+    ] }) }),
+    /* @__PURE__ */ jsx6(
+      LogsPanel,
+      {
+        logs: pm.logs,
+        filter: kb.logFilter,
+        searchTerm: kb.searchTerm,
+        paused: kb.logsPaused,
+        showTimestamps: kb.showTimestamps,
+        maxNameLen,
+        height: logsHeight,
+        focused: kb.panel === "logs"
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      StatsPanel,
+      {
+        states: pm.states,
+        stats: pm.stats,
+        sortMode: kb.sortMode,
+        maxNameLen,
+        height: statsHeight,
+        focused: kb.panel === "stats"
+      }
+    ),
+    kb.modal === "filter" && /* @__PURE__ */ jsx6(ServiceList, { title: "Filter by service", services: pm.states, onSelect: handleFilterSelect, onClose: () => kb.setModal("none") }),
+    kb.modal === "restart" && /* @__PURE__ */ jsx6(ServiceList, { title: "Restart service", services: pm.states, onSelect: handleRestartSelect, onClose: () => kb.setModal("none") }),
+    kb.modal === "open" && /* @__PURE__ */ jsx6(ServiceList, { title: "Open in browser", services: pm.states, onSelect: handleOpenSelect, onClose: () => kb.setModal("none"), filterType: "web" }),
+    kb.modal === "search" && /* @__PURE__ */ jsx6(SearchInput, { onSubmit: kb.setSearch, onClose: () => kb.setModal("none") }),
+    /* @__PURE__ */ jsx6(StatusBar, {})
+  ] });
+}
+
+// src/config/types.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/index.ts
+async function main() {
+  const cwd = process.cwd();
+  const cliArgs = parseCliArgs(process.argv.slice(2));
+  let configPath;
+  try {
+    configPath = findConfigFile(cwd, cliArgs.configPath);
+  } catch (e) {
+    console.error(`\u274C ${e.message}`);
+    process.exit(1);
+  }
+  const config = await loadConfig(configPath);
+  const errors = validateConfig(config, cwd);
+  if (errors.length) {
+    console.error(`\u274C Config validation failed:
+${formatValidationErrors(errors)}`);
+    process.exit(1);
+  }
+  const services = filterServices(config.services, cliArgs);
+  if (!services.length) {
+    console.error("\u274C No services to run after filtering");
+    process.exit(1);
+  }
+  const platform = await detectPlatform();
+  const envFile = config.envFile ? join4(cwd, config.envFile) : join4(cwd, ".env");
+  const env = parseEnvFile(envFile, process.env);
+  if (config.env) {
+    for (const [k, v] of Object.entries(config.env)) {
+      if (!env[k]) env[k] = v;
+    }
+  }
+  let proxyProvider = null;
+  let proxyOpts = null;
+  if (cliArgs.proxy && config.proxy) {
+    proxyProvider = detectProxyProvider(config.proxy.provider);
+    proxyOpts = {
+      host: cliArgs.proxyHost ?? config.proxy.host ?? platform.defaultTraefikHost,
+      domain: env["GUESTHUB_DOMAIN"] ?? env["DOMAIN"] ?? "localhost",
+      routes: config.proxy.routes,
+      tls: cliArgs.proxyTls ?? config.proxy.tls ?? true,
+      entrypoint: cliArgs.proxyEntrypoint ?? config.proxy.entrypoint ?? "websecure",
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join4(homedir(), ".traefik", "traefik_conf.yaml")
+    };
+  }
+  const isInteractive = process.stdin.isTTY ?? false;
+  const { waitUntilExit } = render(
+    React4.createElement(App, {
+      config,
+      services,
+      cliArgs,
+      platform,
+      env,
+      baseCwd: cwd,
+      proxyProvider,
+      proxyOpts
+    }),
+    { exitOnCtrlC: false, patchConsole: isInteractive, interactive: isInteractive }
+  );
+  await waitUntilExit();
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
+export {
+  defineConfig
+};
+//# sourceMappingURL=index.js.map