procdeck 0.1.0

package/dist/cli.js

@@ -0,0 +1,688 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_UI_PORT,
+  loadConfig,
+  resolveSpec,
+  usesOwnPort
+} from "./chunk-SBVZ6G4G.js";
+
+// src/cli.ts
+import { Effect as Effect3, Fiber as Fiber2 } from "effect";
+
+// src/supervisor.ts
+import { Effect, Fiber, Latch, PubSub } from "effect";
+
+// src/proc.ts
+import { execFile } from "child_process";
+import { chmodSync, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { spawn } from "node-pty";
+var fixSpawnHelperExecBit = () => {
+  if (process.platform !== "darwin") return;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageRoot = dirname(require2.resolve("node-pty/package.json"));
+    const helper = join(packageRoot, "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+    const mode = statSync(helper).mode;
+    if ((mode & 73) === 0) chmodSync(helper, mode | 493);
+  } catch {
+  }
+};
+fixSpawnHelperExecBit();
+var describeCommand = (spec) => spec.shell ?? (spec.cmd ?? []).join(" ");
+var resolveArgv = (spec) => {
+  if (spec.shell !== void 0) {
+    return { file: process.env["SHELL"] ?? "/bin/sh", args: ["-c", spec.shell] };
+  }
+  const [file, ...args] = spec.cmd ?? [];
+  if (file === void 0) {
+    throw new Error(`proc "${spec.id}" defines neither shell nor cmd`);
+  }
+  return { file, args };
+};
+var buildEnv = (spec) => {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) env[key] = value;
+  }
+  env["TERM"] = "xterm-256color";
+  env["FORCE_COLOR"] = "1";
+  return { ...env, ...spec.env };
+};
+var spawnProc = (options) => {
+  const { spec, root, cols, rows, onData } = options;
+  const { file, args } = resolveArgv(spec);
+  const pty = spawn(file, args, {
+    name: "xterm-256color",
+    cols,
+    rows,
+    cwd: spec.cwd === void 0 ? root : spec.cwd,
+    env: buildEnv(spec)
+  });
+  pty.onData(onData);
+  const exited = new Promise((resolve) => {
+    pty.onExit(
+      ({ exitCode, signal }) => resolve(signal === void 0 ? { exitCode } : { exitCode, signal })
+    );
+  });
+  return { pty, pid: pty.pid, exited };
+};
+var runPreflight = (shell, cwd, timeoutMs = 15e3) => new Promise((resolve) => {
+  execFile(
+    process.env["SHELL"] ?? "/bin/sh",
+    ["-c", shell],
+    { cwd, timeout: timeoutMs, maxBuffer: 1024 * 1024 },
+    (error, stdout, stderr) => {
+      resolve({ ok: error === null, output: `${stdout}${stderr}` });
+    }
+  );
+});
+var killTree = (pid, signal) => {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+};
+var isGroupAlive = (pid) => {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var terminate = async (proc, graceMs = 4e3) => {
+  if (!isGroupAlive(proc.pid)) return;
+  killTree(proc.pid, "SIGTERM");
+  const timedOut = /* @__PURE__ */ Symbol("timeout");
+  const outcome = await Promise.race([proc.exited, delay(graceMs).then(() => timedOut)]);
+  if (outcome !== timedOut && !isGroupAlive(proc.pid)) return;
+  killTree(proc.pid, "SIGKILL");
+  for (let i = 0; i < 10 && isGroupAlive(proc.pid); i++) {
+    await delay(100);
+  }
+};
+
+// src/ports.ts
+import { execFile as execFile2 } from "child_process";
+import { createServer } from "net";
+var run = (cmd, args) => new Promise((resolve) => {
+  execFile2(cmd, args, (_error, stdout) => resolve(stdout ?? ""));
+});
+var detectPorts = async (pgid) => {
+  const pids = (await run("pgrep", ["-g", String(pgid)])).split("\n").filter(Boolean);
+  if (pids.length === 0) return [];
+  const output = await run("lsof", [
+    "-a",
+    "-P",
+    "-n",
+    "-iTCP",
+    "-sTCP:LISTEN",
+    "-p",
+    pids.join(",")
+  ]);
+  const ports = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const match = /:(\d+)\s+\(LISTEN\)/.exec(line);
+    if (match !== null) ports.add(Number(match[1]));
+  }
+  return [...ports].sort((a, b) => a - b);
+};
+var samePorts = (a, b) => a.length === b.length && a.every((port, i) => port === b[i]);
+var isInternalPort = (port) => port >= 49152 || port >= 9229 && port <= 9249;
+var findFreePorts = async (count) => {
+  const servers = await Promise.all(
+    Array.from(
+      { length: count },
+      () => new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve(server));
+      })
+    )
+  );
+  const ports = servers.map((server) => server.address().port);
+  await Promise.all(
+    servers.map((server) => new Promise((done) => server.close(() => done())))
+  );
+  return ports;
+};
+
+// src/supervisor.ts
+var DEFAULT_COLS = 120;
+var DEFAULT_ROWS = 30;
+var PORT_POLL_INTERVAL = "1 second";
+var EVENT_BUFFER = 5e3;
+var requiredPort = (spec) => {
+  if (spec.url === void 0) return void 0;
+  try {
+    const url = new URL(spec.url);
+    return url.port === "" ? void 0 : Number(url.port);
+  } catch {
+    return void 0;
+  }
+};
+var ALERT_TAIL = 4096;
+var make = Effect.fn("procdeck.supervisor")(function* (loaded) {
+  const scope = yield* Effect.scope;
+  const events = yield* PubSub.sliding({
+    capacity: EVENT_BUFFER,
+    replay: EVENT_BUFFER
+  });
+  const wantsPort = loaded.config.procs.filter(usesOwnPort);
+  const freePorts = yield* Effect.promise(() => findFreePorts(wantsPort.length));
+  const assigned = new Map(wantsPort.map((spec, index) => [spec.id, freePorts[index]]));
+  const runtimes = /* @__PURE__ */ new Map();
+  for (const spec of loaded.config.procs) {
+    const assignedPort = assigned.get(spec.id);
+    const resolved = resolveSpec(spec, assigned);
+    runtimes.set(spec.id, {
+      spec,
+      resolved: assignedPort === void 0 ? resolved : { ...resolved, env: { PORT: String(assignedPort), ...resolved.env } },
+      assignedPort,
+      status: { id: spec.id, state: "stopped" },
+      proc: void 0,
+      ready: Latch.makeUnsafe(false),
+      waiter: void 0,
+      ports: [],
+      tail: "",
+      cols: DEFAULT_COLS,
+      rows: DEFAULT_ROWS
+    });
+  }
+  const emit = (event) => {
+    PubSub.publishUnsafe(events, event);
+  };
+  const setStatus = (runtime, status) => {
+    runtime.status = status;
+    emit({ type: "status", status });
+  };
+  const require_ = (id) => {
+    const runtime = runtimes.get(id);
+    if (runtime === void 0) throw new Error(`unknown proc "${id}"`);
+    return runtime;
+  };
+  const markUnready = (runtime) => {
+    runtime.ready.closeUnsafe();
+    runtime.ports = [];
+  };
+  const handleData = (runtime, data) => {
+    emit({ type: "log", id: runtime.spec.id, data });
+    const alerts = runtime.spec.alerts ?? [];
+    if (alerts.length === 0 || runtime.status.alert !== void 0) return;
+    runtime.tail = (runtime.tail + data).slice(-ALERT_TAIL);
+    for (const alert of alerts) {
+      if (new RegExp(alert.pattern).test(runtime.tail)) {
+        setStatus(runtime, { ...runtime.status, alert: alert.label });
+        return;
+      }
+    }
+  };
+  const startSync = (runtime) => {
+    if (runtime.proc !== void 0) return;
+    setStatus(runtime, { id: runtime.spec.id, state: "starting" });
+    markUnready(runtime);
+    runtime.tail = "";
+    let proc;
+    try {
+      proc = spawnProc({
+        spec: runtime.resolved,
+        root: loaded.root,
+        cols: runtime.cols,
+        rows: runtime.rows,
+        onData: (data) => handleData(runtime, data)
+      });
+    } catch (cause) {
+      emit({
+        type: "log",
+        id: runtime.spec.id,
+        data: `\r
+procdeck: spawn failed: ${String(cause)}\r
+`
+      });
+      setStatus(runtime, { id: runtime.spec.id, state: "exited", exitCode: -1 });
+      return;
+    }
+    runtime.proc = proc;
+    if (runtime.spec.readyWhen === "started") runtime.ready.openUnsafe();
+    setStatus(runtime, {
+      id: runtime.spec.id,
+      state: "running",
+      pid: proc.pid,
+      startedAt: Date.now()
+    });
+    void proc.exited.then(({ exitCode, signal }) => {
+      if (runtime.proc !== proc) return;
+      runtime.proc = void 0;
+      markUnready(runtime);
+      setStatus(runtime, {
+        id: runtime.spec.id,
+        state: "exited",
+        exitCode,
+        ...signal === void 0 ? {} : { signal }
+      });
+    });
+  };
+  const gate = Effect.fn("procdeck.preflight")(function* (runtime) {
+    const preflight = runtime.spec.preflight;
+    if (preflight === void 0) return true;
+    setStatus(runtime, { id: runtime.spec.id, state: "starting" });
+    const result = yield* Effect.promise(
+      () => runPreflight(preflight.shell, runtime.spec.cwd ?? loaded.root)
+    );
+    const expected = preflight.expect === void 0 || new RegExp(preflight.expect).test(result.output);
+    if (result.ok && expected) return true;
+    const reason = result.ok ? ` (output lacks /${preflight.expect}/)` : "";
+    const lines = [
+      `procdeck: preflight failed${reason}: ${preflight.shell}`,
+      ...result.output.split("\n").filter((line) => line.length > 0),
+      ...preflight.hint === void 0 ? [] : [`procdeck: hint: ${preflight.hint}`]
+    ];
+    emit({ type: "log", id: runtime.spec.id, data: `\r
+${lines.join("\r\n")}\r
+` });
+    runtime.waiter = void 0;
+    setStatus(runtime, {
+      id: runtime.spec.id,
+      state: "blocked",
+      ...preflight.hint === void 0 ? {} : { hint: preflight.hint }
+    });
+    return false;
+  });
+  const start = Effect.fn("procdeck.start")(function* (id) {
+    const runtime = require_(id);
+    if (runtime.proc !== void 0 || runtime.waiter !== void 0) return;
+    const needs = runtime.spec.needs ?? [];
+    if (needs.length === 0 && runtime.spec.preflight === void 0) {
+      return yield* Effect.sync(() => startSync(runtime));
+    }
+    if (needs.length > 0) setStatus(runtime, { id: runtime.spec.id, state: "waiting" });
+    let finished = false;
+    let self;
+    const fiber2 = yield* Effect.forkIn(
+      Effect.forEach(needs, (need) => require_(need).ready.await, { discard: true }).pipe(
+        Effect.andThen(gate(runtime)),
+        Effect.andThen((cleared) => Effect.sync(() => cleared && startSync(runtime))),
+        Effect.ensuring(
+          Effect.sync(() => {
+            finished = true;
+            if (runtime.waiter === self) runtime.waiter = void 0;
+          })
+        )
+      ),
+      scope
+    );
+    self = fiber2;
+    if (!finished) runtime.waiter = fiber2;
+  });
+  const stop = Effect.fn("procdeck.stop")(function* (id) {
+    const runtime = require_(id);
+    const waiter = runtime.waiter;
+    if (waiter !== void 0) {
+      runtime.waiter = void 0;
+      yield* Fiber.interrupt(waiter);
+      setStatus(runtime, { id: runtime.spec.id, state: "stopped" });
+      return;
+    }
+    const proc = runtime.proc;
+    if (proc === void 0) return;
+    runtime.proc = void 0;
+    markUnready(runtime);
+    yield* Effect.promise(() => terminate(proc));
+    if (runtime.status.state !== "exited") {
+      setStatus(runtime, { id: runtime.spec.id, state: "stopped" });
+    }
+  });
+  const restart = Effect.fn("procdeck.restart")(function* (id) {
+    yield* stop(id);
+    yield* start(id);
+  });
+  const pollPorts = Effect.gen(function* () {
+    while (true) {
+      yield* Effect.sleep(PORT_POLL_INTERVAL);
+      for (const runtime of runtimes.values()) {
+        const proc = runtime.proc;
+        if (proc === void 0) continue;
+        const ports = yield* Effect.promise(() => detectPorts(proc.pid));
+        if (runtime.proc !== proc) continue;
+        if (!samePorts(ports, runtime.ports)) {
+          runtime.ports = ports;
+          setStatus(runtime, { ...runtime.status, ports });
+        }
+        if (runtime.spec.readyWhen !== "started") {
+          const required = requiredPort(runtime.resolved) ?? runtime.assignedPort;
+          const ready = required === void 0 ? ports.length > 0 : ports.includes(required);
+          if (ready) runtime.ready.openUnsafe();
+        }
+      }
+    }
+  });
+  yield* Effect.forkIn(pollPorts, scope);
+  const uiPort = loaded.config.port ?? DEFAULT_UI_PORT;
+  const supervisor = {
+    events,
+    list: () => [...runtimes.values()].map((runtime) => ({
+      id: runtime.spec.id,
+      command: describeCommand(runtime.resolved),
+      ...runtime.resolved.url === void 0 ? {} : { url: runtime.resolved.url },
+      ...runtime.assignedPort === void 0 ? {} : { assignedPort: runtime.assignedPort },
+      proxyUrl: `http://${runtime.spec.id}.localhost:${uiPort}`,
+      status: runtime.status
+    })),
+    start,
+    stop,
+    restart,
+    resize: (id, cols, rows) => {
+      const runtime = runtimes.get(id);
+      if (runtime === void 0 || cols <= 0 || rows <= 0) return;
+      runtime.cols = cols;
+      runtime.rows = rows;
+      try {
+        runtime.proc?.pty.resize(cols, rows);
+      } catch {
+      }
+    },
+    write: (id, data) => {
+      runtimes.get(id)?.proc?.pty.write(data);
+    },
+    proxyPort: (id) => {
+      const runtime = runtimes.get(id);
+      if (runtime === void 0) return void 0;
+      return runtime.assignedPort ?? requiredPort(runtime.resolved) ?? runtime.ports.find((port) => !isInternalPort(port));
+    }
+  };
+  const stopAll = Effect.forEach([...runtimes.keys()], stop, {
+    concurrency: "unbounded",
+    discard: true
+  });
+  for (const runtime of runtimes.values()) {
+    if (runtime.spec.autostart !== false) yield* start(runtime.spec.id);
+  }
+  return { supervisor, stopAll };
+});
+var makeSupervisor = (loaded) => Effect.acquireRelease(make(loaded), ({ stopAll }) => stopAll).pipe(
+  Effect.map(({ supervisor }) => supervisor)
+);
+
+// src/server.ts
+import { createServer as createServer2, request as httpRequest } from "http";
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { Readable } from "stream";
+import * as path from "path";
+import { Effect as Effect2, Stream } from "effect";
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+var API = "/__procdeck/api";
+var HEARTBEAT = "20 seconds";
+var distDir = path.join(import.meta.dirname, "..", "ui", "dist");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".map": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".woff2": "font/woff2"
+};
+var NO_DIST = "procdeck UI is not built \u2014 run `pnpm --filter procdeck build` first.";
+var serveStatic = (pathname) => Effect2.gen(function* () {
+  if (!existsSync(distDir)) {
+    return HttpServerResponse.text(NO_DIST, { status: 503 });
+  }
+  const relative = pathname === "/" ? "index.html" : pathname.slice(1);
+  const resolved = path.join(distDir, relative);
+  const file = resolved.startsWith(distDir) && existsSync(resolved) ? resolved : path.join(distDir, "index.html");
+  const bytes = yield* Effect2.promise(() => readFile(file));
+  return HttpServerResponse.uint8Array(bytes, {
+    headers: { "content-type": MIME[path.extname(file)] ?? "application/octet-stream" }
+  });
+});
+var sse = (supervisor) => Effect2.sync(() => {
+  const encoder = new TextEncoder();
+  const body = Stream.fromPubSub(supervisor.events).pipe(
+    Stream.map((event) => `data: ${JSON.stringify(event)}
+
+`),
+    Stream.merge(Stream.tick(HEARTBEAT).pipe(Stream.map(() => ": ping\n\n"))),
+    Stream.map((chunk) => encoder.encode(chunk))
+  );
+  return HttpServerResponse.stream(body, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform"
+    }
+  });
+});
+var manifest = (deck) => ({
+  name: `${deck.name} \xB7 procdeck`,
+  short_name: deck.name,
+  start_url: "/",
+  scope: "/",
+  display: "standalone",
+  background_color: "#0e1116",
+  theme_color: "#151a21",
+  icons: [
+    { src: "/icon-192.png", sizes: "192x192", type: "image/png" },
+    { src: "/icon-512.png", sizes: "512x512", type: "image/png" },
+    { src: "/icon-512.png", sizes: "512x512", type: "image/png", purpose: "maskable" }
+  ]
+});
+var routes = (supervisor, deck) => HttpRouter.addAll([
+  HttpRouter.route(
+    "GET",
+    `${API}/deck`,
+    () => Effect2.sync(() => HttpServerResponse.jsonUnsafe(deck))
+  ),
+  HttpRouter.route(
+    "GET",
+    "/manifest.webmanifest",
+    () => Effect2.sync(
+      () => HttpServerResponse.text(JSON.stringify(manifest(deck)), {
+        headers: { "content-type": "application/manifest+json" }
+      })
+    )
+  ),
+  HttpRouter.route(
+    "GET",
+    `${API}/procs`,
+    () => Effect2.sync(() => HttpServerResponse.jsonUnsafe(supervisor.list()))
+  ),
+  HttpRouter.route("GET", `${API}/events`, () => sse(supervisor)),
+  HttpRouter.route(
+    "POST",
+    `${API}/procs/:id/:action`,
+    (request) => Effect2.gen(function* () {
+      const params = yield* HttpRouter.params;
+      const id = params["id"] ?? "";
+      const body = yield* request.json.pipe(Effect2.catch(() => Effect2.succeed(null)));
+      switch (params["action"]) {
+        case "start":
+          yield* supervisor.start(id);
+          break;
+        case "stop":
+          yield* supervisor.stop(id);
+          break;
+        case "restart":
+          yield* supervisor.restart(id);
+          break;
+        case "resize":
+          supervisor.resize(id, body?.cols ?? 0, body?.rows ?? 0);
+          break;
+        case "input":
+          supervisor.write(id, body?.data ?? "");
+          break;
+        default:
+          return HttpServerResponse.jsonUnsafe({ error: "unknown action" }, { status: 404 });
+      }
+      return HttpServerResponse.jsonUnsafe({ ok: true });
+    })
+  ),
+  // Everything else is the built UI.
+  HttpRouter.route("GET", "/", () => serveStatic("/")),
+  HttpRouter.route(
+    "GET",
+    "/*",
+    (request) => serveStatic(new URL(request.url, "http://localhost").pathname)
+  )
+]);
+var hostProcId = (host) => {
+  if (host === void 0) return void 0;
+  const name = host.split(":")[0].toLowerCase();
+  return name.endsWith(".localhost") ? name.slice(0, -".localhost".length) : void 0;
+};
+var upstreamOptions = (req, port) => ({
+  host: "localhost",
+  port,
+  autoSelectFamily: true,
+  method: req.method,
+  path: req.url,
+  headers: { ...req.headers, host: `localhost:${port}` }
+});
+var refuse = (res, status, message) => {
+  if (!res.headersSent) res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+  res.end(`procdeck: ${message}
+`);
+};
+var proxyRequest = (supervisor, id, req, res) => {
+  const port = supervisor.proxyPort(id);
+  if (port === void 0) {
+    return refuse(res, 503, `"${id}" has no listening port yet \u2014 is it running?`);
+  }
+  const upstream = httpRequest(upstreamOptions(req, port), (upRes) => {
+    res.writeHead(upRes.statusCode ?? 502, upRes.headers);
+    upRes.pipe(res);
+  });
+  upstream.on("error", () => refuse(res, 502, `"${id}" refused the connection on :${port}`));
+  req.pipe(upstream);
+};
+var proxyUpgrade = (supervisor, id, req, socket, head) => {
+  const port = supervisor.proxyPort(id);
+  if (port === void 0) {
+    socket.destroy();
+    return;
+  }
+  const upstream = httpRequest(upstreamOptions(req, port));
+  upstream.on("upgrade", (upRes, upSocket, upHead) => {
+    const lines = ["HTTP/1.1 101 Switching Protocols"];
+    for (let i = 0; i < upRes.rawHeaders.length; i += 2) {
+      lines.push(`${upRes.rawHeaders[i]}: ${upRes.rawHeaders[i + 1]}`);
+    }
+    socket.write(`${lines.join("\r\n")}\r
+\r
+`);
+    if (upHead.length > 0) socket.write(upHead);
+    if (head.length > 0) upSocket.write(head);
+    upSocket.pipe(socket);
+    socket.pipe(upSocket);
+    const drop = () => {
+      upSocket.destroy();
+      socket.destroy();
+    };
+    upSocket.on("error", drop);
+    socket.on("error", drop);
+  });
+  upstream.on("response", (upRes) => {
+    socket.end(`HTTP/1.1 ${upRes.statusCode ?? 502} ${upRes.statusMessage ?? ""}\r
+connection: close\r
+\r
+`);
+  });
+  upstream.on("error", () => socket.destroy());
+  socket.on("error", () => upstream.destroy());
+  upstream.end();
+};
+var handleNode = async (handler, req, res) => {
+  const controller = new AbortController();
+  res.on("close", () => controller.abort());
+  const method = req.method ?? "GET";
+  const request = new Request(`http://localhost${req.url ?? "/"}`, {
+    method,
+    headers: req.headers,
+    body: method === "GET" || method === "HEAD" ? null : Readable.toWeb(req),
+    duplex: "half",
+    signal: controller.signal
+  });
+  try {
+    const response = await handler(request);
+    res.writeHead(response.status, Object.fromEntries(response.headers));
+    if (response.body !== null) {
+      for await (const chunk of response.body) {
+        res.write(chunk);
+      }
+    }
+    res.end();
+  } catch {
+    if (!res.headersSent) res.writeHead(500);
+    res.end();
+  }
+};
+var serve = (supervisor, port, deck) => Effect2.acquireRelease(
+  Effect2.gen(function* () {
+    const { handler, dispose } = HttpRouter.toWebHandler(routes(supervisor, deck), {
+      disableLogger: true
+    });
+    const ids = new Set(supervisor.list().map((info) => info.id));
+    const http = createServer2((req, res) => {
+      const id = hostProcId(req.headers.host);
+      if (id !== void 0 && ids.has(id)) return proxyRequest(supervisor, id, req, res);
+      void handleNode(handler, req, res);
+    });
+    http.on("upgrade", (req, socket, head) => {
+      const id = hostProcId(req.headers.host);
+      if (id === void 0 || !ids.has(id)) return socket.destroy();
+      proxyUpgrade(supervisor, id, req, socket, head);
+    });
+    yield* Effect2.callback((resume) => {
+      http.once("error", (cause) => resume(Effect2.fail(cause)));
+      http.listen(port, () => resume(Effect2.void));
+    });
+    return { http, dispose };
+  }),
+  ({ http, dispose }) => Effect2.promise(async () => {
+    http.closeAllConnections();
+    await new Promise((done) => http.close(() => done()));
+    await dispose();
+  })
+).pipe(Effect2.as(port));
+
+// src/cli.ts
+var configPath = process.argv[2] ?? "procdeck.config.ts";
+var main = Effect3.gen(function* () {
+  const loaded = yield* loadConfig(configPath);
+  const supervisor = yield* makeSupervisor(loaded);
+  const port = yield* serve(supervisor, loaded.config.port ?? DEFAULT_UI_PORT, { name: loaded.name });
+  yield* Effect3.log(`procdeck listening on http://localhost:${port}`);
+  yield* Effect3.never;
+});
+var program = Effect3.scoped(main).pipe(
+  Effect3.catchCause(
+    (cause) => Effect3.gen(function* () {
+      yield* Effect3.logError("procdeck failed", cause);
+      process.exitCode = 1;
+    })
+  )
+);
+var fiber = Effect3.runFork(program);
+var shuttingDown = false;
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    if (shuttingDown) process.exit(1);
+    shuttingDown = true;
+    Effect3.runFork(Effect3.log("shutting down, terminating processes\u2026 (Ctrl-C again to force)"));
+    Effect3.runPromise(Fiber2.interrupt(fiber)).then(
+      () => process.exit(0),
+      () => process.exit(1)
+    );
+  });
+}