relife2 1.0.0

package/dist/cli.js

@@ -0,0 +1,4778 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/jsloader.ts
+var jsloader_exports = {};
+__export(jsloader_exports, {
+  loadJsFile: () => loadJsFile
+});
+import * as fs5 from "node:fs";
+import { createRequire } from "node:module";
+import path6 from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadJsFile(file) {
+  const ext = path6.extname(file).toLowerCase();
+  const source = fs5.readFileSync(file, "utf8");
+  if (ext === ".mjs") return importFreshEs(file);
+  if (ext === ".cjs") return loadCjs(file, source);
+  if (CJS_MARKER.test(source)) return loadCjs(file, source);
+  try {
+    return await importFreshEs(file);
+  } catch {
+    return loadCjs(file, source);
+  }
+}
+function importFreshEs(file) {
+  const url = `${pathToFileURL(file).href}?t=${Date.now()}`;
+  return import(url).then((mod) => mod.default ?? mod);
+}
+function loadCjs(file, source) {
+  try {
+    return compileCjs(file, source);
+  } catch {
+    const require2 = createRequire(import.meta.url);
+    try {
+      return require2(file);
+    } catch (err) {
+      throw new Error(`cannot load config '${file}': ${err.message}`);
+    }
+  }
+}
+function compileCjs(file, source) {
+  const req = createRequire(import.meta.url);
+  const nodeModule = req("node:module");
+  const mod = new nodeModule.Module(file, null);
+  mod.filename = file;
+  mod.paths = nodeModule._nodeModulePaths(path6.dirname(file));
+  mod._compile(source, file);
+  return mod.exports;
+}
+var CJS_MARKER;
+var init_jsloader = __esm({
+  "src/config/jsloader.ts"() {
+    "use strict";
+    CJS_MARKER = /^\s*(?:module\.exports|exports\.[\w$])/m;
+  }
+});
+
+// src/daemon/client.ts
+import { spawn } from "node:child_process";
+import net from "node:net";
+import path3 from "node:path";
+
+// src/ipc/protocol.ts
+var PROTOCOL_VERSION = 1;
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+
+// src/util/fsx.ts
+import fs from "node:fs";
+import path from "node:path";
+function ensureDirSync(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function pathExists(p) {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function atomicWriteFileSync(file, data) {
+  ensureDirSync(path.dirname(file));
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, data, "utf8");
+  try {
+    const fd = fs.openSync(tmp, "r");
+    try {
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+  }
+  fs.renameSync(tmp, file);
+}
+function readJsonFile(file) {
+  if (!pathExists(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  if (!pid || Number.isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+// src/util/time.ts
+function parseTime(v) {
+  if (typeof v === "number") return v;
+  const s = String(v).trim();
+  const m = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/i.exec(s);
+  if (!m || m[1] === void 0) {
+    throw new Error(`invalid time string '${s}' (expected e.g. '500ms', '10s', '1m')`);
+  }
+  const n = Number.parseFloat(m[1]);
+  const unit = (m[2] ?? "s").toLowerCase();
+  const factor = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[unit];
+  if (factor === void 0) throw new Error(`invalid time unit in '${s}'`);
+  return Math.round(n * factor);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/daemon/base.ts
+import fs2 from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+function envDir(name) {
+  const v = process.env[name]?.trim();
+  return v ? path2.resolve(v) : null;
+}
+function dataDir() {
+  const override = envDir("RELIFE2_DIR");
+  if (override !== null) return override;
+  const xdg = envDir("XDG_DATA_HOME");
+  if (xdg !== null) return path2.join(xdg, "relife2");
+  return path2.join(os.homedir(), ".relife2");
+}
+function runtimeDir() {
+  const override = envDir("RELIFE2_DIR");
+  if (override !== null) return override;
+  const xdg = envDir("XDG_RUNTIME_DIR");
+  if (xdg !== null) return path2.join(xdg, "relife2");
+  return dataDir();
+}
+function lockPath(base) {
+  return path2.join(base, "daemon.lock");
+}
+function unixSockPath(base) {
+  return path2.join(base, "relife2.sock");
+}
+function portFilePath(base) {
+  return path2.join(base, "daemon.port");
+}
+function defaultPort(base) {
+  let h = 2166136261;
+  for (let i = 0; i < base.length; i++) {
+    h ^= base.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return 44720 + (h >>> 0) % 1e3;
+}
+function acquireLock(base) {
+  fs2.mkdirSync(base, { recursive: true });
+  const file = lockPath(base);
+  const payload = JSON.stringify({ app: "relife2", pid: process.pid, ts: Date.now() });
+  try {
+    fs2.writeFileSync(file, payload, { flag: "wx" });
+    return {
+      release() {
+        try {
+          fs2.unlinkSync(file);
+        } catch {
+        }
+      }
+    };
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const stale = readLockInfo(file);
+  if (stale !== null && isAlive(stale.pid)) {
+    return null;
+  }
+  try {
+    fs2.unlinkSync(file);
+  } catch {
+  }
+  return acquireLock(base);
+}
+function readLockInfo(file) {
+  if (!pathExists(file)) return null;
+  try {
+    const data = JSON.parse(fs2.readFileSync(file, "utf8"));
+    return typeof data.pid === "number" && Number.isInteger(data.pid) ? { pid: data.pid } : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/daemon/client.ts
+var CONNECT_TIMEOUT = 1500;
+var CALL_TIMEOUT = 3e4;
+async function tryConnect(runtime) {
+  const opts = process.platform === "win32" ? { host: "127.0.0.1", port: currentPort(runtime) } : { path: path3.join(runtime, "relife2.sock") };
+  return new Promise((resolve) => {
+    const sock = net.connect(opts);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve(null);
+    }, CONNECT_TIMEOUT);
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      resolve(sock);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+function currentPort(runtime) {
+  const data = readJsonFile(path3.join(runtime, "daemon.port"));
+  if (typeof data === "number" && Number.isInteger(data)) return data;
+  if (data !== null && typeof data === "object" && typeof data.port === "number") return data.port;
+  return defaultPort(runtime);
+}
+var RpcClient = class {
+  constructor(socket) {
+    this.socket = socket;
+    socket.setEncoding("utf8");
+    socket.on("data", (d) => this.onData(d));
+    socket.on("close", () => this.failAll(new Error("connection to daemon closed")));
+    socket.on("error", () => this.failAll(new Error("connection to daemon failed")));
+  }
+  buffer = "";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  call(method, params, timeoutMs = CALL_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`timeout waiting for daemon method '${method}'`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (v) => resolve(v),
+        reject,
+        timer
+      });
+      this.socket.write(`${JSON.stringify({ id, method, params })}
+`);
+    });
+  }
+  close() {
+    try {
+      this.socket.end();
+    } catch {
+    }
+  }
+  onData(d) {
+    const text = typeof d === "string" ? d : d.toString("utf8");
+    this.buffer += text;
+    let idx = this.buffer.indexOf("\n");
+    while (idx >= 0) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      if (line.trim() !== "") this.onMessage(line);
+      idx = this.buffer.indexOf("\n");
+    }
+  }
+  onMessage(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof msg.id !== "number") return;
+    const entry = this.pending.get(msg.id);
+    if (entry === void 0) return;
+    this.pending.delete(msg.id);
+    clearTimeout(entry.timer);
+    if (msg.ok === true) {
+      entry.resolve(msg.result);
+    } else {
+      entry.reject(new RpcError(msg.error?.code ?? "ERROR", msg.error?.message ?? "daemon error"));
+    }
+  }
+  failAll(err) {
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+async function ensureDaemonClient() {
+  const runtime = runtimeDir();
+  const data = dataDir();
+  let sock = await tryConnect(runtime);
+  if (sock === null) {
+    spawnDaemon();
+    for (let i = 0; i < 100 && sock === null; i++) {
+      await sleep(100);
+      sock = await tryConnect(runtime);
+    }
+  }
+  if (sock === null) {
+    throw new Error(
+      `cannot connect to relife2 daemon (runtime: ${runtime}, data: ${data}); inspect ${path3.join(data, "logs", "daemon.log")}`
+    );
+  }
+  const client = new RpcClient(sock);
+  const ping = await client.call("ping");
+  if (ping.protocol !== PROTOCOL_VERSION) {
+    client.close();
+    throw new Error(
+      `daemon protocol mismatch (daemon: ${ping.protocol}, cli: ${PROTOCOL_VERSION}); run 'relife2 kill' to stop the stale daemon`
+    );
+  }
+  return client;
+}
+function spawnDaemon() {
+  const arg1 = process.argv[1];
+  const isSingleBinary = arg1 === void 0 || !arg1.endsWith(".js") && !arg1.endsWith(".mjs") && !arg1.endsWith(".cjs");
+  if (isSingleBinary) {
+    const child2 = spawn(process.execPath, [], {
+      env: { ...process.env, RELIFE2_DAEMON: "1" },
+      stdio: "ignore",
+      detached: true
+    });
+    child2.unref();
+    return;
+  }
+  const entry = path3.resolve(arg1);
+  const child = spawn(process.execPath, [entry], {
+    env: { ...process.env, RELIFE2_DAEMON: "1" },
+    stdio: "ignore",
+    detached: true
+  });
+  child.unref();
+}
+
+// src/util/args.ts
+function parseCliArgs(args, valueOpts = /* @__PURE__ */ new Set()) {
+  const positionals = [];
+  const opts = /* @__PURE__ */ new Map();
+  const passthrough = [];
+  let afterDashDash = false;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === void 0) break;
+    if (afterDashDash) {
+      passthrough.push(a);
+      i += 1;
+      continue;
+    }
+    if (a === "--") {
+      afterDashDash = true;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const eq = key.indexOf("=");
+      if (eq >= 0) {
+        opts.set(key.slice(0, eq), key.slice(eq + 1));
+        i += 1;
+        continue;
+      }
+      const next = args[i + 1];
+      if (valueOpts.has(key) && next !== void 0 && !next.startsWith("-")) {
+        opts.set(key, next);
+        i += 2;
+      } else {
+        opts.set(key, true);
+        i += 1;
+      }
+      continue;
+    }
+    if (a.startsWith("-") && a.length >= 2) {
+      const key = a.slice(1);
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        opts.set(key, next);
+        i += 2;
+      } else {
+        opts.set(key, true);
+        i += 1;
+      }
+      continue;
+    }
+    positionals.push(a);
+    i += 1;
+  }
+  return { positionals, opts, passthrough };
+}
+function splitArgs(input) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  let i = 0;
+  while (i < input.length) {
+    const c = input[i];
+    if (c === void 0) break;
+    if (quote === null) {
+      if (c === '"' || c === "'") {
+        quote = c;
+      } else if (c === "\\" && i + 1 < input.length) {
+        cur += input[i + 1] ?? "";
+        i += 1;
+      } else if (c === " " || c === "	" || c === "\n") {
+        if (cur !== "") {
+          out.push(cur);
+          cur = "";
+        }
+      } else {
+        cur += c;
+      }
+    } else if (c === quote) {
+      quote = null;
+    } else if (c === "\\" && quote === '"' && i + 1 < input.length) {
+      cur += input[i + 1] ?? "";
+      i += 1;
+    } else {
+      cur += c;
+    }
+    i += 1;
+  }
+  if (cur !== "") out.push(cur);
+  return out;
+}
+
+// src/commands/delete.ts
+async function run(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 delete <name|all>");
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("delete", { name });
+    for (const a of res.apps) {
+      console.log(`ok deleted ${a.name}`);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/describe.ts
+async function run2(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 describe <name>");
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    const rec = await client.call("describe", { name });
+    console.log(JSON.stringify(rec, null, 2));
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/dev.ts
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import * as fs3 from "node:fs";
+import path4 from "node:path";
+var DEV_VALUE_OPTS = /* @__PURE__ */ new Set(["watch", "interpreter", "env", "name", "w"]);
+function hasBun() {
+  try {
+    const r = spawnSync("bun", ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function isBunProject(cwd) {
+  let cur = path4.resolve(cwd);
+  const home = path4.resolve(process.env.HOME ?? "");
+  for (let i = 0; i < 12; i++) {
+    if (fs3.existsSync(path4.join(cur, "bun.lockb")) || fs3.existsSync(path4.join(cur, "bun.lock")))
+      return true;
+    if (cur === home || cur === path4.dirname(cur)) break;
+    cur = path4.dirname(cur);
+  }
+  return false;
+}
+function collectSubDirs(root) {
+  const out = [root];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === "node_modules" || e.name === ".git" || e.name.startsWith(".")) continue;
+      const p = path4.join(dir, e.name);
+      out.push(p);
+      stack.push(p);
+    }
+  }
+  return out;
+}
+async function run3(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    return 0;
+  }
+  const { positionals, opts, passthrough } = parseCliArgs(args, DEV_VALUE_OPTS);
+  const scriptArg = positionals[0];
+  if (!scriptArg) {
+    console.error(
+      "usage: relife2 dev <script> [--watch <paths>] [--hot|--no-hot] [--interpreter <bin>] [-- --args...]"
+    );
+    console.error("  e.g. relife2 dev ./server.ts --watch ./src --hot");
+    console.error("  e.g. relife2 dev ./app.js -- --port 3000");
+    return 1;
+  }
+  const script = path4.resolve(scriptArg);
+  if (!fs3.existsSync(script)) {
+    console.error(`dev: script not found: ${script}`);
+    return 1;
+  }
+  const cwd = path4.dirname(script);
+  const useHot = opts.has("no-hot") ? false : opts.has("hot") ? true : void 0;
+  const watchRaw = opts.get("watch") ?? opts.get("w");
+  const interpreterOpt = opts.get("interpreter") ?? void 0;
+  let interpreter = interpreterOpt;
+  if (!interpreter) {
+    const bunAvailable = hasBun();
+    const looksBun = script.endsWith(".ts") || script.endsWith(".tsx") || isBunProject(cwd);
+    if (bunAvailable && looksBun) interpreter = "bun";
+    else interpreter = "node";
+  }
+  const isBun = interpreter === "bun";
+  const hot = useHot ?? (isBun && (script.endsWith(".ts") || script.endsWith(".tsx")));
+  if (hot && !isBun) {
+    console.error(
+      "dev: --hot requires bun interpreter (use --interpreter bun or run a .ts file with bun available)"
+    );
+    return 1;
+  }
+  if (hot && isBun) {
+    return runBunHot(script, cwd, passthrough, watchRaw);
+  }
+  return runManualWatch(script, cwd, interpreter, passthrough, watchRaw);
+}
+async function runBunHot(script, cwd, appArgs, watchRaw) {
+  const extraWatch = watchRaw ? ["--watch"] : [];
+  const bunArgs = ["--hot", script, ...appArgs];
+  console.log(`dev (bun --hot): bun ${bunArgs.join(" ")}  [cwd ${cwd}]`);
+  if (watchRaw)
+    console.log(`  note: --watch ${watchRaw} is ignored in --hot mode (bun watches imports)`);
+  console.log(`  press Ctrl+C to stop`);
+  const child = spawn2("bun", bunArgs, { cwd, stdio: "inherit", env: process.env });
+  return waitForExit(child);
+}
+async function runManualWatch(script, cwd, interpreter, appArgs, watchRaw) {
+  const targets = [];
+  if (watchRaw) {
+    for (const p of watchRaw.split(",").map((s) => s.trim()).filter(Boolean)) {
+      targets.push(path4.resolve(cwd, p));
+    }
+  } else {
+    targets.push(cwd);
+  }
+  console.log(
+    `dev (watch): ${interpreter} ${path4.basename(script)} ${appArgs.join(" ")}  [cwd ${cwd}]`
+  );
+  console.log(`  watching: ${targets.join(", ")}`);
+  console.log(`  press Ctrl+C to stop`);
+  let child = null;
+  let stopped = false;
+  let restarting = false;
+  let debounce = null;
+  const watchers = [];
+  const startChild = () => {
+    if (stopped) return;
+    const cmd = interpreter === "none" ? script : interpreter;
+    const cmdArgs = interpreter === "none" ? [...appArgs] : [script, ...appArgs];
+    child = spawn2(cmd, cmdArgs, { cwd, stdio: "inherit", env: process.env, detached: false });
+    child.on("exit", (code, signal) => {
+      if (stopped) return;
+      if (restarting) {
+        restarting = false;
+        return;
+      }
+      if (code !== null && code !== 0) {
+        console.log(`dev: process exited with code ${code} \u2014 waiting for file change to restart`);
+      } else if (signal) {
+        console.log(`dev: process killed by ${signal} \u2014 waiting for file change`);
+      } else {
+        console.log(`dev: process exited \u2014 waiting for file change`);
+      }
+    });
+  };
+  const restart = () => {
+    if (child?.pid && !child.killed) {
+      restarting = true;
+      try {
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            if (child?.pid && !child.killed) child.kill("SIGKILL");
+          } catch {
+          }
+        }, 1200);
+      } catch {
+      }
+      child.once("exit", () => {
+        if (stopped) return;
+        console.log(`dev: restarting\u2026`);
+        startChild();
+      });
+    } else {
+      console.log(`dev: restarting\u2026`);
+      startChild();
+    }
+  };
+  const scheduleRestart = (changedPath) => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      console.log(`dev: change detected (${changedPath})`);
+      restart();
+    }, 200);
+  };
+  for (const target of targets) {
+    if (!fs3.existsSync(target)) {
+      console.error(`dev: watch path does not exist: ${target} \u2014 skipping`);
+      continue;
+    }
+    const stat = fs3.statSync(target);
+    if (!stat.isDirectory()) {
+      const dir = path4.dirname(target);
+      const base = path4.basename(target);
+      try {
+        const w = fs3.watch(dir, (_ev, filename) => {
+          if (filename && filename !== base) return;
+          scheduleRestart(target);
+        });
+        watchers.push(w);
+      } catch (err) {
+        console.error(`dev: cannot watch ${dir}: ${err.message}`);
+      }
+      continue;
+    }
+    if (process.platform === "win32" || process.platform === "darwin") {
+      try {
+        const w = fs3.watch(target, { recursive: true }, () => scheduleRestart(target));
+        watchers.push(w);
+      } catch (err) {
+        console.error(`dev: cannot watch ${target}: ${err.message}`);
+      }
+    } else {
+      const dirs = collectSubDirs(target);
+      for (const dir of dirs) {
+        try {
+          const w = fs3.watch(dir, () => scheduleRestart(dir));
+          watchers.push(w);
+        } catch {
+        }
+      }
+    }
+  }
+  const cleanup = () => {
+    stopped = true;
+    if (debounce) clearTimeout(debounce);
+    for (const w of watchers)
+      try {
+        w.close();
+      } catch {
+      }
+    if (child?.pid && !child.killed) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          if (child?.pid && !child.killed) child.kill("SIGKILL");
+        } catch {
+        }
+      }, 800);
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    setTimeout(() => process.exit(0), 400);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    setTimeout(() => process.exit(0), 400);
+  });
+  startChild();
+  return new Promise((resolve) => {
+    const onSig = () => resolve(0);
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+  });
+}
+function waitForExit(child) {
+  return new Promise((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 0));
+    child.on("error", (err) => {
+      console.error(`dev: failed to spawn: ${err.message}`);
+      resolve(1);
+    });
+    process.on("SIGINT", () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 800);
+    });
+    process.on("SIGTERM", () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    });
+  });
+}
+function printUsage() {
+  console.log(`relife2 dev \u2014 run a script with watch+restart (backlog, now ready)
+
+Usage: relife2 dev <script> [--watch <paths>] [--hot|--no-hot] [--interpreter <bin>] [-- --args...]
+
+  <script>           path to .js/.mjs/.ts file (resolved from cwd)
+  --watch <paths>    comma-separated paths to watch (default: script's directory)
+  --hot              force bun --hot (HMR, bun only)
+  --no-hot           force manual watch+restart even for bun/ts
+  --interpreter <bin> node|bun|path (default: auto \u2014 bun if .ts or bun.lockb nearby)
+  --                 app args after -- are passed to the script
+
+Mode:
+  bun + --hot (default for .ts under bun) \u2192  bun --hot <script>  (bun watches imports, instant HMR)
+  otherwise            \u2192  manual fs.watch + SIGTERM\u2192SIGKILL restart (works with node/bun/java\u2026)
+
+Examples:
+  relife2 dev ./server.ts
+  relife2 dev ./app.js --watch ./src,./config
+  relife2 dev ./bot.ts --no-hot --watch ./src
+  relife2 dev ./main.js -- --port 3000
+`);
+}
+
+// src/commands/doctor.ts
+async function run4(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const report = await client.call("doctor", {});
+    let hadErrors = false;
+    for (const check of report.checks) {
+      const icon = check.ok ? "\u2713" : "\u2717";
+      console.log(`${icon} ${check.name}`);
+      for (const issue of check.issues) {
+        const prefix = issue.severity === "error" ? "  \u26A0 ERROR" : issue.severity === "warn" ? "  \u26A0 WARN " : "  \u2713 OK   ";
+        console.log(`${prefix} [${issue.code}] ${issue.message}`);
+        if (issue.severity === "error") hadErrors = true;
+      }
+    }
+    console.log("---");
+    console.log(
+      `checks: ${report.summary.total} total, ${report.summary.ok} ok, ${report.summary.warnings} warnings, ${report.summary.errors} errors`
+    );
+    return hadErrors ? 1 : 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/find.ts
+import * as fs7 from "node:fs";
+import os4 from "node:os";
+import path8 from "node:path";
+
+// src/config/loader.ts
+import * as fs6 from "node:fs";
+import os3 from "node:os";
+import path7 from "node:path";
+
+// src/util/cron.ts
+var FIELD_RANGES = [
+  [0, 59],
+  // minute
+  [0, 23],
+  // hour
+  [1, 31],
+  // day of month
+  [1, 12],
+  // month
+  [0, 6]
+  // day of week (0 = Sunday)
+];
+function assertInRange(v, min, max, field) {
+  if (v < min || v > max) {
+    throw new Error(`cron value ${v} out of range [${min}, ${max}] in field '${field}'`);
+  }
+}
+function parseField(field, min, max) {
+  if (field === "") throw new Error("empty cron field");
+  const values = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    if (part === "") throw new Error("empty cron list element");
+    const stepMatch = /^(.+)\/(\d+)$/.exec(part);
+    const step = stepMatch?.[2] !== void 0 ? Number(stepMatch[2]) : 1;
+    if (step <= 0 || !Number.isInteger(step)) throw new Error(`invalid cron step '${part}'`);
+    const rangePart = stepMatch?.[1] !== void 0 ? stepMatch[1] : part;
+    if (rangePart === "*") {
+      for (let v = min; v <= max; v += step) values.add(v);
+    } else {
+      const rangeMatch = /^(\d+)-(\d+)$/.exec(rangePart);
+      if (rangeMatch !== null) {
+        const start = Number(rangeMatch[1]);
+        const end = Number(rangeMatch[2]);
+        assertInRange(start, min, max, field);
+        assertInRange(end, min, max, field);
+        if (start > end) throw new Error(`invalid cron range '${rangePart}': start > end`);
+        for (let v = start; v <= end; v += step) values.add(v);
+      } else {
+        const v = Number(rangePart);
+        if (!Number.isInteger(v)) {
+          throw new Error(`invalid cron field value '${rangePart}'`);
+        }
+        assertInRange(v, min, max, field);
+        values.add(v);
+      }
+    }
+  }
+  if (values.size === 0) throw new Error(`cron field '${field}' produced no values`);
+  return values;
+}
+function parseCron(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5 || fields[0] === void 0 || fields[1] === void 0 || fields[2] === void 0 || fields[3] === void 0 || fields[4] === void 0) {
+    throw new Error(`cron expression must have 5 fields, got ${fields.length}`);
+  }
+  return [
+    parseField(fields[0], FIELD_RANGES[0][0], FIELD_RANGES[0][1]),
+    parseField(fields[1], FIELD_RANGES[1][0], FIELD_RANGES[1][1]),
+    parseField(fields[2], FIELD_RANGES[2][0], FIELD_RANGES[2][1]),
+    parseField(fields[3], FIELD_RANGES[3][0], FIELD_RANGES[3][1]),
+    parseField(fields[4], FIELD_RANGES[4][0], FIELD_RANGES[4][1])
+  ];
+}
+function cronMatches(expr, date) {
+  const [minutes, hours, dom, months, dow] = parseCron(expr);
+  return minutes.has(date.getMinutes()) && hours.has(date.getHours()) && dom.has(date.getDate()) && months.has(date.getMonth() + 1) && dow.has(date.getDay());
+}
+
+// src/util/dotenv.ts
+function parseDotenv(text) {
+  const out = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    let line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) line = line.slice("export ".length).trim();
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (key === "") continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      const quote = value.charAt(0);
+      const inner = value.slice(1, -1);
+      value = quote === '"' ? inner.replaceAll("\\n", "\n").replaceAll("\\r", "\r").replaceAll("\\t", "	").replaceAll('\\"', '"').replaceAll("\\\\", "\\") : inner;
+    } else {
+      const hash = value.indexOf(" #");
+      if (hash >= 0) value = value.slice(0, hash).trim();
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/util/memory.ts
+function parseMemory(v) {
+  if (typeof v === "number") return Math.max(0, Math.round(v));
+  const s = String(v).trim();
+  const m = /^(\d+(?:\.\d+)?)\s*(k|m|g|t)?b?$/i.exec(s);
+  if (!m || m[1] === void 0) {
+    throw new Error(`invalid memory string '${s}' (expected e.g. '256M', '1G', '512K')`);
+  }
+  const n = Number.parseFloat(m[1]);
+  const unit = (m[2] ?? "").toLowerCase();
+  const factor = {
+    "": 1,
+    k: 1024,
+    m: 1048576,
+    g: 1073741824,
+    t: 1099511627776
+  };
+  const f = factor[unit];
+  if (f === void 0) throw new Error(`invalid memory unit in '${s}'`);
+  return Math.round(n * f);
+}
+
+// src/util/portable.ts
+import * as fs4 from "node:fs";
+import os2 from "node:os";
+import path5 from "node:path";
+function isDir(p) {
+  try {
+    return fs4.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(p) {
+  try {
+    return fs4.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function stripHomePrefix(p) {
+  const m = p.match(/^\/(?:home|Users|opt)\/[^/\\]+[/\\](.*)$/);
+  if (m?.[1] !== void 0) return m[1];
+  const dm = p.match(/^[A-Za-z]:[/\\]+(?:home|Users|opt)[/\\]+[^/\\]+[/\\]+(.*)$/i);
+  if (dm?.[1] !== void 0) return dm[1].replaceAll("\\", "/");
+  const wm = p.match(/^[A-Za-z]:[\\/]+Users[\\/]+[^\\/]+[\\/]+(.*)$/i);
+  if (wm?.[1] !== void 0) return wm[1].replaceAll("\\", "/");
+  return null;
+}
+function searchByBasename(root, basename, maxDepth = 4) {
+  const queue = [{ dir: root, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    if (cur.depth > maxDepth) continue;
+    let entries;
+    try {
+      entries = fs4.readdirSync(cur.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path5.join(cur.dir, e.name);
+      if (e.isFile() && e.name === basename) return full;
+      if (e.isDirectory() && !e.isSymbolicLink()) {
+        if (e.name === "node_modules" || e.name === ".git") continue;
+        const real = (() => {
+          try {
+            return fs4.realpathSync(full);
+          } catch {
+            return full;
+          }
+        })();
+        if (seen.has(real)) continue;
+        seen.add(real);
+        queue.push({ dir: full, depth: cur.depth + 1 });
+      }
+    }
+  }
+  return null;
+}
+function fixCwd(staleCwd, sourceDir) {
+  if (isDir(staleCwd)) return { path: staleCwd, fixed: false };
+  const candidates = [];
+  const tail = stripHomePrefix(staleCwd);
+  if (tail !== null) {
+    candidates.push(path5.join(os2.homedir(), tail));
+    candidates.push(path5.join(path5.dirname(os2.homedir()), tail));
+    candidates.push(path5.join(path5.dirname(sourceDir), tail));
+    if (isDir(sourceDir) && !staleCwd.startsWith(os2.homedir())) candidates.push(sourceDir);
+  }
+  const proj = path5.basename(sourceDir);
+  if (proj) {
+    const marker = `${path5.sep}${proj}${path5.sep}`;
+    const altMarker = `/${proj}/`;
+    const idx = staleCwd.includes(marker) ? staleCwd.lastIndexOf(marker) : staleCwd.lastIndexOf(altMarker);
+    if (idx >= 0) {
+      const suffix = staleCwd.slice(idx + proj.length + 2);
+      candidates.push(path5.join(sourceDir, suffix));
+      candidates.push(path5.join(path5.dirname(sourceDir), proj, suffix));
+    }
+  }
+  for (const c of candidates) {
+    if (c && isDir(c))
+      return { path: c, fixed: true, reason: `cwd '${staleCwd}' not found \u2192 auto-fixed to '${c}'` };
+  }
+  return {
+    path: staleCwd,
+    fixed: false,
+    reason: `cwd '${staleCwd}' not found and no auto-fix candidate exists`
+  };
+}
+function fixScript(staleScript, cwd, sourceDir) {
+  if (isFile(staleScript)) return { path: staleScript, fixed: false };
+  const base = path5.basename(staleScript);
+  const candidates = [];
+  candidates.push(path5.join(cwd, base));
+  candidates.push(path5.join(sourceDir, base));
+  const tail = stripHomePrefix(staleScript);
+  if (tail !== null) {
+    candidates.push(path5.join(os2.homedir(), tail));
+    candidates.push(path5.join(path5.dirname(os2.homedir()), tail));
+    candidates.push(path5.join(sourceDir, tail));
+    const tailParts = tail.split("/");
+    if (tailParts.length > 1) candidates.push(path5.join(sourceDir, tailParts.slice(1).join("/")));
+  }
+  const proj = path5.basename(sourceDir);
+  if (proj) {
+    const marker = `/${proj}/`;
+    const idx = staleScript.lastIndexOf(marker);
+    if (idx >= 0) {
+      const suffix = staleScript.slice(idx + proj.length + 2);
+      candidates.push(path5.join(sourceDir, suffix));
+      candidates.push(path5.join(cwd, suffix));
+    }
+  }
+  const parts = staleScript.split(/[/\\]/).filter(Boolean);
+  if (parts.length >= 2) {
+    const lastTwo = parts.slice(-2).join(path5.sep);
+    candidates.push(path5.join(sourceDir, lastTwo));
+    candidates.push(path5.join(cwd, lastTwo));
+  }
+  for (const c of candidates) {
+    if (c && isFile(c))
+      return {
+        path: c,
+        fixed: true,
+        reason: `script '${staleScript}' not found \u2192 auto-fixed to '${c}'`
+      };
+  }
+  const found = searchByBasename(sourceDir, base, 4);
+  if (found !== null)
+    return {
+      path: found,
+      fixed: true,
+      reason: `script '${staleScript}' not found \u2192 found '${found}' under '${sourceDir}'`
+    };
+  if (cwd !== sourceDir) {
+    const found2 = searchByBasename(cwd, base, 4);
+    if (found2 !== null)
+      return {
+        path: found2,
+        fixed: true,
+        reason: `script '${staleScript}' not found \u2192 found '${found2}' under cwd`
+      };
+  }
+  return {
+    path: staleScript,
+    fixed: false,
+    reason: `script '${staleScript}' not found and no auto-fix candidate exists`
+  };
+}
+
+// src/config/loader.ts
+init_jsloader();
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "script",
+  "args",
+  "interpreter",
+  "cwd",
+  "env",
+  "autorestart",
+  "max_restarts",
+  "restart_delay",
+  "min_uptime",
+  "kill_timeout",
+  "instances",
+  "exec_mode",
+  // M2: logging + env_file + wait_ready (+ pm2 aliases)
+  "out_file",
+  "output",
+  "error_file",
+  "err_file",
+  "merge_logs",
+  "merge",
+  "time",
+  "timestamp",
+  "log_date_format",
+  "wait_ready",
+  "env_file",
+  // M4: memory
+  "max_memory_restart",
+  // M5: scheduling + watch
+  "cron_restart",
+  "watch",
+  "watch_delay"
+]);
+var LATER_KEYS = {
+  user: "M6",
+  group: "M6",
+  uid: "M6",
+  gid: "M6"
+};
+var CONFIG_FILE_RE = /^(?:(?:ecosystem|pm2|relife2)[\w.-]*|[\w.-]*?)\.config\.(?:c?js|mjs|json|ts)$/i;
+function looksLikeConfigFile(file) {
+  return CONFIG_FILE_RE.test(path7.basename(file));
+}
+function findDefaultConfig(cwd) {
+  const candidates = [
+    "relife2.config.ts",
+    "relife2.config.js",
+    "relife2.config.cjs",
+    "relife2.config.mjs",
+    "relife2.config.json",
+    "ecosystem.config.js",
+    "ecosystem.config.cjs",
+    "ecosystem.config.mjs",
+    "ecosystem.config.json",
+    "pm2.config.js",
+    "pm2.config.cjs"
+  ];
+  for (const name of candidates) {
+    const full = path7.join(cwd, name);
+    if (fs6.existsSync(full)) return full;
+  }
+  return null;
+}
+async function loadConfigFile(filePath, opts) {
+  const ext = path7.extname(filePath).toLowerCase();
+  let exported;
+  if (ext === ".json") {
+    exported = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+  } else if (ext === ".ts") {
+    exported = await loadTsFile(filePath);
+  } else {
+    exported = await loadJsFile(filePath);
+    if (typeof exported === "function") {
+      exported = await exported();
+    }
+    if (exported instanceof Promise) exported = await exported;
+  }
+  return normalizeExported(exported, path7.dirname(filePath), opts);
+}
+async function loadTsFile(file) {
+  try {
+    const { pathToFileURL: pathToFileURL2 } = await import("node:url");
+    const url = `${pathToFileURL2(file).href}?t=${Date.now()}`;
+    const mod = await import(url);
+    return mod.default ?? mod;
+  } catch {
+    const raw = fs6.readFileSync(file, "utf8");
+    const stripped = raw.replace(/^\s*import\s+type\s+.*$/gm, "").replace(/:\s*[\w<>[\]|&\s,?]+(?=[=;,\n)}])/g, "").replace(/\s+as\s+const/g, "");
+    const tmp = `${file}.tmp.cjs`;
+    try {
+      fs6.writeFileSync(tmp, stripped, "utf8");
+      const { loadJsFile: lf } = await Promise.resolve().then(() => (init_jsloader(), jsloader_exports));
+      return await lf(tmp);
+    } finally {
+      try {
+        fs6.unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
+}
+function normalizeExported(exported, sourceDir, opts) {
+  let rawApps;
+  if (Array.isArray(exported)) {
+    rawApps = exported;
+  } else if (exported !== null && typeof exported === "object") {
+    rawApps = exported.apps;
+  }
+  if (!Array.isArray(rawApps) || rawApps.length === 0) {
+    throw new ConfigError("config must export { apps: [...] } with at least one app");
+  }
+  const warnings = [];
+  const apps = rawApps.map((raw, i) => normalizeApp(raw, sourceDir, warnings, i, opts?.envName));
+  return { apps, warnings };
+}
+function normalizeApp(raw, sourceDir, warnings, index, envName) {
+  if (raw === null || typeof raw !== "object") {
+    throw new ConfigError(`apps[${index}] must be an object`);
+  }
+  const input = raw;
+  const envProfiles = {};
+  for (const key of Object.keys(input)) {
+    if (key.startsWith("env_")) {
+      const profile = key.slice(4);
+      const val = input[key];
+      if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+        const out = {};
+        for (const [k, v] of Object.entries(val)) {
+          out[k] = v === void 0 || v === null ? "" : String(v);
+        }
+        envProfiles[profile] = out;
+      }
+    }
+  }
+  for (const key of Object.keys(input)) {
+    if (KNOWN_KEYS.has(key)) continue;
+    if (key.startsWith("env_")) continue;
+    const later = LATER_KEYS[key];
+    if (later !== void 0) {
+      warnings.push(`apps[${index}] '${key}' is ignored until milestone ${later} (TODO.md \xA75)`);
+    } else {
+      warnings.push(`apps[${index}] unknown field '${key}' is ignored`);
+    }
+  }
+  const scriptRaw = input.script;
+  if (typeof scriptRaw !== "string" || scriptRaw === "") {
+    throw new ConfigError(`apps[${index}] requires a string 'script'`);
+  }
+  const instances = parseInstances(input.instances, index);
+  const execMode = parseExecMode(input.exec_mode, index);
+  const rawCwd = typeof input.cwd === "string" ? input.cwd : void 0;
+  const cwdRaw = path7.resolve(sourceDir, rawCwd ?? ".");
+  const cwdFix = fixCwd(cwdRaw, sourceDir);
+  const cwd = cwdFix.path;
+  if (cwdFix.fixed && cwdFix.reason) warnings.push(cwdFix.reason);
+  const hasSep = scriptRaw.includes("/") || scriptRaw.includes("\\");
+  const isJsExt = /\.(?:c?js|mjs|ts|mts|cts)$/i.test(scriptRaw);
+  const scriptRawResolved = hasSep || isJsExt ? path7.resolve(cwd, scriptRaw) : scriptRaw;
+  let script = scriptRawResolved;
+  if (path7.isAbsolute(scriptRawResolved)) {
+    const f = fixScript(scriptRawResolved, cwd, sourceDir);
+    if (f.fixed) {
+      warnings.push(f.reason ?? `script '${scriptRawResolved}' \u2192 '${f.path}'`);
+      script = f.path;
+    } else if (!fs6.existsSync(scriptRawResolved) && f.reason) {
+      warnings.push(f.reason);
+    }
+  }
+  const name = typeof input.name === "string" && input.name !== "" ? input.name : defaultName(script);
+  const env = normalizeEnv(input.env, warnings, index);
+  const selectedEnv = envName ?? process.env.NODE_ENV;
+  if (selectedEnv !== void 0 && selectedEnv !== "") {
+    const profile = envProfiles[selectedEnv];
+    if (profile !== void 0) {
+      Object.assign(env, profile);
+    } else if (envName !== void 0) {
+      warnings.push(`apps[${index}] --env '${envName}' has no matching env_${envName} profile`);
+    }
+  }
+  const envFile = typeof input.env_file === "string" && input.env_file !== "" ? input.env_file : void 0;
+  if (envFile !== void 0) {
+    const envPath = path7.resolve(cwd, envFile);
+    let parsed = null;
+    if (fs6.existsSync(envPath) && fs6.statSync(envPath).isFile()) {
+      try {
+        parsed = parseDotenv(fs6.readFileSync(envPath, "utf8"));
+      } catch (err) {
+        warnings.push(
+          `apps[${index}] env_file '${envFile}' could not be read: ${err.message}`
+        );
+      }
+    }
+    if (parsed === null) {
+      warnings.push(`apps[${index}] env_file '${envFile}': ${envPath} not found; ignored`);
+    } else {
+      for (const [k, v] of Object.entries(parsed)) {
+        if (!(k in env) && !(k in process.env)) env[k] = v;
+      }
+    }
+  }
+  return {
+    name,
+    script,
+    args: normalizeArgs(input.args, index),
+    interpreter: typeof input.interpreter === "string" ? input.interpreter : void 0,
+    cwd,
+    env,
+    autorestart: input.autorestart !== false,
+    maxRestarts: toInt(input.max_restarts, 15, "max_restarts", index),
+    restartDelay: toInt(input.restart_delay, 0, "restart_delay", index),
+    minUptime: parseTimeField(input.min_uptime, "1s", "min_uptime", index),
+    killTimeout: toInt(input.kill_timeout, 1600, "kill_timeout", index),
+    outFile: strOrUndef(input.out_file ?? input.output),
+    errFile: strOrUndef(input.error_file ?? input.err_file),
+    mergeLogs: input.merge_logs === true || input.merge === true,
+    time: input.time === true || input.timestamp === true,
+    logDateFormat: strOrUndef(input.log_date_format),
+    waitReady: input.wait_ready === true,
+    envFile,
+    maxMemoryRestart: parseMemoryField(input.max_memory_restart, "max_memory_restart", index),
+    cronRestart: parseCronField(input.cron_restart, "cron_restart", index),
+    watch: parseWatchField(input.watch, "watch", index),
+    watchDelay: toInt(input.watch_delay, 1e3, "watch_delay", index),
+    instances,
+    execMode,
+    envName: selectedEnv,
+    sourceDir
+  };
+}
+function strOrUndef(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function normalizeEnv(env, warnings, index) {
+  if (env === void 0 || env === null) return {};
+  if (typeof env !== "object" || Array.isArray(env)) {
+    warnings.push(`apps[${index}] 'env' must be an object; ignoring`);
+    return {};
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    out[k] = v === void 0 || v === null ? "" : String(v);
+  }
+  return out;
+}
+function normalizeArgs(args, index) {
+  if (args === void 0 || args === null) return [];
+  if (Array.isArray(args)) return args.map((a) => String(a));
+  if (typeof args === "string") return splitArgs(args);
+  throw new ConfigError(`apps[${index}] 'args' must be a string or string[]`);
+}
+function toInt(v, fallback, field, index) {
+  if (v === void 0 || v === null) return fallback;
+  const n = Number(v);
+  if (!Number.isFinite(n)) throw new ConfigError(`apps[${index}] '${field}' must be a number`);
+  return Math.max(0, Math.round(n));
+}
+function parseTimeField(v, fallback, field, index) {
+  if (v === void 0 || v === null) return parseTime(fallback);
+  try {
+    return parseTime(v);
+  } catch (err) {
+    throw new ConfigError(`apps[${index}] '${field}': ${err.message}`);
+  }
+}
+function parseMemoryField(v, field, index) {
+  if (v === void 0 || v === null) return void 0;
+  try {
+    return parseMemory(v);
+  } catch (err) {
+    throw new ConfigError(`apps[${index}] '${field}': ${err.message}`);
+  }
+}
+function parseCronField(v, field, index) {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "string" || v.trim() === "") {
+    throw new ConfigError(`apps[${index}] '${field}' must be a non-empty cron expression string`);
+  }
+  const trimmed = v.trim();
+  const parts = trimmed.split(/\s+/);
+  if (parts.length !== 5) {
+    throw new ConfigError(
+      `apps[${index}] '${field}': invalid cron expression '${v}' (expected 5 fields: 'min hour dom month dow')`
+    );
+  }
+  try {
+    parseCron(trimmed);
+  } catch (err) {
+    throw new ConfigError(
+      `apps[${index}] '${field}': invalid cron expression '${v}': ${err.message}`
+    );
+  }
+  return trimmed;
+}
+function parseWatchField(v, field, index) {
+  if (v === void 0 || v === null) return void 0;
+  if (v === false) return false;
+  if (v === true) return true;
+  if (Array.isArray(v)) {
+    const paths = v.filter((p) => typeof p === "string" && p !== "");
+    if (paths.length === 0) {
+      throw new ConfigError(`apps[${index}] '${field}': array must contain at least one path`);
+    }
+    return paths;
+  }
+  throw new ConfigError(`apps[${index}] '${field}' must be false, true, or an array of paths`);
+}
+function parseInstances(v, index) {
+  if (v === void 0 || v === null) return 1;
+  if (v === "max" || v === "MAX") return os3.cpus().length || 1;
+  const n = Number(v);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new ConfigError(`apps[${index}] 'instances' must be a positive number or 'max'`);
+  }
+  return Math.max(1, Math.round(n));
+}
+function parseExecMode(v, index) {
+  if (v === void 0 || v === null) return "fork";
+  const s = String(v).toLowerCase();
+  if (s === "fork" || s === "fork_mode") return "fork";
+  if (s === "cluster" || s === "cluster_mode") return "cluster";
+  throw new ConfigError(`apps[${index}] 'exec_mode' must be 'fork' or 'cluster'`);
+}
+function defaultName(script) {
+  const base = path7.basename(script);
+  return base.replace(/\.(?:c?js|mjs|ts|mts|cts)$/i, "") || base;
+}
+function normalizeSingleApp(input, sourceDir, envName) {
+  const warnings = [];
+  const effectiveEnv = input._envName ?? envName;
+  const app = normalizeApp(input, sourceDir, warnings, 0, effectiveEnv);
+  return { app, warnings };
+}
+
+// src/commands/find.ts
+var VALUE_OPTS = /* @__PURE__ */ new Set(["root", "depth"]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "vendor",
+  ".next",
+  ".output",
+  "dist",
+  "build",
+  "target",
+  "__pycache__",
+  ".cache",
+  ".pnpm",
+  ".yarn",
+  ".turbo",
+  ".parcel-cache",
+  "Library",
+  "AppData",
+  ".local",
+  // broad but contains share/nvm etc — scanning it is expensive
+  "proc",
+  "sys",
+  "dev"
+]);
+function findConfigs(root, maxDepth) {
+  const out = [];
+  const stack = [{ dir: root, depth: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    if (cur === void 0) break;
+    const { dir, depth } = cur;
+    if (depth > maxDepth) continue;
+    let real;
+    try {
+      real = fs7.realpathSync(dir);
+    } catch {
+      continue;
+    }
+    if (visited.has(real)) continue;
+    visited.add(real);
+    let entries;
+    try {
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      const full = path8.join(dir, ent.name);
+      if (ent.isFile() && looksLikeConfigFile(ent.name)) {
+        out.push(full);
+        continue;
+      }
+      if (!ent.isDirectory()) continue;
+      if (IGNORED_DIRS.has(ent.name)) continue;
+      if (ent.name.startsWith(".") && ![".config"].includes(ent.name)) {
+        if ([".vscode", ".idea", ".github", ".husky"].includes(ent.name)) continue;
+        if (depth < 2) continue;
+      }
+      if (ent.isSymbolicLink()) continue;
+      if (depth + 1 <= maxDepth) stack.push({ dir: full, depth: depth + 1 });
+    }
+  }
+  return out;
+}
+async function enrich(found) {
+  const entries = [];
+  for (const p of found) {
+    try {
+      const loaded = await loadConfigFile(p);
+      entries.push({ path: p, apps: loaded.apps.map((a) => a.name), warnings: loaded.warnings });
+    } catch (err) {
+      entries.push({ path: p, apps: [], error: err.message, warnings: [] });
+    }
+  }
+  return entries;
+}
+function relToRoot(p, root) {
+  const rel = path8.relative(root, p);
+  return rel === "" ? path8.basename(p) : rel;
+}
+async function run5(args) {
+  const { positionals, opts } = parseCliArgs(args, VALUE_OPTS);
+  const wantsStart = positionals[0] === "start" || opts.has("start");
+  const jsonMode = opts.has("json");
+  const allFlag = opts.has("all");
+  let root = opts.get("root");
+  if (root === void 0) {
+    if (allFlag) {
+      root = process.platform === "win32" ? path8.parse(process.cwd()).root : "/";
+    } else {
+      root = os4.homedir() || process.cwd();
+    }
+  }
+  root = path8.resolve(root);
+  let depth = 6;
+  const depthRaw = opts.get("depth");
+  if (depthRaw !== void 0) {
+    const n = Number(depthRaw);
+    if (!Number.isFinite(n) || n < 1 || n > 20) {
+      console.error(`find: --depth must be 1..20, got '${depthRaw}'`);
+      return 1;
+    }
+    depth = Math.round(n);
+  }
+  if (allFlag) depth = Math.max(depth, 8);
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) {
+    console.error(`find: root '${root}' does not exist or is not a directory`);
+    return 1;
+  }
+  if (!jsonMode) console.log(`relife2 find \u2014 scanning ${root} (depth ${depth}) \u2026`);
+  const t0 = Date.now();
+  const foundPaths = findConfigs(root, depth);
+  foundPaths.sort();
+  const enriched = await enrich(foundPaths);
+  const dt = Date.now() - t0;
+  let running = /* @__PURE__ */ new Set();
+  try {
+    const client2 = await ensureDaemonClient();
+    try {
+      const res = await client2.call("list");
+      running = new Set(res.apps.map((a) => a.name));
+      for (const n of [...running]) {
+        const base = n.split(":")[0];
+        if (base !== void 0) running.add(base);
+      }
+    } finally {
+      client2.close();
+    }
+  } catch {
+  }
+  const rows = enriched.map((e) => {
+    const isError = e.error !== void 0;
+    const statuses = e.apps.length === 0 ? isError ? "error" : "empty" : e.apps.every((n) => running.has(n) || running.has(n.split(":")[0])) ? "running" : e.apps.some((n) => running.has(n)) ? "partial" : "stopped";
+    return { ...e, statuses };
+  });
+  if (jsonMode) {
+    const jsonOut = rows.map((r) => ({
+      path: r.path,
+      rel: relToRoot(r.path, root),
+      apps: r.apps,
+      status: r.statuses,
+      error: r.error,
+      warnings: r.warnings
+    }));
+    console.log(
+      JSON.stringify({ root, depth, count: rows.length, tookMs: dt, configs: jsonOut }, null, 2)
+    );
+  } else {
+    if (rows.length === 0) {
+      console.log(`No configs found under ${root} (pattern *.config.{js,cjs,mjs,json,ts})`);
+      console.log(`Hints: try --root <dir> --depth 8, or --all for full scan`);
+      return 0;
+    }
+    console.log(`Found ${rows.length} config(s) in ${dt}ms:
+`);
+    const rels = rows.map((r) => relToRoot(r.path, root));
+    const maxRel = Math.max(12, ...rels.map((s) => s.length), 20);
+    const maxApps = Math.max(4, ...rows.map((r) => r.apps.join(",").length), 12);
+    console.log(`${"path".padEnd(maxRel)}  ${"apps".padEnd(maxApps)}  status   notes`);
+    console.log(`${"-".repeat(maxRel)}  ${"-".repeat(maxApps)}  ------   -----`);
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      const rel = rels[i];
+      const appsStr = r.apps.join(",") || (r.error ? "!" : "-");
+      const note = r.error ? r.error.slice(0, 80) : r.warnings.length > 0 ? r.warnings[0]?.slice(0, 60) ?? "" : "";
+      let line = `${rel.padEnd(maxRel)}  ${appsStr.padEnd(maxApps)}  ${r.statuses.padEnd(6)}   ${note}`;
+      if (r.statuses === "running") line = `\x1B[32m${line}\x1B[0m`;
+      else if (r.statuses === "error") line = `\x1B[31m${line}\x1B[0m`;
+      else if (r.statuses === "stopped") line = `\x1B[90m${line}\x1B[0m`;
+      console.log(line);
+    }
+    console.log(`
+Tip: relife2 find start --root ${root}  \u2192 start all stopped configs`);
+    console.log(`     relife2 find --json | jq .  \u2192 scripting`);
+  }
+  if (!wantsStart) return 0;
+  const toStart = rows.filter(
+    (r) => r.error === void 0 && r.apps.length > 0 && r.statuses !== "running" && r.statuses !== "partial"
+  );
+  if (toStart.length === 0) {
+    if (!jsonMode)
+      console.log("\nNothing to start \u2014 all found configs are already running or broken.");
+    return 0;
+  }
+  if (!jsonMode) console.log(`
+Starting ${toStart.length} config(s) not yet running\u2026
+`);
+  const client = await ensureDaemonClient();
+  try {
+    let started = 0;
+    let failed = 0;
+    for (const r of toStart) {
+      try {
+        const res = await client.call("start", {
+          target: { type: "config", path: r.path }
+        });
+        for (const w of res.warnings ?? []) console.error(`warning ${path8.basename(r.path)}: ${w}`);
+        for (const a of res.apps) {
+          if (a.status === "errored") {
+            console.error(`x ${a.name} (${path8.basename(r.path)}): ${a.message ?? "failed"}`);
+            failed++;
+          } else {
+            console.log(
+              `ok ${a.name}: ${a.status}${a.pid !== void 0 ? ` (pid ${a.pid})` : ""} \u2190 ${relToRoot(r.path, root)}`
+            );
+            if (!a.message?.includes("already")) started++;
+          }
+        }
+      } catch (err) {
+        console.error(`x ${path8.basename(r.path)}: ${err.message}`);
+        failed++;
+      }
+    }
+    if (!jsonMode)
+      console.log(
+        `
+Done: started ${started}, failed ${failed}, skipped ${rows.length - toStart.length} already running`
+      );
+    return failed > 0 ? 1 : 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/flush.ts
+async function run6(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0] ?? "all";
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("flush", {
+      name
+    });
+    for (const a of res.apps) {
+      console.log(`ok flushed ${a.name}${a.files.length > 0 ? "" : " (no log files)"}`);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/fromCaddy.ts
+import * as fs8 from "node:fs";
+import os5 from "node:os";
+import path9 from "node:path";
+var LOOPBACK_RE = /(?:127\.0\.0\.1|localhost|::1):(\d{2,5})/g;
+var ENTRY_PATTERNS = [
+  ".output/server/index.mjs",
+  "dist/server/entry.mjs",
+  "dist/index.mjs",
+  ".output/server/index.js",
+  "dist/server/entry.js",
+  "index.mjs",
+  "index.js",
+  "server.mjs",
+  "server.js",
+  "bot.js",
+  "app.js",
+  "main.js"
+];
+function parseHint(s) {
+  const out = {};
+  for (const part of s.trim().split(/\s+/)) {
+    const eq = part.indexOf("=");
+    if (eq > 0) {
+      const k = part.slice(0, eq).trim();
+      const v = part.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+      if (k) out[k] = v;
+    }
+  }
+  return out;
+}
+function sanitizeName(site, port) {
+  let s = site.trim().split(",")[0].trim();
+  s = s.replace(/^https?:\/\//, "");
+  s = s.split(":")[0];
+  s = s.split("/")[0];
+  if (s.startsWith("*.")) s = s.slice(2);
+  if (!s || s === "*" || s.startsWith(":")) return port ? `app-${port}` : "app";
+  const label = s.split(".")[0];
+  let name = label.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+  if (!name) name = "app";
+  return name.toLowerCase();
+}
+function extractUpstreams(block) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = block.split("\n");
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t || t.startsWith("#")) continue;
+    if (!/reverse_proxy|php_fastcgi/.test(t)) continue;
+    let m;
+    LOOPBACK_RE.lastIndex = 0;
+    while ((m = LOOPBACK_RE.exec(t)) !== null) {
+      const port = Number(m[1]);
+      if (port < 1 || port > 65535) continue;
+      const raw = m[0];
+      if (seen.has(raw)) continue;
+      seen.add(raw);
+      const host = raw.split(":")[0];
+      out.push({ host, port, raw });
+    }
+  }
+  if (out.length === 0) {
+    const blockLoopbacks = [...block.matchAll(LOOPBACK_RE)];
+    for (const b of blockLoopbacks) {
+      const raw = b[0];
+      if (seen.has(raw)) continue;
+      const idx = b.index ?? 0;
+      const before = block.slice(Math.max(0, idx - 200), idx);
+      if (!/reverse_proxy|php_fastcgi/.test(before)) continue;
+      const port = Number(b[1]);
+      if (port < 1 || port > 65535) continue;
+      seen.add(raw);
+      out.push({ host: raw.split(":")[0], port, raw });
+    }
+  }
+  return out;
+}
+function parseCaddyfile(content) {
+  const warnings = [];
+  const sites = [];
+  const lines = content.split("\n");
+  let depth = 0;
+  let pendingHint = null;
+  let currentSite = null;
+  let siteDepth = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed.startsWith("#")) {
+      const hm = trimmed.match(/#\s*relife2:\s*(.*)/i);
+      if (hm) pendingHint = parseHint(hm[1]);
+      continue;
+    }
+    if (trimmed === "") continue;
+    if (currentSite === null && depth === 0) {
+      const braceIdx = rawLine.indexOf("{");
+      if (braceIdx !== -1) {
+        const before = rawLine.slice(0, braceIdx).trim();
+        const firstWord = before.split(/\s+/)[0].toLowerCase();
+        const isDirective = [
+          "handle",
+          "handle_path",
+          "route",
+          "reverse_proxy",
+          "php_fastcgi",
+          "file_server",
+          "encode",
+          "header",
+          "redir",
+          "respond",
+          "tls",
+          "log",
+          "import"
+        ].includes(firstWord);
+        if (!isDirective && before !== "" && before !== "*") {
+          const site = {
+            label: before.split(",")[0].trim(),
+            rawLabel: before,
+            hint: pendingHint,
+            block: "",
+            upstreams: []
+          };
+          pendingHint = null;
+          currentSite = site;
+          siteDepth = depth;
+          sites.push(site);
+          const open2 = (rawLine.match(/\{/g) || []).length;
+          const close2 = (rawLine.match(/\}/g) || []).length;
+          depth += open2 - close2;
+          const after = rawLine.slice(braceIdx + 1);
+          if (after.trim() && !after.trim().startsWith("}")) site.block += `${after}
+`;
+          continue;
+        }
+      } else {
+        let j = i + 1;
+        while (j < lines.length && lines[j].trim() === "") j++;
+        if (j < lines.length && lines[j].trim().startsWith("{")) {
+          const before = trimmed;
+          const firstWord = before.split(/\s+/)[0].toLowerCase();
+          const isDirective = ["handle", "route"].includes(firstWord);
+          if (!isDirective && before !== "") {
+            const site = {
+              label: before.split(",")[0].trim(),
+              rawLabel: before,
+              hint: pendingHint,
+              block: "",
+              upstreams: []
+            };
+            pendingHint = null;
+            currentSite = site;
+            siteDepth = depth;
+            sites.push(site);
+            continue;
+          }
+        }
+      }
+    }
+    if (currentSite !== null) currentSite.block += `${rawLine}
+`;
+    const open = (rawLine.match(/\{/g) || []).length;
+    const close = (rawLine.match(/\}/g) || []).length;
+    depth += open - close;
+    if (depth < 0) depth = 0;
+    if (currentSite !== null && depth <= siteDepth) {
+      currentSite = null;
+      siteDepth = -1;
+    }
+  }
+  for (const s of sites) s.upstreams = extractUpstreams(s.block);
+  return { sites, warnings };
+}
+function findEntry(dir) {
+  for (const pat of ENTRY_PATTERNS) {
+    const p = path9.join(dir, pat);
+    if (fs8.existsSync(p)) return { script: pat, exists: true };
+  }
+  return null;
+}
+function guessDir(site, _port, hint, caddyfileDir) {
+  const warnings = [];
+  if (hint?.dir) {
+    const d = path9.isAbsolute(hint.dir) ? hint.dir : path9.resolve(caddyfileDir, hint.dir);
+    return { dir: d, warnings };
+  }
+  const searchRoots = [];
+  const homedir = os5.homedir();
+  if (homedir) searchRoots.push(homedir);
+  if (caddyfileDir) searchRoots.push(caddyfileDir);
+  if (caddyfileDir) searchRoots.push(path9.resolve(caddyfileDir, ".."));
+  const uniqRoots = [...new Set(searchRoots)].filter(Boolean);
+  const siteName = sanitizeName(site);
+  const candidates = [];
+  if (homedir) candidates.push(path9.join(homedir, siteName));
+  if (homedir) candidates.push(path9.join(homedir, siteName.split("-")[0]));
+  for (const r of uniqRoots) candidates.push(path9.join(r, siteName));
+  const rawDir = site.split(".")[0].replace(/[^a-zA-Z0-9_-]/g, "");
+  if (rawDir && homedir) candidates.push(path9.join(homedir, rawDir));
+  for (const cand of candidates) {
+    if (fs8.existsSync(cand) && fs8.statSync(cand).isDirectory()) {
+      const e = findEntry(cand);
+      if (e) return { dir: cand, warnings };
+    }
+  }
+  const fallback = homedir ? path9.join(homedir, siteName) : path9.join(caddyfileDir || process.cwd(), siteName);
+  warnings.push(
+    `no existing dir found for ${site} \u2192 using fallback ${fallback} (create or set via '# relife2: dir=...')`
+  );
+  return { dir: fallback, warnings };
+}
+async function run7(args) {
+  let caddyfilePath = null;
+  let outPath = null;
+  let dryRun = false;
+  let withCaddy = false;
+  let jsonOut = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--dry-run" || a === "-n") dryRun = true;
+    else if (a === "--with-caddy") withCaddy = true;
+    else if (a === "--json") jsonOut = true;
+    else if (a === "-o" || a === "--output") {
+      outPath = args[i + 1] ?? null;
+      i++;
+    } else if (a.startsWith("-o=")) outPath = a.slice(3);
+    else if (!a.startsWith("-") && caddyfilePath === null) caddyfilePath = a;
+    else if (a === "--help" || a === "-h") {
+      printUsage2();
+      return 0;
+    }
+  }
+  const candidates = [
+    caddyfilePath,
+    caddyfilePath ? null : "./Caddyfile",
+    caddyfilePath ? null : "Caddyfile",
+    caddyfilePath ? null : "/etc/caddy/Caddyfile",
+    caddyfilePath ? null : path9.join(os5.homedir(), "Caddyfile")
+  ].filter(Boolean);
+  let resolvedCaddy = null;
+  let content = null;
+  for (const cand of candidates) {
+    const p = path9.resolve(cand);
+    if (fs8.existsSync(p)) {
+      resolvedCaddy = p;
+      content = fs8.readFileSync(p, "utf8");
+      break;
+    }
+  }
+  if (!resolvedCaddy || content === null) {
+    console.error(`from-caddy: Caddyfile not found. Tried: ${candidates.join(", ")}`);
+    console.error(
+      `  Usage: relife2 from-caddy [/path/to/Caddyfile] [-o relife2.config.cjs] [--dry-run]`
+    );
+    return 1;
+  }
+  const caddyfileDir = path9.dirname(resolvedCaddy);
+  const { sites } = parseCaddyfile(content);
+  if (sites.length === 0) {
+    console.error(`from-caddy: no sites found in ${resolvedCaddy}`);
+    console.error(`  Is it a valid Caddyfile? Sites should look like 'example.com { ... }'`);
+    return 1;
+  }
+  const planned = [];
+  const nameCounts = /* @__PURE__ */ new Map();
+  const portCounts = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const site of sites) {
+    if (site.upstreams.length === 0) {
+      warnings.push(
+        `site '${site.rawLabel}' has no reverse_proxy/php_fastcgi to loopback \u2014 static only, skipping`
+      );
+      continue;
+    }
+    for (const up of site.upstreams) {
+      const isLoopback = up.host === "127.0.0.1" || up.host === "localhost" || up.host === "::1";
+      if (!isLoopback) {
+        warnings.push(`upstream ${up.raw} for site '${site.rawLabel}' is not loopback \u2014 skipping`);
+        continue;
+      }
+      const baseName = site.hint?.name ?? sanitizeName(site.label, up.port);
+      const count = nameCounts.get(baseName) ?? 0;
+      nameCounts.set(baseName, count + 1);
+      let name = baseName;
+      if (count > 0) {
+        const suffix = String(up.port);
+        name = `${baseName}-${suffix}`;
+        const c2 = nameCounts.get(name) ?? 0;
+        if (c2 > 0) name = `${baseName}-${suffix}-${c2}`;
+        nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
+      }
+      const pc = portCounts.get(up.port) ?? 0;
+      portCounts.set(up.port, pc + 1);
+      if (pc > 0)
+        warnings.push(
+          `duplicate upstream port ${up.port} for site '${site.rawLabel}' (also used elsewhere) \u2014 check for collision`
+        );
+      const { dir, warnings: dirWarns } = guessDir(site.label, up.port, site.hint, caddyfileDir);
+      warnings.push(...dirWarns);
+      const entry = site.hint?.script ?? site.hint?.entry ?? null;
+      let exists = false;
+      let relScript = "";
+      if (entry) {
+        relScript = entry;
+        exists = fs8.existsSync(path9.isAbsolute(entry) ? entry : path9.join(dir, entry));
+        if (!exists) warnings.push(`hint script '${entry}' for ${name} not found under ${dir}`);
+      } else {
+        const found = findEntry(dir);
+        if (found) {
+          relScript = found.script;
+          exists = true;
+        } else {
+          relScript = ".output/server/index.mjs";
+          exists = false;
+          warnings.push(
+            `no entry found under ${dir} for ${name} \u2014 using placeholder '${relScript}'`
+          );
+        }
+      }
+      let interpreter = site.hint?.interpreter;
+      if (!interpreter) {
+        if (relScript.endsWith(".mjs") || relScript.endsWith(".ts")) {
+          const hasBun2 = fs8.existsSync(path9.join(dir, "bun.lockb")) || fs8.existsSync(path9.join(dir, "bun.lock"));
+          if (hasBun2) interpreter = "bun";
+        }
+      }
+      const item = {
+        name,
+        site: site.rawLabel,
+        upstream: up,
+        dir,
+        script: relScript,
+        exists,
+        hint: site.hint,
+        warnings: []
+      };
+      item._interpreter = interpreter;
+      planned.push(item);
+    }
+  }
+  if (withCaddy) {
+    const caddyName = "caddy";
+    if (!nameCounts.has(caddyName)) {
+      const item = {
+        name: caddyName,
+        site: "system",
+        upstream: { host: "127.0.0.1", port: 0, raw: "caddy" },
+        dir: caddyfileDir,
+        script: "caddy",
+        exists: true,
+        hint: null,
+        warnings: []
+      };
+      item._interpreter = "none";
+      planned.push(item);
+    }
+  }
+  if (planned.length === 0) {
+    console.error(`from-caddy: no loopback upstreams found in ${resolvedCaddy}`);
+    if (warnings.length) {
+      console.error("  warnings:");
+      for (const w of warnings) console.error(`  - ${w}`);
+    }
+    console.error(
+      "  Tip: add '# relife2: dir=/path/to/app name=myapp' above a site block to hint."
+    );
+    return 1;
+  }
+  if (jsonOut) {
+    console.log(JSON.stringify({ caddyfile: resolvedCaddy, sites, planned, warnings }, null, 2));
+    return 0;
+  }
+  if (dryRun) {
+    console.log(`from-caddy \u2014 dry-run for ${resolvedCaddy}
+`);
+    console.log(`Sites: ${sites.length}, upstreams: ${planned.length}
+`);
+    console.log(
+      `site                               upstream            \u2192 app              dir                              entry`
+    );
+    console.log(
+      `------------------------------------------------------------------------------------------------`
+    );
+    for (const p of planned) {
+      const siteCol = p.site.padEnd(30).slice(0, 30);
+      const upCol = p.upstream.raw.padEnd(18).slice(0, 18);
+      const appCol = p.name.padEnd(16).slice(0, 16);
+      const dirCol = p.dir.padEnd(28).slice(0, 28);
+      const entryCol = p.script + (p.exists ? "" : " (missing)");
+      console.log(`${siteCol}  ${upCol} \u2192 ${appCol}  ${dirCol}  ${entryCol}`);
+    }
+    if (warnings.length) {
+      console.log(`
+Warnings:`);
+      for (const w of warnings) console.log(`  - ${w}`);
+    }
+    console.log(
+      `
+Would write ${planned.length} app(s) to ${outPath ?? "relife2.config.cjs (dry-run, no file written)"}`
+    );
+    console.log(`Run without --dry-run to generate.`);
+    return 0;
+  }
+  const resolvedOut = path9.resolve(outPath ?? "relife2.config.cjs");
+  const appsCode = planned.map((p) => {
+    const interp = p._interpreter;
+    const isCaddy = p.name === "caddy";
+    const env = isCaddy ? {} : { NODE_ENV: "production", HOST: "127.0.0.1", PORT: String(p.upstream.port) };
+    const siteClean = (p.site.split(",")[0] ?? "").trim().replace(/^https?:\/\//, "").split(" ")[0] ?? "";
+    if (!isCaddy && siteClean && siteClean !== "*") {
+      if (siteClean.includes(".")) env.SITE_URL = `https://${siteClean}`;
+    }
+    const lines = [];
+    lines.push(`    {`);
+    lines.push(`      name: '${p.name.replace(/'/g, "\\'")}',`);
+    if (isCaddy) {
+      lines.push(`      script: 'caddy',`);
+      lines.push(
+        `      args: ['run', '--config', '${resolvedCaddy.replace(/'/g, "\\'")}', '--adapter', 'caddyfile'],`
+      );
+      lines.push(`      cwd: '${p.dir.replace(/'/g, "\\'")}',`);
+      lines.push(`      interpreter: 'none',`);
+    } else {
+      const scriptEsc = p.script.replace(/'/g, "\\'");
+      const dirEsc = p.dir.replace(/'/g, "\\'");
+      lines.push(`      script: ${JSON.stringify(p.script)},`);
+      lines.push(`      cwd: ${JSON.stringify(p.dir)},`);
+      if (interp) lines.push(`      interpreter: ${JSON.stringify(interp)},`);
+      lines.push(`      instances: 1,`);
+      lines.push(`      exec_mode: 'fork',`);
+      lines.push(`      autorestart: true,`);
+      lines.push(`      max_memory_restart: '512M',`);
+      lines.push(`      env: {`);
+      for (const [k, v] of Object.entries(env))
+        lines.push(`        ${k}: '${String(v).replace(/'/g, "\\'")}',`);
+      lines.push(`      },`);
+      lines.push(`      out_file: ${JSON.stringify(`./logs/${p.name}-out.log`)},`);
+      lines.push(`      error_file: ${JSON.stringify(`./logs/${p.name}-err.log`)},`);
+      lines.push(`      merge_logs: true,`);
+      lines.push(`      time: true,`);
+    }
+    if (!p.exists && !isCaddy) {
+      lines.push(`      // TODO: entry '${p.script}' not found under ${p.dir}`);
+      lines.push(`      // checked: ${ENTRY_PATTERNS.join(", ")}`);
+      lines.push(`      // fix: set correct 'script' or create placeholder, or add hint:`);
+      lines.push(`      //   # relife2: dir=${p.dir} script=./your/entry.js`);
+    }
+    lines.push(`    },`);
+    return lines.join("\n");
+  }).join("\n");
+  const fileContent = `// Generated by relife2 from-caddy \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+// Source: ${resolvedCaddy}
+// Caddy handles TLS/static/proxy, relife2 supervises apps.
+// Review and adjust cwd/script/PORT before relife2 start.
+module.exports = {
+  apps: [
+${appsCode}
+  ]
+};
+`;
+  fs8.writeFileSync(resolvedOut, fileContent, "utf8");
+  console.log(
+    `from-caddy: parsed ${sites.length} site(s), ${planned.length} upstream(s) from ${resolvedCaddy}`
+  );
+  for (const p of planned) {
+    const status = p.exists ? "found" : "missing";
+    console.log(
+      `  - ${p.site} \u2192 ${p.upstream.raw} \u2192 app '${p.name}' @ ${p.dir} / ${p.script} [${status}]`
+    );
+  }
+  if (warnings.length) {
+    console.log(`
+Warnings:`);
+    for (const w of warnings) console.log(`  - ${w}`);
+  }
+  console.log(`
+Wrote ${resolvedOut} (${planned.length} app(s))`);
+  console.log(
+    `Next: relife2 inspect-config ${path9.basename(resolvedOut)}  \u2192  relife2 start ${path9.basename(resolvedOut)}`
+  );
+  return 0;
+}
+function printUsage2() {
+  console.log(`Usage: relife2 from-caddy [Caddyfile] [-o relife2.config.cjs] [--dry-run] [--json] [--with-caddy]
+
+  Parses a Caddyfile, finds reverse_proxy upstreams to 127.0.0.1/localhost,
+  and generates a relife2 config with one app per upstream.
+
+  Options:
+    Caddyfile            Path to Caddyfile (default: ./Caddyfile, /etc/caddy/Caddyfile, ~/Caddyfile)
+    -o, --output <file>  Output config path (default: ./relife2.config.cjs)
+    -n, --dry-run        Show plan without writing file
+    --json               Output parsed sites/upstreams as JSON (for scripting)
+    --with-caddy         Also add Caddy itself as a managed app (interpreter: none)
+
+  Hints:
+    Add a comment above a site block to override detection:
+      # relife2: dir=/home/debian/uwc name=uwc script=.output/server/index.mjs interpreter=bun
+
+  Example:
+    relife2 from-caddy /etc/caddy/Caddyfile --dry-run
+    relife2 from-caddy -o relife2.config.cjs
+    relife2 from-caddy --with-caddy -o relife2.config.cjs && relife2 start relife2.config.cjs
+`);
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/commands/help.ts
+var HELP_TEXT = `relife2 ${VERSION} \u2014 process manager for Node.js & Bun apps (PM2 alternative, done right)
+
+Usage: relife2 <command> [options]
+
+Commands:
+  start <config|script> [--name <n>] [--env <env>] [--instances <n|max>] [--exec-mode <fork|cluster>] [-- --app-args...]
+                         Start all apps from a config, or one script (M1/M6).
+                         No args \u2192 auto-discovers relife2.config.{ts,js,cjs,mjs,json} or ecosystem.config.* in cwd.
+  --env <name>           Select env profile (merges env_<name> over env; e.g. env_production)
+  --instances <n|max>    Override instances count per app (max = cpu count)
+  --exec-mode <mode>     Override exec_mode (fork|cluster)
+  stop <name|all>        Gracefully stop app(s) (SIGTERM \u2192 kill_timeout \u2192 SIGKILL)
+  restart <name|all>     Stop and respawn app(s)
+  reload <name|all>      Zero-downtime reload (M6): graceful restart, sequentially per instance
+  delete <name|all>      Stop and forget app(s)
+  list | ls | status     Table of managed apps
+  describe <name>        Full state + resolved config of one app
+  ping                   Show daemon status and protocol version
+  logs <name> [--lines N] [-f]
+                         Print app log lines (tail; -f follows)
+  flush [name|all]       Empty the app log file(s)
+  rotate [--max-size <bytes>] [--retain <n>] [name|all]
+                         Rotate log files exceeding the size threshold (M3)
+  doctor                 Run integrity checks on the running daemon (M3)
+  metrics                Show daemon self-metrics + per-app summary (M3)
+  monit [--once]         Live dashboard (M6): cpu/mem/uptime per app, q to quit
+  find [start] [--root <dir>] [--depth <n>] [--json] [--all]
+                         Find all configs under a root (default $HOME, depth 6) \u2014 solves PM2 pain: no need to remember dirs
+                         find        \u2192 list with status (running/stopped/error)
+                         find start  \u2192 start every stopped config (or --start flag)
+  save                   Save current state to disk (snapshot)
+  resurrect              Start all apps from the saved state (M5)
+  import-pm2 [dump.pm2]  Import PM2 dump file (default ~/.pm2/dump.pm2) (M6)
+  from-caddy [Caddyfile] [-o relife2.config.cjs] [--dry-run]
+                         Generate relife2 config from Caddyfile reverse_proxy upstreams (M6)
+  dev <script> [--watch <paths>] [--hot|--no-hot] [--interpreter <bin>] [-- --args...]
+                         Watch+restart for local dev \u2014 bun --hot for .ts, manual fs.watch otherwise
+  daemon-upgrade         Upgrade daemon in place: save \u2192 shutdown old \u2192 spawn new \u2192 resurrect (no second daemon, ADR-0005)
+  startup                Install systemd user unit for autostart on boot (M5, Linux)
+  kill                   Stop the daemon (apps are stopped gracefully)
+  version                Print version and runtime info
+  help                   Show this help
+
+Global flags:
+  -h, --help             Show help
+  -v, --version          Print version
+
+Design: exactly one locked daemon; commands that silently respawn the daemon
+(pm2 update style) do not exist by design. See TODO.md \xA70 (anti-pitfalls).
+`;
+function printHelp() {
+  console.log(HELP_TEXT);
+}
+
+// src/commands/importpm2.ts
+import * as fs9 from "node:fs";
+import os6 from "node:os";
+import path10 from "node:path";
+async function run8(args) {
+  const target = args[0];
+  const dumpPath = target !== void 0 ? path10.resolve(target) : path10.join(os6.homedir(), ".pm2", "dump.pm2");
+  if (!fs9.existsSync(dumpPath)) {
+    console.error(`import-pm2: dump file not found: ${dumpPath}`);
+    console.error(
+      "  pm2 saves to ~/.pm2/dump.pm2 via `pm2 save` \u2014 run that first, or pass a path:"
+    );
+    console.error("  relife2 import-pm2 /path/to/dump.pm2");
+    return 1;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs9.readFileSync(dumpPath, "utf8"));
+  } catch (err) {
+    console.error(`import-pm2: cannot parse ${dumpPath}: ${err.message}`);
+    return 1;
+  }
+  const list = Array.isArray(raw) ? raw : [];
+  if (list.length === 0) {
+    console.error(`import-pm2: dump file is empty: ${dumpPath}`);
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    let imported = 0;
+    for (const entry of list) {
+      const pm2env = entry.pm2_env ?? {};
+      const name = pm2env.name ?? entry.name ?? "app";
+      const script = pm2env.pm_exec_path ?? entry.pm_exec_path;
+      if (typeof script !== "string" || script === "") continue;
+      const cwd = pm2env.pm_cwd ?? entry.pm_cwd ?? process.cwd();
+      const argsRaw = pm2env.args ?? entry.pm_args;
+      const args2 = Array.isArray(argsRaw) ? argsRaw : typeof argsRaw === "string" && argsRaw !== "" ? argsRaw.split(" ") : [];
+      const env = pm2env.env ?? entry.pm_env ?? {};
+      const outFile = pm2env.pm_out_log_path ?? entry.pm_out_log_path;
+      const errFile = pm2env.pm_err_log_path ?? entry.pm_err_log_path;
+      const interpreterRaw = pm2env.exec_interpreter ?? pm2env.interpreter;
+      const interpreter = typeof interpreterRaw === "string" && interpreterRaw !== "" && interpreterRaw !== "none" ? interpreterRaw : void 0;
+      const tmpConfig = {
+        apps: [
+          {
+            name,
+            script,
+            args: args2,
+            cwd,
+            env,
+            out_file: outFile,
+            error_file: errFile,
+            ...interpreter !== void 0 ? { interpreter } : {},
+            autorestart: pm2env.autorestart !== false,
+            instances: pm2env.instances ?? 1,
+            exec_mode: pm2env.exec_mode ?? "fork"
+          }
+        ]
+      };
+      const tmpPath = path10.join(
+        os6.tmpdir(),
+        `relife2-import-${Date.now()}-${Math.random().toString(36).slice(2)}.cjs`
+      );
+      fs9.writeFileSync(tmpPath, `module.exports = ${JSON.stringify(tmpConfig)}`, "utf8");
+      try {
+        const res = await client.call("start", {
+          target: { type: "config", path: tmpPath }
+        });
+        for (const a of res.apps) {
+          if (a.status === "errored") console.error(`x ${a.name}: ${a.message ?? "failed"}`);
+          else {
+            console.log(`ok import ${a.name}: ${a.status}`);
+            imported++;
+          }
+        }
+      } catch (err) {
+        console.error(`import ${name}: ${err.message}`);
+      } finally {
+        try {
+          fs9.unlinkSync(tmpPath);
+        } catch {
+        }
+      }
+    }
+    console.log(`
+imported ${imported} app(s) from ${dumpPath}`);
+    console.log(
+      "Note: review `relife2 list` and `relife2 describe <name>` \u2014 PM2 fields like cron/watch are imported if present."
+    );
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/inspectconfig.ts
+import path11 from "node:path";
+async function run9(args) {
+  const { positionals } = parseCliArgs(args);
+  const file = positionals[0];
+  if (file === void 0) {
+    console.error("usage: relife2 inspect-config <config-file>");
+    return 1;
+  }
+  let loaded;
+  try {
+    loaded = await loadConfigFile(path11.resolve(file));
+  } catch (err) {
+    console.error(`relife2: ${err.message}`);
+    return 1;
+  }
+  console.log(JSON.stringify({ apps: loaded.apps, warnings: loaded.warnings }, null, 2));
+  return 0;
+}
+
+// src/commands/kill.ts
+async function run10(_args) {
+  const sock = await tryConnect(runtimeDir());
+  if (sock === null) {
+    console.log("daemon is not running");
+    return 0;
+  }
+  const client = new RpcClient(sock);
+  try {
+    await client.call("shutdown");
+    console.log("daemon stopped");
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/list.ts
+async function run11(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("list");
+    if (res.apps.length === 0) {
+      console.log("no apps (use `relife2 start <config|script>`)");
+      return 0;
+    }
+    const rows = res.apps.map((a) => ({
+      name: a.name,
+      status: a.status,
+      pid: a.pid !== void 0 ? String(a.pid) : "-",
+      uptime: a.startTime !== void 0 ? formatUptime(Date.now() - a.startTime) : "-",
+      restarts: String(a.restarts),
+      detail: a.error ?? ""
+    }));
+    printTable(rows);
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+function formatUptime(ms) {
+  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 printTable(rows) {
+  const first = rows[0];
+  if (first === void 0) return;
+  const cols = Object.keys(first);
+  const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => (r[c] ?? "").length)));
+  console.log(cols.map((c, i) => c.padEnd(widths[i] ?? 0)).join("  "));
+  for (const row of rows) {
+    console.log(cols.map((c, i) => (row[c] ?? "").padEnd(widths[i] ?? 0)).join("  "));
+  }
+}
+
+// src/commands/logs.ts
+import * as fs10 from "node:fs";
+var VALUE_OPTS2 = /* @__PURE__ */ new Set(["lines"]);
+async function run12(args) {
+  const { positionals, opts } = parseCliArgs(args, VALUE_OPTS2);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 logs <name> [--lines N] [-f]");
+    return 1;
+  }
+  const lines = parseLines(opts.get("lines") ?? opts.get("n"));
+  const follow = opts.has("f") || opts.has("follow");
+  const client = await ensureDaemonClient();
+  try {
+    const info = await client.call("logs", { name });
+    if (info.files.length === 0) {
+      console.log(`no log files configured for ${name}`);
+      return 0;
+    }
+    let printed = 0;
+    for (const file of info.files) {
+      printed += printTail(file, lines);
+    }
+    if (printed === 0) {
+      console.log(`(no log output yet for ${name})`);
+    }
+    if (follow) {
+      console.log(`(following ${name}; press Ctrl+C to stop)`);
+      await followFiles(info.files);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+function parseLines(v) {
+  const n = typeof v === "string" ? Number.parseInt(v, 10) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : 50;
+}
+function printTail(file, lines) {
+  try {
+    const text = fs10.readFileSync(file, "utf8");
+    const all = text.split(/\r?\n/);
+    if (all.length > 0 && all[all.length - 1] === "") all.pop();
+    const slice = all.slice(Math.max(0, all.length - lines));
+    for (const line of slice) {
+      if (line !== "") console.log(line);
+    }
+    return slice.length;
+  } catch {
+    return 0;
+  }
+}
+async function followFiles(files) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    positions.set(f, 0);
+  }
+  process.once("SIGINT", () => process.exit(0));
+  process.once("SIGTERM", () => process.exit(0));
+  for (; ; ) {
+    await sleep(400);
+    for (const f of files) {
+      const size = fileSize(f);
+      const from = positions.get(f) ?? 0;
+      if (size > from) {
+        try {
+          const fd = fs10.openSync(f, "r");
+          try {
+            const buf = Buffer.alloc(size - from);
+            fs10.readSync(fd, buf, 0, buf.length, from);
+            process.stdout.write(buf);
+          } finally {
+            fs10.closeSync(fd);
+          }
+        } catch {
+        }
+      }
+      positions.set(f, size);
+    }
+  }
+}
+function fileSize(file) {
+  try {
+    return fs10.statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+
+// src/commands/metrics.ts
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(1)} ${units[i] ?? "KB"}`;
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 36e5) return `${Math.floor(ms / 6e4)}m ${Math.floor(ms % 6e4 / 1e3)}s`;
+  return `${Math.floor(ms / 36e5)}h ${Math.floor(ms % 36e5 / 6e4)}m`;
+}
+async function run13(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const report = await client.call("metrics", {});
+    console.log(
+      `daemon: pid=${report.daemon.pid} uptime=${fmtDuration(report.daemon.uptimeMs)} protocol=${report.daemon.protocolVersion} apps=${report.daemon.appCount}`
+    );
+    for (const a of report.apps) {
+      const memStr = a.memory !== void 0 ? ` mem=${fmtBytes(a.memory)}` : "";
+      const uptimeStr = a.uptimeMs !== void 0 ? ` uptime=${fmtDuration(a.uptimeMs)}` : "";
+      console.log(
+        `  ${a.name}: pid=${a.pid ?? "?"} status=${a.status} restarts=${a.restarts}${uptimeStr}${memStr}`
+      );
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/monit.ts
+function formatUptime2(ms) {
+  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 formatMem(bytes) {
+  if (bytes === void 0) return "-";
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function pad(s, n) {
+  return s.length >= n ? s.slice(0, n) : s + " ".repeat(n - s.length);
+}
+async function run14(args) {
+  const once = args.includes("--once");
+  const client = await ensureDaemonClient();
+  let running = true;
+  function onExit() {
+    running = false;
+    try {
+      client.close();
+    } catch {
+    }
+    process.stdout.write("\x1B[?25h");
+    process.exit(0);
+  }
+  process.on("SIGINT", onExit);
+  process.on("SIGTERM", onExit);
+  if (!once) process.stdout.write("\x1B[?25l");
+  async function render() {
+    try {
+      const [listRes, metricsRes] = await Promise.all([
+        client.call("list"),
+        client.call("metrics")
+      ]);
+      const memMap = new Map(metricsRes.apps.map((a) => [a.name, a.memory]));
+      const uptimeMap = new Map(metricsRes.apps.map((a) => [a.name, a.uptimeMs]));
+      if (!once) clearScreen();
+      console.log(
+        `relife2 monit \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}  (q to quit${once ? ", --once" : ""})`
+      );
+      console.log(
+        `daemon pid=${metricsRes.daemon.pid} uptime=${formatUptime2(metricsRes.daemon.uptimeMs)} apps=${metricsRes.daemon.appCount}`
+      );
+      console.log("");
+      const header = `${pad("name", 20)} ${pad("status", 10)} ${pad("pid", 8)} ${pad("uptime", 10)} ${pad("restarts", 9)} ${pad("memory", 10)} ${"error"}`;
+      console.log(header);
+      console.log("-".repeat(header.length));
+      for (const app of listRes.apps) {
+        const mem = formatMem(memMap.get(app.name));
+        const up = app.startTime !== void 0 ? formatUptime2(Date.now() - app.startTime) : uptimeMap.get(app.name) !== void 0 ? formatUptime2(uptimeMap.get(app.name)) : "-";
+        const line = `${pad(app.name, 20)} ${pad(app.status, 10)} ${pad(app.pid !== void 0 ? String(app.pid) : "-", 8)} ${pad(up, 10)} ${pad(String(app.restarts), 9)} ${pad(mem, 10)} ${app.error ?? ""}`;
+        let colored = line;
+        if (app.status === "online") colored = `\x1B[32m${line}\x1B[0m`;
+        else if (app.status === "errored") colored = `\x1B[31m${line}\x1B[0m`;
+        else if (app.status === "stopped") colored = `\x1B[90m${line}\x1B[0m`;
+        console.log(colored);
+      }
+      console.log("");
+      if (!once) console.log("Press q or Ctrl+C to exit.");
+    } catch (err) {
+      if (!once) clearScreen();
+      console.error(`monit error: ${err.message}`);
+    }
+  }
+  if (once) {
+    await render();
+    client.close();
+    return 0;
+  }
+  await render();
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", (d) => {
+        const s = d.toString("utf8");
+        if (s === "q" || s === "Q" || s === "") onExit();
+      });
+    } catch {
+    }
+  }
+  while (running) {
+    await new Promise((r) => setTimeout(r, 1e3));
+    if (running) await render();
+  }
+  return 0;
+}
+
+// src/commands/ping.ts
+async function run15(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const info = await client.call("ping");
+    console.log(
+      `relife2 daemon: online (pid ${info.pid}, v${info.version}, protocol ${info.protocol}, uptime ${info.uptime}s)`
+    );
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/reload.ts
+async function run16(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 reload <name|all>");
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call(
+      "reload",
+      { name }
+    );
+    for (const a of res.apps) {
+      console.log(`ok ${a.name}: ${a.status}${a.pid !== void 0 ? ` (pid ${a.pid})` : ""}`);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/restart.ts
+async function run17(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 restart <name|all>");
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call(
+      "restart",
+      { name }
+    );
+    for (const a of res.apps) {
+      console.log(`ok ${a.name}: ${a.status}${a.pid !== void 0 ? ` (pid ${a.pid})` : ""}`);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/resurrect.ts
+async function run18(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("resurrect");
+    let failed = false;
+    for (const app of res.apps) {
+      if (app.status === "errored") {
+        console.error(`x ${app.name}: ${app.message ?? "failed to start"}`);
+        failed = true;
+      } else if (app.message === "already running") {
+        console.log(`  ${app.name}: already running`);
+      } else {
+        console.log(
+          `ok ${app.name}: ${app.status}${app.pid !== void 0 ? ` (pid ${app.pid})` : ""}`
+        );
+      }
+    }
+    return failed ? 1 : 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/rotate.ts
+var VALUE_OPTS3 = /* @__PURE__ */ new Set(["max-size", "retain", "app"]);
+async function run19(args) {
+  const { positionals, opts } = parseCliArgs(args, VALUE_OPTS3);
+  const maxSize = parseSize(opts.get("max-size") ?? "10485760");
+  const retain = parseCount(opts.get("retain") ?? "7");
+  const appName = opts.get("app");
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("rotate", {
+      app: appName ?? positionals[0],
+      maxSizeBytes: maxSize,
+      retain
+    });
+    if (res.length === 0) {
+      console.log("no log files to rotate");
+      return 0;
+    }
+    let totalRotated = 0;
+    for (const entry of res) {
+      if (entry.rotated.length > 0) {
+        console.log(`ok ${entry.name}: rotated ${entry.rotated.length} file(s)`);
+        for (const f of entry.rotated) console.log(`  ${f}`);
+        totalRotated += entry.rotated.length;
+      } else if (entry.skipped.length > 0) {
+        console.log(
+          `ok ${entry.name}: no files exceed the size threshold (${entry.skipped.length} file(s) skipped)`
+        );
+      }
+    }
+    console.log(`---
+${totalRotated} file(s) rotated, retain=${retain}`);
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+function parseSize(v) {
+  if (typeof v !== "string") return 10485760;
+  const m = /^(\d+(?:\.\d+)?)\s*([kmg]?)$/i.exec(v.trim());
+  if (!m) return 10485760;
+  const num = Number.parseFloat(m[1] ?? "");
+  if (!Number.isFinite(num)) return 10485760;
+  const mult = { k: 1024, m: 1024 ** 2, g: 1024 ** 3, K: 1024, M: 1024 ** 2, G: 1024 ** 3 }[m[2] ?? ""] ?? 1;
+  return Math.round(num * mult);
+}
+function parseCount(v) {
+  if (typeof v !== "string") return 7;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : 7;
+}
+
+// src/commands/save.ts
+async function run20(_args) {
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("save");
+    console.log(`state saved (${res.savedAt})`);
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/start.ts
+import path12 from "node:path";
+var VALUE_OPTS4 = /* @__PURE__ */ new Set([
+  "name",
+  "env",
+  "instances",
+  "exec-mode",
+  "exec_mode",
+  "interpreter",
+  "cwd",
+  "max-memory-restart",
+  "max_memory_restart",
+  "kill-timeout",
+  "restart-delay",
+  "watch-delay"
+]);
+async function run21(args) {
+  const { positionals, opts, passthrough } = parseCliArgs(args, VALUE_OPTS4);
+  let target = positionals[0];
+  if (target === void 0) {
+    const found = findDefaultConfig(process.cwd());
+    if (found === null) {
+      console.error(
+        "usage: relife2 start <config|script> [--name <n>] [--env <env>] [--instances <n>] [-- --app-args...]\n  also: relife2 start (no args) will look for relife2.config.{ts,js,cjs,mjs,json} or ecosystem.config.* in cwd"
+      );
+      return 1;
+    }
+    target = found;
+  }
+  const nameVal = opts.get("name");
+  const name = typeof nameVal === "string" && nameVal !== "" ? nameVal : void 0;
+  const envName = opts.get("env") ?? void 0;
+  const cliOverrides = {};
+  if (envName !== void 0 && envName !== "") cliOverrides._envName = envName;
+  if (opts.has("instances")) cliOverrides.instances = opts.get("instances");
+  if (opts.has("exec-mode") || opts.has("exec_mode"))
+    cliOverrides.exec_mode = opts.get("exec-mode") ?? opts.get("exec_mode");
+  if (opts.has("interpreter")) cliOverrides.interpreter = opts.get("interpreter");
+  if (opts.has("cwd")) cliOverrides.cwd = opts.get("cwd");
+  if (opts.has("max-memory-restart") || opts.has("max_memory_restart"))
+    cliOverrides.max_memory_restart = opts.get("max-memory-restart") ?? opts.get("max_memory_restart");
+  if (opts.has("kill-timeout")) cliOverrides.kill_timeout = opts.get("kill-timeout");
+  if (opts.has("restart-delay")) cliOverrides.restart_delay = opts.get("restart-delay");
+  if (opts.has("watch-delay")) cliOverrides.watch_delay = opts.get("watch-delay");
+  const isConfig = looksLikeConfigFile(target);
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call("start", {
+      target: {
+        type: isConfig ? "config" : "script",
+        path: path12.resolve(target),
+        name,
+        args: passthrough.length > 0 ? passthrough : void 0,
+        envName: envName ?? void 0,
+        cliOverrides: Object.keys(cliOverrides).length > 0 ? cliOverrides : void 0
+      }
+    });
+    for (const w of res.warnings ?? []) console.error(`warning: ${w}`);
+    let failed = false;
+    for (const app of res.apps) {
+      if (app.status === "errored") {
+        console.error(`x ${app.name}: ${app.message ?? "failed to start"}`);
+        failed = true;
+      } else {
+        console.log(
+          `ok ${app.name}: ${app.status}${app.pid !== void 0 ? ` (pid ${app.pid})` : ""}${app.message ? ` \u2014 ${app.message}` : ""}`
+        );
+      }
+    }
+    return failed ? 1 : 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/startup.ts
+import { execSync, spawnSync as spawnSync2 } from "node:child_process";
+import * as fs11 from "node:fs";
+import os7 from "node:os";
+import path13 from "node:path";
+import { fileURLToPath } from "node:url";
+var SYSTEMD_USER_DIR = path13.join(os7.homedir(), ".config", "systemd", "user");
+var UNIT_NAME = "relife2.service";
+function getRelife2Bin() {
+  const which = spawnSync2(process.platform === "win32" ? "where" : "which", ["relife2"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const firstLine = which.stdout.trim().split("\n")[0]?.trim();
+  if (which.status === 0 && firstLine !== void 0 && firstLine !== "") {
+    return firstLine;
+  }
+  const arg1 = process.argv[1];
+  const isSingleBinary = arg1 === void 0 || !arg1.endsWith(".js") && !arg1.endsWith(".mjs") && !arg1.endsWith(".cjs");
+  if (isSingleBinary) {
+    return process.execPath;
+  }
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const cliPath = path13.resolve(path13.dirname(thisFile), "..", "cli.js");
+    if (fs11.existsSync(cliPath)) {
+      return `node ${cliPath}`;
+    }
+  } catch {
+  }
+  return `node ${path13.resolve(arg1 ?? process.cwd())}`;
+}
+function generateUnit(bin) {
+  const envHint = process.env.RELIFE2_DIR !== void 0 ? `
+Environment=RELIFE2_DIR=${process.env.RELIFE2_DIR}` : "";
+  return `[Unit]
+Description=relife2 process manager daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${bin}
+Restart=always
+RestartSec=2
+KillMode=process
+Environment=RELIFE2_DAEMON=1${envHint}
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function run22(_args) {
+  if (process.platform === "win32") {
+    console.error(
+      "relife2 startup: systemd is not available on Windows (use Task Scheduler instead)"
+    );
+    return 1;
+  }
+  if (process.platform === "darwin") {
+    console.error("relife2 startup: systemd is not available on macOS (use launchd instead)");
+    return 1;
+  }
+  const bin = getRelife2Bin();
+  const unitContent = generateUnit(bin);
+  const unitPath = path13.join(SYSTEMD_USER_DIR, UNIT_NAME);
+  try {
+    fs11.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+  } catch (err) {
+    console.error(`cannot create ${SYSTEMD_USER_DIR}: ${err.message}`);
+    return 1;
+  }
+  try {
+    fs11.writeFileSync(unitPath, unitContent);
+    console.log(`written systemd user unit: ${unitPath}`);
+  } catch (err) {
+    console.error(`cannot write ${unitPath}: ${err.message}`);
+    return 1;
+  }
+  try {
+    const user = process.env.USER ?? os7.userInfo().username ?? "root";
+    execSync(`loginctl enable-linger ${user}`, { stdio: ["ignore", "pipe", "pipe"] });
+    console.log(`enabled linger for user ${user}`);
+  } catch (err) {
+    console.error(
+      `warning: could not run 'loginctl enable-linger' (is systemd-logind running?): ${err instanceof Error ? err.message : String(err)}`
+    );
+    console.error("your apps will only start after you log in. Run manually:");
+    console.error(`  loginctl enable-linger ${process.env.USER ?? os7.userInfo().username}`);
+  }
+  try {
+    execSync("systemctl --user daemon-reload", { stdio: ["ignore", "pipe", "pipe"] });
+    execSync(`systemctl --user enable ${UNIT_NAME}`, { stdio: ["ignore", "pipe", "pipe"] });
+    console.log(`enabled and reloaded: systemctl --user enable ${UNIT_NAME}`);
+  } catch (err) {
+    console.error(
+      `warning: could not enable unit (is systemd available?): ${err instanceof Error ? err.message : String(err)}`
+    );
+    console.error("run manually:");
+    console.error("  systemctl --user daemon-reload");
+    console.error(`  systemctl --user enable ${UNIT_NAME}`);
+  }
+  console.log("");
+  console.log("relife2 will now start automatically on boot.");
+  console.log(`ExecStart is: ${bin}`);
+  console.log("To start now, run: systemctl --user start relife2.service");
+  console.log("To check status: systemctl --user status relife2.service");
+  return 0;
+}
+
+// src/commands/stop.ts
+async function run23(args) {
+  const { positionals } = parseCliArgs(args);
+  const name = positionals[0];
+  if (name === void 0) {
+    console.error("usage: relife2 stop <name|all>");
+    return 1;
+  }
+  const client = await ensureDaemonClient();
+  try {
+    const res = await client.call(
+      "stop",
+      { name }
+    );
+    for (const a of res.apps) {
+      console.log(`ok ${a.name}: ${a.status}${a.pid !== void 0 ? ` (pid ${a.pid})` : ""}`);
+    }
+    return 0;
+  } finally {
+    client.close();
+  }
+}
+
+// src/commands/upgrade.ts
+async function run24(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage3();
+    return 0;
+  }
+  const runtime = runtimeDir();
+  const data = dataDir();
+  let sock = await tryConnect(runtime);
+  if (sock === null) {
+    console.log("daemon is not running \u2014 starting fresh");
+    spawnDaemon();
+    for (let i = 0; i < 100; i++) {
+      await sleep(100);
+      sock = await tryConnect(runtime);
+      if (sock !== null) break;
+    }
+    if (sock === null) {
+      console.error(`cannot start daemon (runtime: ${runtime}); inspect logs/daemon.log`);
+      return 1;
+    }
+    const client2 = new RpcClient(sock);
+    try {
+      const ping = await client2.call("ping");
+      if (ping.protocol !== PROTOCOL_VERSION) {
+        console.error(
+          `daemon protocol mismatch after start (daemon: ${ping.protocol}, cli: ${PROTOCOL_VERSION})`
+        );
+        return 1;
+      }
+      console.log(`daemon started (pid ${ping.pid}, v${ping.version}, protocol ${ping.protocol})`);
+      return 0;
+    } finally {
+      client2.close();
+    }
+  }
+  const client = new RpcClient(sock);
+  let oldPid;
+  let oldVersion;
+  let appsCount = 0;
+  try {
+    try {
+      const ping = await client.call("ping");
+      oldPid = ping.pid;
+      oldVersion = ping.version;
+      if (ping.protocol !== PROTOCOL_VERSION) {
+        console.error(
+          `warning: daemon protocol ${ping.protocol} != cli ${PROTOCOL_VERSION} \u2014 forcing upgrade`
+        );
+      }
+    } catch {
+    }
+    try {
+      const list = await client.call("list");
+      appsCount = list.apps.length;
+    } catch {
+    }
+    try {
+      await client.call("save");
+    } catch {
+    }
+    console.log(
+      `upgrading daemon${oldPid ? ` pid ${oldPid}` : ""}${oldVersion ? ` v${oldVersion}` : ""} (${appsCount} app(s)) \u2026`
+    );
+    try {
+      await client.call("shutdown");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("connection to daemon closed") && !msg.includes("timeout")) {
+        console.error(`warning: shutdown call failed: ${msg}`);
+      }
+    }
+  } finally {
+    client.close();
+  }
+  for (let i = 0; i < 50; i++) {
+    await sleep(100);
+    const probe = await tryConnect(runtime);
+    if (probe === null) break;
+    probe.destroy();
+    if (i === 49) {
+      console.error("old daemon did not exit within 5s \u2014 try `relife2 kill` and retry");
+      return 1;
+    }
+  }
+  await sleep(200);
+  console.log(`starting new daemon \u2026`);
+  spawnDaemon();
+  let newSock = null;
+  for (let i = 0; i < 100; i++) {
+    await sleep(100);
+    newSock = await tryConnect(runtime);
+    if (newSock !== null) break;
+  }
+  if (newSock === null) {
+    console.error(`new daemon did not appear within 10s (runtime: ${runtime}, data: ${data})`);
+    return 1;
+  }
+  const newClient = new RpcClient(newSock);
+  try {
+    const ping = await newClient.call("ping");
+    if (ping.protocol !== PROTOCOL_VERSION) {
+      console.error(
+        `new daemon protocol mismatch (daemon: ${ping.protocol}, cli: ${PROTOCOL_VERSION})`
+      );
+      return 1;
+    }
+    console.log(`new daemon ready (pid ${ping.pid}, v${ping.version}, protocol ${ping.protocol})`);
+    if (appsCount > 0) {
+      try {
+        const res = await newClient.call(
+          "resurrect"
+        );
+        const started = res.apps.filter(
+          (a) => a.status === "online" || a.status === "starting"
+        ).length;
+        console.log(`resurrected ${started}/${res.apps.length} app(s)`);
+      } catch (err) {
+        console.error(
+          `warning: resurrect failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    try {
+      const list = await newClient.call("list");
+      const online = list.apps.filter(
+        (a) => a.status === "online" || a.status === "starting"
+      ).length;
+      console.log(
+        `daemon-upgrade: ${oldPid ?? "?"} \u2192 ${ping.pid} (${online}/${list.apps.length} online)`
+      );
+    } catch {
+      console.log(`daemon-upgrade: ${oldPid ?? "?"} \u2192 ${ping.pid}`);
+    }
+    return 0;
+  } finally {
+    newClient.close();
+  }
+}
+function printUsage3() {
+  console.log(`relife2 daemon-upgrade \u2014 upgrade daemon without losing app list
+
+Usage: relife2 daemon-upgrade
+
+Flow: save snapshot \u2192 graceful shutdown of old daemon (under lock) \u2192 spawn new
+daemon \u2192 wait for ping (protocol check) \u2192 resurrect apps from snapshot.
+
+If no daemon is running, just starts one. Never spawns a second daemon while
+the old one is alive \u2014 relies on socket bind + lock file for singleton (ADR-0005).
+Use when you updated the relife2 binary or need to cycle the daemon cleanly.
+`);
+}
+
+// src/commands/version.ts
+function printVersion() {
+  console.log(`relife2 ${VERSION}`);
+  const [runtime, runtimeVersion] = detectRuntime();
+  console.log(`runtime: ${runtime} ${runtimeVersion} (${process.platform} ${process.arch})`);
+}
+function detectRuntime() {
+  const g = globalThis;
+  if (g.Bun !== void 0) {
+    return ["bun", g.Bun.version];
+  }
+  return ["node", process.version];
+}
+
+// src/daemon/daemon.ts
+import * as fs18 from "node:fs";
+import os8 from "node:os";
+import path19 from "node:path";
+import * as zlib from "node:zlib";
+
+// src/daemon/applog.ts
+import * as fs12 from "node:fs";
+import path14 from "node:path";
+
+// src/util/datefmt.ts
+function formatDate(pattern, date = /* @__PURE__ */ new Date()) {
+  const y = date.getFullYear();
+  const mo = date.getMonth() + 1;
+  const d = date.getDate();
+  const h = date.getHours();
+  const mi = date.getMinutes();
+  const s = date.getSeconds();
+  const ms = date.getMilliseconds();
+  const offset = date.getTimezoneOffset();
+  const sign = offset <= 0 ? "+" : "-";
+  const abs = Math.abs(offset);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  const z = `${sign}${oh}${om}`;
+  const zz = `${sign}${oh}:${om}`;
+  const ampm = h < 12 ? "AM" : "PM";
+  const pad2 = (n, len = 2) => String(n).padStart(len, "0");
+  return pattern.replaceAll("YYYY", String(y)).replaceAll("YY", String(y).slice(-2)).replaceAll("MM", pad2(mo)).replaceAll("DD", pad2(d)).replaceAll("HH", pad2(h)).replaceAll("mm", pad2(mi)).replaceAll("ss", pad2(s)).replaceAll("SSS", pad2(ms, 3)).replaceAll("ZZ", zz).replaceAll("Z", z).replaceAll("A", ampm).replaceAll("a", ampm.toLowerCase()).replaceAll("M", String(mo)).replaceAll("D", String(d)).replaceAll("H", String(h));
+}
+
+// src/daemon/applog.ts
+var DEFAULT_LOG_FORMAT = "YYYY-MM-DD HH:mm:ss.SSS Z";
+var DEFAULT_LOGS_DIR = (base) => path14.join(base, "logs");
+function resolveLogPaths(app, base) {
+  const safe = app.name.replace(/[^\w.-]/g, "_");
+  const out = app.outFile ? path14.resolve(app.cwd, app.outFile) : path14.join(DEFAULT_LOGS_DIR(base), `${safe}.out.log`);
+  if (app.mergeLogs) return { out, err: null };
+  const err = app.errFile ? path14.resolve(app.cwd, app.errFile) : path14.join(DEFAULT_LOGS_DIR(base), `${safe}.err.log`);
+  return { out, err };
+}
+var AppLogSink = class {
+  constructor(app, paths) {
+    this.paths = paths;
+    const timestamped = app.time || app.logDateFormat !== void 0;
+    this.prefix = timestamped ? `${formatDate(app.logDateFormat ?? DEFAULT_LOG_FORMAT)} ` : "";
+  }
+  prefix;
+  outSink = "";
+  errSink = "";
+  out(chunk) {
+    this.writeLeftover(
+      this.paths.out,
+      chunk,
+      () => this.outSink,
+      (v) => this.outSink = v
+    );
+  }
+  err(chunk) {
+    if (this.paths.err === null) {
+      this.writeLeftover(
+        this.paths.out,
+        chunk,
+        () => this.outSink,
+        (v) => this.outSink = v
+      );
+      return;
+    }
+    this.writeLeftover(
+      this.paths.err,
+      chunk,
+      () => this.errSink,
+      (v) => this.errSink = v
+    );
+  }
+  writeLeftover(target, text, get, set) {
+    const joined = get() + text;
+    const lines = joined.split("\n");
+    set(lines.pop() ?? "");
+    for (const line of lines) {
+      const out = `${this.prefix}${line}
+`;
+      try {
+        ensureDirSync(path14.dirname(target));
+        fs12.appendFileSync(target, out);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/daemon/logger.ts
+import fs13 from "node:fs";
+import path15 from "node:path";
+function createDaemonLogger(base) {
+  const logsDir = path15.join(base, "logs");
+  ensureDirSync(logsDir);
+  const mainFile = path15.join(logsDir, "daemon.log");
+  const outRoot = logsDir;
+  function log(msg, extra) {
+    const line = `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), msg, ...extra ?? {} })}
+`;
+    try {
+      fs13.appendFileSync(mainFile, line);
+    } catch {
+    }
+  }
+  function safeName(name) {
+    return name.replace(/[^\w.-]/g, "_");
+  }
+  function appOut(name, chunk) {
+    try {
+      fs13.appendFileSync(path15.join(outRoot, `${safeName(name)}.out.log`), chunk);
+    } catch {
+    }
+  }
+  function appErr(name, chunk) {
+    try {
+      fs13.appendFileSync(path15.join(outRoot, `${safeName(name)}.err.log`), chunk);
+    } catch {
+    }
+  }
+  return { log, appOut, appErr };
+}
+
+// src/daemon/pm.ts
+import { spawn as spawn3 } from "node:child_process";
+import * as fs15 from "node:fs";
+import path17 from "node:path";
+
+// src/daemon/command.ts
+import { existsSync as existsSync8 } from "node:fs";
+import path16 from "node:path";
+import process2 from "node:process";
+var JS_RE = /\.(?:c?js|mjs|ts|mts|cts)$/i;
+function isJsScript(p) {
+  return JS_RE.test(p);
+}
+function isBunProject2(scriptDir) {
+  let dir = scriptDir;
+  const home = process2.env.HOME ?? "";
+  while (true) {
+    if (existsSync8(path16.join(dir, "bun.lockb")) || existsSync8(path16.join(dir, "bun.lock"))) {
+      return true;
+    }
+    const parent = path16.dirname(dir);
+    if (parent === dir) break;
+    if (home !== "" && dir === home) break;
+    dir = parent;
+  }
+  return false;
+}
+function buildSpawnSpec(app) {
+  const script = app.script;
+  let cmd;
+  let note;
+  if (app.interpreter === "none") {
+    cmd = [script, ...app.args];
+  } else if (app.interpreter !== void 0) {
+    cmd = [app.interpreter, script, ...app.args];
+  } else if (isJsScript(script)) {
+    if (isBunProject2(app.cwd)) {
+      cmd = ["bun", script, ...app.args];
+      note = "auto-detected bun project (bun.lockb/bun.lock); using bun";
+    } else {
+      cmd = [process2.execPath, script, ...app.args];
+    }
+  } else {
+    cmd = [script, ...app.args];
+  }
+  if (!cmd[0]) throw new Error("empty command");
+  const env = {};
+  for (const [k, v] of Object.entries(process2.env)) {
+    if (v !== void 0) env[k] = v;
+  }
+  Object.assign(env, app.env);
+  return { cmd, cwd: app.cwd, env, note };
+}
+
+// src/daemon/memproc.ts
+import { execFileSync } from "node:child_process";
+import * as fs14 from "node:fs";
+function processRss(pid) {
+  if (pid <= 0) return void 0;
+  try {
+    if (process.platform === "linux") {
+      return rssFromProc(pid);
+    }
+    if (process.platform === "darwin") {
+      return rssFromPs(pid);
+    }
+    return rssFromWmic(pid);
+  } catch {
+    return void 0;
+  }
+}
+function rssFromProc(pid) {
+  const status = fs14.readFileSync(`/proc/${pid}/status`, "utf8");
+  const match = /^VmRSS:\s+(\d+)\s+kB/m.exec(status);
+  if (match?.[1] === void 0) return void 0;
+  return Number(match[1]) * 1024;
+}
+function rssFromPs(pid) {
+  const out = execFileSync("ps", ["-o", "rss=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  }).trim();
+  if (out === "") return void 0;
+  const kb = Number(out);
+  if (!Number.isFinite(kb) || kb < 0) return void 0;
+  return Math.round(kb * 1024);
+}
+function rssFromWmic(pid) {
+  const out = execFileSync(
+    "wmic",
+    ["process", "where", `ProcessId=${pid}`, "get", "WorkingSetSize"],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }
+  );
+  const lines = out.split("\n").map((l) => l.trim()).filter((l) => l !== "" && l !== "WorkingSetSize");
+  if (lines.length === 0) return void 0;
+  const bytes = Number(lines[0]);
+  if (!Number.isFinite(bytes) || bytes < 0) return void 0;
+  return Math.round(bytes);
+}
+
+// src/daemon/pm.ts
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var READY_TIMEOUT_MS = 3e4;
+var MEMORY_CHECK_INTERVAL_MS = 5e3;
+var CRON_CHECK_INTERVAL_MS = 6e4;
+function canUseIpc(app) {
+  const interp = app.interpreter;
+  if (interp === "none") return false;
+  if (interp === "bun" || interp === "node") return true;
+  if (interp !== void 0) return false;
+  return process.execPath.toLowerCase().includes("node");
+}
+var ProcessManager = class {
+  constructor(store, logger, base) {
+    this.store = store;
+    this.logger = logger;
+    this.base = base;
+  }
+  timers = /* @__PURE__ */ new Map();
+  killTimers = /* @__PURE__ */ new Map();
+  readyTimers = /* @__PURE__ */ new Map();
+  watchTimers = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Map();
+  memMonitor;
+  cronMonitor;
+  cronLastCheck = 0;
+  spawnApp(record, opts) {
+    this.clearTimer(record.name);
+    this.clearKillTimer(record.name);
+    this.clearReadyTimer(record.name);
+    this.stopWatch(record.name);
+    const cwdFix = fixCwd(record.config.cwd, record.config.sourceDir);
+    if (cwdFix.fixed && cwdFix.reason) {
+      this.logger.log(cwdFix.reason);
+      this.store.journal("app-portable-fix", {
+        name: record.name,
+        field: "cwd",
+        from: record.config.cwd,
+        to: cwdFix.path
+      });
+      record.config.cwd = cwdFix.path;
+    }
+    if (path17.isAbsolute(record.config.script) && !fs15.existsSync(record.config.script)) {
+      const sFix = fixScript(record.config.script, record.config.cwd, record.config.sourceDir);
+      if (sFix.fixed && sFix.reason) {
+        this.logger.log(sFix.reason);
+        this.store.journal("app-portable-fix", {
+          name: record.name,
+          field: "script",
+          from: record.config.script,
+          to: sFix.path
+        });
+        record.config.script = sFix.path;
+      } else if (!sFix.fixed) {
+        this.fail(
+          record,
+          `script not found: '${record.config.script}'. ${sFix.reason ?? ""} Run 'relife2 find --root ${path17.dirname(record.config.sourceDir)}' to locate configs or fix the config.`
+        );
+        this.store.saveSync();
+        return;
+      }
+    }
+    let spec;
+    try {
+      spec = buildSpawnSpec(record.config);
+    } catch (err) {
+      this.fail(record, `spawn config: ${errMsg(err)}`);
+      return;
+    }
+    record.status = "starting";
+    if (opts?.resetCrashStreak !== false) {
+      record.crashStreak = 0;
+    }
+    this.touch(record);
+    record.sink = new AppLogSink(record.config, resolveLogPaths(record.config, this.base));
+    const sink = record.sink;
+    let child;
+    const bin = spec.cmd[0];
+    if (bin === void 0) {
+      this.fail(record, "spawn config: empty command");
+      return;
+    }
+    const useIpc = canUseIpc(record.config);
+    try {
+      child = spawn3(bin, spec.cmd.slice(1), {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio: useIpc ? ["ignore", "pipe", "pipe", "ipc"] : ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32"
+      });
+    } catch (err) {
+      this.fail(record, `spawn failed: ${errMsg(err)}`);
+      return;
+    }
+    record.child = child;
+    record.pid = child.pid;
+    record.startTime = Date.now();
+    record.exitCode = void 0;
+    record.exitSignal = void 0;
+    record.error = void 0;
+    record.stopRequested = void 0;
+    record.exitAt = void 0;
+    record.status = record.config.waitReady ? "starting" : "online";
+    this.touch(record);
+    this.store.journal("app-start", { name: record.name, pid: child.pid, cmd: spec.cmd.join(" ") });
+    this.logger.log(
+      `started ${record.name} (pid ${child.pid}) ${spec.cmd.join(" ")}${spec.note ? ` [${spec.note}]` : ""}`
+    );
+    child.stdout?.on("data", (d) => sink.out(d.toString("utf8")));
+    child.stderr?.on("data", (d) => sink.err(d.toString("utf8")));
+    if (useIpc && record.config.waitReady) {
+      child.on("message", (msg) => {
+        if (record.child !== child) return;
+        if (msg === "ready" || msg !== null && typeof msg === "object" && msg.type === "ready") {
+          this.markReady(record);
+        }
+      });
+      const timer = setTimeout(() => {
+        this.readyTimers.delete(record.name);
+        if (record.child === child && record.status === "starting") {
+          this.logger.log(
+            `app ${record.name} did not send 'ready' within ${READY_TIMEOUT_MS}ms; marking online`
+          );
+          record.status = "online";
+          this.touch(record);
+        }
+      }, READY_TIMEOUT_MS);
+      this.readyTimers.set(record.name, timer);
+    }
+    child.on("error", (err) => this.fail(record, `process error: ${errMsg(err)}`));
+    child.on("exit", (code, signal) => this.onExit(record, code, signal));
+    this.maybeStartMemMonitor();
+    this.maybeStartWatch(record);
+    this.maybeStartCronMonitor();
+  }
+  maybeStartMemMonitor() {
+    if (this.memMonitor !== void 0) return;
+    const anyLimited = [...this.store.apps.values()].some(
+      (rec) => rec.config.maxMemoryRestart !== void 0 && rec.config.maxMemoryRestart > 0
+    );
+    if (!anyLimited) return;
+    this.memMonitor = setInterval(() => this.checkMemory(), MEMORY_CHECK_INTERVAL_MS);
+    if (typeof this.memMonitor.unref === "function") this.memMonitor.unref();
+  }
+  checkMemory() {
+    for (const rec of this.store.apps.values()) {
+      const limit = rec.config.maxMemoryRestart;
+      if (limit === void 0 || limit <= 0) continue;
+      const pid = rec.pid;
+      if (pid === void 0) continue;
+      const rss = processRss(pid);
+      if (rss === void 0) continue;
+      if (rss > limit) {
+        this.logger.log(
+          `app ${rec.name} exceeded memory limit (${rss} > ${limit} bytes); restarting`
+        );
+        this.store.journal("app-restart-memory", {
+          name: rec.name,
+          pid,
+          rss,
+          limit
+        });
+        this.stop(rec, "restart");
+      }
+    }
+  }
+  /** Marks a wait_ready app as online once it signals readiness over IPC. */
+  markReady(record) {
+    const t = this.readyTimers.get(record.name);
+    if (t !== void 0) {
+      clearTimeout(t);
+      this.readyTimers.delete(record.name);
+    }
+    if (record.status === "starting") {
+      record.status = "online";
+      this.store.journal("app-ready", { name: record.name });
+      this.logger.log(`app ${record.name} ready`);
+      this.touch(record);
+    }
+  }
+  /** Graceful stop. `reason === 'restart'` respawns after the process actually exits. */
+  stop(record, reason) {
+    this.clearTimer(record.name);
+    this.clearKillTimer(record.name);
+    this.clearReadyTimer(record.name);
+    this.stopWatch(record.name);
+    record.stopRequested = reason;
+    if (record.pid === void 0) {
+      if (reason === "restart") {
+        if (record.status === "stopped" || record.status === "errored") {
+          record.stopRequested = void 0;
+          this.spawnApp(record);
+        }
+        return;
+      }
+      this.setStateStopped(record);
+      return;
+    }
+    record.status = "stopping";
+    this.touch(record);
+    this.store.journal("app-stop", { name: record.name, reason });
+    this.signalTree(record, "SIGTERM");
+    const timeout = record.config.killTimeout;
+    this.killTimers.set(
+      record.name,
+      setTimeout(() => {
+        this.killTimers.delete(record.name);
+        if (record.pid !== void 0) {
+          this.logger.log(`kill_timeout reached for ${record.name}; sending SIGKILL`);
+          this.signalTree(record, "SIGKILL");
+        }
+      }, timeout)
+    );
+  }
+  stopAll(reason) {
+    for (const record of this.store.apps.values()) {
+      this.stop(record, reason);
+    }
+  }
+  waitForAllStopped(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve) => {
+      const tick = () => {
+        const running = [...this.store.apps.values()].some((r) => r.pid !== void 0);
+        if (!running || Date.now() >= deadline) {
+          resolve();
+          return;
+        }
+        setTimeout(tick, 100);
+      };
+      tick();
+    });
+  }
+  onExit(record, code, signal) {
+    if (!record.child) return;
+    record.child = void 0;
+    record.pid = void 0;
+    record.exitCode = code;
+    record.exitSignal = signal;
+    record.exitAt = Date.now();
+    this.clearKillTimer(record.name);
+    const uptime = record.startTime !== void 0 ? Math.max(0, Date.now() - record.startTime) : 0;
+    this.store.journal("app-exit", { name: record.name, code, signal, uptime });
+    this.logger.log(`app ${record.name} exited (code=${code} signal=${signal} uptime=${uptime}ms)`);
+    const reason = record.stopRequested;
+    if (reason !== void 0) {
+      record.stopRequested = void 0;
+      if (reason === "restart") {
+        this.spawnApp(record);
+      } else {
+        this.setStateStopped(record);
+      }
+      return;
+    }
+    if (uptime >= record.config.minUptime) {
+      record.crashStreak = 0;
+    } else {
+      record.crashStreak += 1;
+    }
+    this.touch(record);
+    if (!record.config.autorestart) {
+      this.setStateStopped(record);
+      return;
+    }
+    if (record.crashStreak > record.config.maxRestarts) {
+      record.status = "errored";
+      record.error = `exited ${String(code)} after ${record.crashStreak} crashes inside min_uptime (${record.config.minUptime}ms); max_restarts=${record.config.maxRestarts}`;
+      this.store.journal("app-errored", { name: record.name, error: record.error });
+      this.touch(record);
+      this.logger.log(`app ${record.name} entered errored state: ${record.error}`);
+      return;
+    }
+    record.restarts += 1;
+    record.status = "restarting";
+    this.store.journal("app-restart-scheduled", { name: record.name, restarts: record.restarts });
+    this.touch(record);
+    this.timers.set(
+      record.name,
+      setTimeout(() => {
+        this.timers.delete(record.name);
+        if (record.status === "restarting") {
+          this.spawnApp(record, { resetCrashStreak: false });
+        }
+      }, record.config.restartDelay)
+    );
+  }
+  fail(record, message) {
+    record.child = void 0;
+    record.pid = void 0;
+    record.status = "errored";
+    record.error = message;
+    this.store.journal("app-errored", { name: record.name, error: message });
+    this.touch(record);
+    this.logger.log(`app ${record.name} errored: ${message}`);
+  }
+  setStateStopped(record) {
+    record.status = "stopped";
+    this.store.journal("app-stopped", { name: record.name });
+    this.touch(record);
+    this.logger.log(`app ${record.name} stopped`);
+  }
+  signalTree(record, signal) {
+    const pid = record.pid;
+    if (pid === void 0) return;
+    if (process.platform === "win32") {
+      try {
+        spawn3("taskkill", ["/pid", String(pid), "/T", "/F"]);
+      } catch {
+      }
+      return;
+    }
+    try {
+      process.kill(-pid, signal);
+    } catch {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    }
+  }
+  clearTimer(name) {
+    const t = this.timers.get(name);
+    if (t !== void 0) {
+      clearTimeout(t);
+      this.timers.delete(name);
+    }
+  }
+  clearKillTimer(name) {
+    const t = this.killTimers.get(name);
+    if (t !== void 0) {
+      clearTimeout(t);
+      this.killTimers.delete(name);
+    }
+  }
+  clearReadyTimer(name) {
+    const t = this.readyTimers.get(name);
+    if (t !== void 0) {
+      clearTimeout(t);
+      this.readyTimers.delete(name);
+    }
+  }
+  /** Stops the background memory monitor (called during shutdown). */
+  stopMemMonitor() {
+    if (this.memMonitor !== void 0) {
+      clearInterval(this.memMonitor);
+      this.memMonitor = void 0;
+    }
+  }
+  /** Stops all watch + cron monitors (called during shutdown). */
+  stopAllMonitors() {
+    this.stopMemMonitor();
+    if (this.cronMonitor !== void 0) {
+      clearInterval(this.cronMonitor);
+      this.cronMonitor = void 0;
+    }
+    for (const watchers of this.watchers.values()) {
+      for (const w of watchers) {
+        try {
+          w.close();
+        } catch {
+        }
+      }
+    }
+    this.watchers.clear();
+    for (const t of this.watchTimers.values()) clearTimeout(t);
+    this.watchTimers.clear();
+  }
+  // ─── Watch ──────────────────────────────────────────────────────────────
+  maybeStartWatch(record) {
+    const watch3 = record.config.watch;
+    if (watch3 === void 0 || watch3 === false) return;
+    if (this.watchers.has(record.name)) return;
+    const rawPaths = Array.isArray(watch3) ? watch3.map((p) => path17.resolve(record.config.cwd, p)) : [record.config.cwd];
+    const watchers = [];
+    for (const target of rawPaths) {
+      try {
+        if (!fs15.existsSync(target)) {
+          this.logger.log(`watch: path '${target}' does not exist yet; skipping`);
+          continue;
+        }
+        const stat = fs15.statSync(target);
+        if (!stat.isDirectory()) {
+          const dir = path17.dirname(target);
+          const base = path17.basename(target);
+          const watcher = fs15.watch(dir, (_eventType, filename) => {
+            if (filename !== null && filename !== base) return;
+            this.onWatchChange(record.name, target);
+          });
+          watchers.push(watcher);
+          continue;
+        }
+        if (process.platform === "win32" || process.platform === "darwin") {
+          const watcher = fs15.watch(target, { recursive: true }, () => {
+            this.onWatchChange(record.name, target);
+          });
+          watchers.push(watcher);
+        } else {
+          const dirs = this.collectSubDirs(target);
+          for (const dir of dirs) {
+            try {
+              const watcher = fs15.watch(dir, () => {
+                this.onWatchChange(record.name, target);
+              });
+              watchers.push(watcher);
+            } catch (err) {
+              this.logger.log(`watch: cannot watch '${dir}': ${errMsg(err)}`);
+            }
+          }
+        }
+      } catch (err) {
+        this.logger.log(`watch: cannot watch '${target}': ${errMsg(err)}`);
+      }
+    }
+    if (watchers.length > 0) {
+      this.watchers.set(record.name, watchers);
+      this.logger.log(`watch: started for ${record.name} (${watchers.length} path(s))`);
+    }
+  }
+  /** Collects `root` and all its nested sub-directories (BFS, ignores errors/symlink loops). */
+  collectSubDirs(root) {
+    const out = [root];
+    const seen = /* @__PURE__ */ new Set([root]);
+    const queue = [root];
+    while (queue.length > 0) {
+      const dir = queue.shift();
+      let entries;
+      try {
+        entries = fs15.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".")) continue;
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        const full = path17.join(dir, entry.name);
+        if (seen.has(full)) continue;
+        seen.add(full);
+        out.push(full);
+        queue.push(full);
+      }
+    }
+    return out;
+  }
+  onWatchChange(name, dir) {
+    const existing = this.watchTimers.get(name);
+    if (existing !== void 0) clearTimeout(existing);
+    const rec = this.store.apps.get(name);
+    if (rec === void 0) return;
+    const delay = rec.config.watchDelay ?? 1e3;
+    this.watchTimers.set(
+      name,
+      setTimeout(() => {
+        this.watchTimers.delete(name);
+        if (rec.pid !== void 0 && (rec.status === "online" || rec.status === "starting")) {
+          this.logger.log(`watch: change detected in ${dir}; restarting ${name}`);
+          this.store.journal("app-restart-watch", { name, dir });
+          this.stop(rec, "restart");
+        }
+      }, delay)
+    );
+  }
+  /** Stops and removes all watchers for a single app (called on stop/spawn). */
+  stopWatch(name) {
+    const watchers = this.watchers.get(name);
+    if (watchers !== void 0) {
+      for (const w of watchers) {
+        try {
+          w.close();
+        } catch {
+        }
+      }
+      this.watchers.delete(name);
+    }
+    const t = this.watchTimers.get(name);
+    if (t !== void 0) {
+      clearTimeout(t);
+      this.watchTimers.delete(name);
+    }
+  }
+  // ─── Cron ───────────────────────────────────────────────────────────────
+  maybeStartCronMonitor() {
+    if (this.cronMonitor !== void 0) return;
+    const anyCron = [...this.store.apps.values()].some(
+      (rec) => rec.config.cronRestart !== void 0
+    );
+    if (!anyCron) return;
+    this.cronMonitor = setInterval(() => this.checkCron(), CRON_CHECK_INTERVAL_MS);
+    if (typeof this.cronMonitor.unref === "function") this.cronMonitor.unref();
+    this.checkCron();
+  }
+  checkCron() {
+    const now = Date.now();
+    const currentMinute = Math.floor(now / 6e4);
+    if (currentMinute === this.cronLastCheck) return;
+    this.cronLastCheck = currentMinute;
+    for (const rec of this.store.apps.values()) {
+      const expr = rec.config.cronRestart;
+      if (expr === void 0) continue;
+      try {
+        if (cronMatches(expr, new Date(now))) {
+          this.logger.log(`cron: '${expr}' matched for ${rec.name}; restarting`);
+          this.store.journal("app-restart-cron", { name: rec.name, expr });
+          this.stop(rec, "restart");
+        }
+      } catch (err) {
+        this.logger.log(`cron: error checking '${expr}' for ${rec.name}: ${errMsg(err)}`);
+      }
+    }
+  }
+  touch(_record) {
+    this.store.saveSync();
+  }
+  /** Returns the daemon's own RSS in bytes (for self-metrics). */
+  daemonMemory() {
+    try {
+      return process.memoryUsage().rss;
+    } catch {
+      return 0;
+    }
+  }
+  /** Returns a sanitized snapshot of the managed apps for the metrics command. */
+  appMetrics() {
+    return [...this.store.apps.values()].map((rec) => ({
+      name: rec.name,
+      pid: rec.pid,
+      status: rec.status,
+      uptimeMs: rec.startTime !== void 0 ? Date.now() - rec.startTime : void 0,
+      restarts: rec.restarts,
+      memory: rec.pid !== void 0 ? processRss(rec.pid) : void 0
+    }));
+  }
+};
+
+// src/daemon/state.ts
+import fs16 from "node:fs";
+import path18 from "node:path";
+var StateStore = class {
+  apps = /* @__PURE__ */ new Map();
+  snapshotPath;
+  journalPath;
+  constructor(base) {
+    const stateDir = path18.join(base, "state");
+    ensureDirSync(stateDir);
+    this.snapshotPath = path18.join(stateDir, "snapshot.json");
+    this.journalPath = path18.join(stateDir, "journal.jsonl");
+  }
+  load() {
+    const data = readJsonFile(this.snapshotPath);
+    if (!data?.apps) return;
+    for (const [name, rec] of Object.entries(data.apps)) {
+      if (rec === null || typeof rec !== "object" || rec.config === void 0) continue;
+      this.apps.set(name, {
+        name: rec.name ?? name,
+        config: rec.config,
+        status: rec.status ?? "stopped",
+        pid: typeof rec.pid === "number" ? rec.pid : void 0,
+        startTime: void 0,
+        exitAt: rec.exitAt,
+        exitCode: rec.exitCode,
+        exitSignal: rec.exitSignal,
+        restarts: rec.restarts ?? 0,
+        crashStreak: rec.crashStreak ?? 0,
+        error: rec.error
+      });
+    }
+  }
+  saveSync() {
+    const appsObj = {};
+    for (const [name, rec] of this.apps) {
+      const { child: _child, sink: _sink, ...rest } = rec;
+      appsObj[name] = rest;
+    }
+    atomicWriteFileSync(
+      this.snapshotPath,
+      JSON.stringify({ schema: 1, savedAt: (/* @__PURE__ */ new Date()).toISOString(), apps: appsObj }, null, 2)
+    );
+  }
+  journal(type, data) {
+    const line = `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), type, ...data ?? {} })}
+`;
+    try {
+      fs16.appendFileSync(this.journalPath, line);
+    } catch {
+    }
+  }
+  requireApp(name) {
+    const rec = this.apps.get(name);
+    if (!rec) throw new RpcError("NOT_FOUND", `app '${name}' is not in this daemon's list`);
+    return rec;
+  }
+};
+
+// src/daemon/transport.ts
+import fs17 from "node:fs";
+import net2 from "node:net";
+async function createDaemonTransport(base) {
+  return process.platform === "win32" ? createWinTransport(base) : createPosixTransport(base);
+}
+async function createPosixTransport(base) {
+  const sockPath = unixSockPath(base);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const server = net2.createServer();
+    const err = await listenOnce(server, sockPath);
+    if (err === null) return serverTransport(server, sockPath);
+    if (err.code !== "EADDRINUSE") return null;
+    if (await probeActive(sockPath)) return null;
+    try {
+      fs17.unlinkSync(sockPath);
+    } catch {
+    }
+  }
+  return null;
+}
+async function createWinTransport(base) {
+  const preferred = readPortFile(base) ?? defaultPort(base);
+  for (let port = preferred; port < preferred + 20; port++) {
+    const server = net2.createServer();
+    const err = await listenOnce(server, { host: "127.0.0.1", port });
+    if (err === null) {
+      writePortFile(base, port);
+      return serverTransport(server, `127.0.0.1:${port}`);
+    }
+    if (err.code !== "EADDRINUSE") return null;
+  }
+  return null;
+}
+function serverTransport(server, address) {
+  return {
+    address: () => address,
+    close: () => server.close(),
+    onConnection: (cb) => server.on("connection", cb)
+  };
+}
+function listenOnce(server, addr) {
+  return new Promise((resolve) => {
+    server.once("error", (err) => resolve(err));
+    server.once("listening", () => resolve(null));
+    server.listen(addr);
+  });
+}
+function probeActive(sockPath) {
+  return new Promise((resolve) => {
+    const sock = net2.connect(sockPath);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve(false);
+    }, 400);
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve(true);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+function readPortFile(base) {
+  try {
+    const raw = fs17.readFileSync(portFilePath(base), "utf8");
+    return Number.parseInt(raw.trim(), 10) || null;
+  } catch {
+    return null;
+  }
+}
+function writePortFile(base, port) {
+  try {
+    fs17.writeFileSync(portFilePath(base), String(port));
+  } catch {
+  }
+}
+
+// src/daemon/daemon.ts
+async function runDaemon() {
+  const data = dataDir();
+  const runtime = runtimeDir();
+  ensureDirSync(path19.join(data, "logs"));
+  const logger = createDaemonLogger(data);
+  logger.log("daemon starting", { pid: process.pid, version: VERSION, platform: process.platform });
+  const lock = acquireLock(runtime);
+  if (lock === null) {
+    logger.log("another daemon is already running; exiting");
+    return;
+  }
+  const transport = await createDaemonTransport(runtime);
+  if (transport === null) {
+    logger.log("transport is taken by another daemon; exiting");
+    lock.release();
+    return;
+  }
+  const store = new StateStore(data);
+  store.load();
+  for (const rec of store.apps.values()) {
+    if (rec.pid !== void 0 && isAlive(rec.pid)) {
+      try {
+        process.kill(-rec.pid, "SIGKILL");
+      } catch {
+        try {
+          process.kill(rec.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      logger.log(`reaped orphan ${rec.name} pid=${rec.pid}`);
+    }
+    rec.pid = void 0;
+    rec.child = void 0;
+    rec.startTime = void 0;
+  }
+  const autoResurrect = [...store.apps.values()].filter(
+    (rec) => rec.status === "online" || rec.status === "starting" || rec.status === "restarting"
+  );
+  for (const rec of autoResurrect) {
+    rec.status = "stopped";
+  }
+  store.saveSync();
+  store.journal("daemon-start", { pid: process.pid, version: VERSION });
+  const pm = new ProcessManager(store, logger, data);
+  const ctx = { store, pm, logger, transport, lock, base: data };
+  transport.onConnection((socket) => handleConnection(socket, ctx));
+  logger.log("daemon ready", { address: transport.address(), pid: process.pid });
+  for (const rec of autoResurrect) {
+    const cwdFix = fixCwd(rec.config.cwd, rec.config.sourceDir);
+    if (cwdFix.fixed && cwdFix.reason) {
+      logger.log(cwdFix.reason);
+      rec.config.cwd = cwdFix.path;
+    }
+    if (!pathExists(rec.config.cwd)) {
+      logger.log(`autosave: skipping ${rec.name} \u2014 cwd ${rec.config.cwd} does not exist`);
+      rec.status = "errored";
+      rec.error = `cwd does not exist: ${rec.config.cwd}`;
+      continue;
+    }
+    logger.log(`autosave: resurrecting ${rec.name}`);
+    pm.spawnApp(rec);
+  }
+  if (autoResurrect.length > 0) store.saveSync();
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+  process.on(
+    "uncaughtException",
+    (e) => logger.log("uncaughtException", { error: String(e?.stack ?? e) })
+  );
+  process.on("unhandledRejection", (r) => logger.log("unhandledRejection", { error: String(r) }));
+  function onSignal() {
+    logger.log("daemon received stop signal; shutting down");
+    void shutdownDaemon(ctx);
+  }
+}
+async function shutdownDaemon(ctx) {
+  const { store, pm, logger, transport, lock } = ctx;
+  pm.stopAllMonitors();
+  pm.stopAll("stop");
+  await pm.waitForAllStopped(3e3);
+  store.saveSync();
+  store.journal("daemon-stop", {});
+  transport.close();
+  lock.release();
+  logger.log("daemon exited");
+  setTimeout(() => process.exit(0), 50);
+}
+function handleConnection(socket, ctx) {
+  socket.setEncoding("utf8");
+  let buffer = "";
+  socket.on("data", (d) => {
+    buffer += typeof d === "string" ? d : d.toString("utf8");
+    let idx = buffer.indexOf("\n");
+    while (idx >= 0) {
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.trim() !== "") void onLine(socket, ctx, line);
+      idx = buffer.indexOf("\n");
+    }
+  });
+  socket.on("error", () => {
+    try {
+      socket.destroy();
+    } catch {
+    }
+  });
+}
+async function onLine(socket, ctx, line) {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (typeof req.id !== "number" || typeof req.method !== "string") return;
+  const handler = METHODS[req.method];
+  if (handler === void 0) {
+    send(socket, {
+      id: req.id,
+      ok: false,
+      error: { code: "NO_METHOD", message: `unknown method '${req.method}'` }
+    });
+    return;
+  }
+  try {
+    const result = await handler(req.params, ctx);
+    send(socket, { id: req.id, ok: true, result });
+  } catch (err) {
+    const code = err instanceof Error && "code" in err ? String(err.code) : "ERROR";
+    const message = err instanceof Error ? err.message : String(err);
+    send(socket, { id: req.id, ok: false, error: { code, message } });
+  }
+  if (req.method === "shutdown") {
+    setImmediate(() => void shutdownDaemon(ctx));
+  }
+}
+function send(socket, obj) {
+  try {
+    socket.write(`${JSON.stringify(obj)}
+`);
+  } catch {
+  }
+}
+var METHODS = {
+  ping: () => ({
+    version: VERSION,
+    protocol: 1,
+    pid: process.pid,
+    uptime: Math.round(process.uptime())
+  }),
+  list: (_p, { store }) => ({
+    apps: [...store.apps.values()].map(summarize)
+  }),
+  describe: (params, { store }) => {
+    const { name } = params;
+    if (typeof name !== "string" || name === "") {
+      throw new Error("describe: missing app name");
+    }
+    const rec = store.requireApp(name);
+    const { child: _child, sink: _sink, ...rest } = rec;
+    return rest;
+  },
+  start: async (params, ctx) => {
+    const target = params.target;
+    if (target === void 0 || typeof target.path !== "string") {
+      throw new Error("start: missing target");
+    }
+    return startApps(target, ctx);
+  },
+  stop: (params, { store, pm }) => operate("stop", params, store, pm),
+  restart: (params, { store, pm }) => operate("restart", params, store, pm),
+  reload: async (params, ctx) => {
+    const { store, pm, logger } = ctx;
+    const name = params.name;
+    const expanded = name === void 0 || name === "all" ? [...store.apps.values()] : expandTargets(store, name);
+    const results = [];
+    for (const rec of expanded) {
+      if (rec.status !== "online" && rec.status !== "starting") {
+        pm.spawnApp(rec);
+        results.push({ name: rec.name, status: rec.status, pid: rec.pid });
+        continue;
+      }
+      logger.log(`reload: graceful restart of ${rec.name}`);
+      const prevPid = rec.pid;
+      pm.stop(rec, "restart");
+      const start = Date.now();
+      while (Date.now() - start < 5e3) {
+        await new Promise((r) => setTimeout(r, 100));
+        const st = rec.status;
+        if (rec.pid !== void 0 && rec.pid !== prevPid && (st === "online" || st === "starting"))
+          break;
+        if (st === "errored" || st === "stopped") break;
+      }
+      store.saveSync();
+      results.push({ name: rec.name, status: rec.status, pid: rec.pid });
+    }
+    store.saveSync();
+    store.journal("app-reload", { names: results.map((r) => r.name) });
+    return { apps: results };
+  },
+  logs: (params, { store, base }) => {
+    const name = params.name;
+    if (typeof name !== "string" || name === "") {
+      throw new Error("logs: missing app name");
+    }
+    const rec = store.requireApp(name);
+    const paths = resolveLogPaths(rec.config, base);
+    const files = paths.err === null ? [paths.out] : [paths.out, paths.err];
+    return { name, files };
+  },
+  flush: (params, { store, base, logger }) => {
+    const name = params.name;
+    const targets = name === void 0 || name === "all" ? [...store.apps.values()] : [store.requireApp(name)];
+    const apps = targets.map((rec) => {
+      const paths = resolveLogPaths(rec.config, base);
+      const files = paths.err === null ? [paths.out] : [paths.out, paths.err];
+      for (const f of files) {
+        try {
+          ensureDirSync(path19.dirname(f));
+          fs18.writeFileSync(f, "");
+        } catch (err) {
+          logger.log(`flush ${rec.name}: cannot truncate ${f}: ${err.message}`);
+        }
+      }
+      store.journal("app-flush", { name: rec.name, files });
+      return { name: rec.name, files };
+    });
+    return { apps };
+  },
+  delete: (params, { store, pm }) => {
+    const res = operate("stop", params, store, pm);
+    for (const a of res.apps) {
+      store.apps.delete(a.name);
+      store.journal("app-delete", { name: a.name });
+    }
+    store.saveSync();
+    return res;
+  },
+  rotate: (params, { store, base, logger }) => {
+    const { app, maxSizeBytes, retain } = params;
+    const max = maxSizeBytes ?? 10485760;
+    const n = retain ?? 7;
+    const targets = app === void 0 || app === "all" ? [...store.apps.values()] : [store.requireApp(app)];
+    const results = [];
+    for (const rec of targets) {
+      const paths = resolveLogPaths(rec.config, base);
+      const files = paths.err === null ? [paths.out] : [paths.out, paths.err];
+      const rotated = [];
+      const skipped = [];
+      for (const f of files) {
+        if (!pathExists(f)) continue;
+        try {
+          const stat = fs18.statSync(f);
+          if (stat.size >= max) {
+            rotateFile(f, n);
+            rotated.push(f);
+          } else {
+            skipped.push(f);
+          }
+        } catch (err) {
+          logger.log(`rotate ${rec.name}: cannot rotate ${f}: ${err.message}`);
+          skipped.push(f);
+        }
+      }
+      if (rotated.length > 0 || skipped.length > 0) {
+        store.journal("app-rotate", { name: rec.name, files: rotated, skipped });
+        results.push({ name: rec.name, rotated, skipped });
+      }
+    }
+    return results;
+  },
+  metrics: (_params, { store, pm }) => {
+    return {
+      daemon: {
+        pid: process.pid,
+        uptimeMs: Math.round(process.uptime() * 1e3),
+        protocolVersion: 1,
+        appCount: store.apps.size
+      },
+      apps: pm.appMetrics()
+    };
+  },
+  save: (_params, { store, logger }) => {
+    store.saveSync();
+    store.journal("daemon-save", {});
+    logger.log("daemon state saved");
+    return { ok: true, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  },
+  resurrect: async (_params, ctx) => {
+    const { store, pm, logger } = ctx;
+    const results = [];
+    for (const rec of store.apps.values()) {
+      if (rec.status === "online" || rec.status === "starting" || rec.status === "restarting") {
+        results.push({ name: rec.name, status: rec.status, message: "already running" });
+        continue;
+      }
+      logger.log(`resurrect: starting ${rec.name}`);
+      pm.spawnApp(rec);
+      results.push({ name: rec.name, status: rec.status, pid: rec.pid, message: rec.error });
+    }
+    store.saveSync();
+    store.journal("daemon-resurrect", { apps: results.length });
+    return { apps: results };
+  },
+  doctor: (_params, { store, base, transport }) => {
+    const checks = [];
+    const snapshotPath = path19.join(base, "state", "snapshot.json");
+    const stateIssues = [];
+    if (pathExists(snapshotPath)) {
+      try {
+        const data = JSON.parse(fs18.readFileSync(snapshotPath, "utf8"));
+        if (data.schema === 1 && typeof data.apps === "object") {
+          stateIssues.push({
+            severity: "ok",
+            code: "SNAPSHOT_OK",
+            message: `snapshot.json valid (schema 1, ${Object.keys(data.apps ?? {}).length} apps)`
+          });
+        } else {
+          stateIssues.push({
+            severity: "error",
+            code: "SNAPSHOT_SCHEMA",
+            message: `unexpected snapshot schema: ${data.schema}`
+          });
+        }
+      } catch (err) {
+        stateIssues.push({
+          severity: "error",
+          code: "SNAPSHOT_PARSE",
+          message: `cannot parse snapshot.json: ${err.message}`
+        });
+      }
+    } else {
+      stateIssues.push({
+        severity: "warn",
+        code: "SNAPSHOT_MISSING",
+        message: "snapshot.json does not exist yet \u2014 no apps loaded"
+      });
+    }
+    checks.push({
+      name: "State integrity",
+      ok: !stateIssues.some((i) => i.severity === "error"),
+      issues: stateIssues
+    });
+    const lockFile = path19.join(runtimeDir(), "daemon.lock");
+    const lockIssues = [];
+    if (pathExists(lockFile)) {
+      try {
+        const lock = JSON.parse(fs18.readFileSync(lockFile, "utf8"));
+        if (typeof lock.pid === "number" && isAlive(lock.pid)) {
+          lockIssues.push({
+            severity: "ok",
+            code: "LOCK_HELD",
+            message: `lock held by alive daemon pid=${lock.pid}`
+          });
+        } else {
+          lockIssues.push({
+            severity: "error",
+            code: "LOCK_STALE",
+            message: `stale lock file (pid=${lock.pid} not alive)`
+          });
+        }
+      } catch (err) {
+        lockIssues.push({
+          severity: "error",
+          code: "LOCK_PARSE",
+          message: `cannot parse daemon.lock: ${err.message}`
+        });
+      }
+    } else {
+      lockIssues.push({
+        severity: "error",
+        code: "LOCK_MISSING",
+        message: "daemon.lock missing \u2014 daemon may be unhealthy"
+      });
+    }
+    checks.push({
+      name: "Lock consistency",
+      ok: !lockIssues.some((i) => i.severity === "error"),
+      issues: lockIssues
+    });
+    const orphanIssues = [];
+    const orphans = [];
+    for (const rec of store.apps.values()) {
+      if (rec.pid !== void 0 && rec.status === "online" && !isAlive(rec.pid)) {
+        orphans.push(`${rec.name}(pid=${rec.pid})`);
+      }
+    }
+    if (orphans.length === 0) {
+      orphanIssues.push({
+        severity: "ok",
+        code: "NO_ORPHANS",
+        message: "all online apps have live pids"
+      });
+    } else {
+      orphanIssues.push({
+        severity: "error",
+        code: "ORPHAN_APPS",
+        message: `online apps with dead pids: ${orphans.join(", ")}`
+      });
+    }
+    checks.push({
+      name: "Orphan processes",
+      ok: !orphanIssues.some((i) => i.severity === "error"),
+      issues: orphanIssues
+    });
+    const transportIssues = [];
+    const addr = transport.address();
+    if (addr) {
+      transportIssues.push({
+        severity: "ok",
+        code: "TRANSPORT_OK",
+        message: `listening on ${addr}`
+      });
+    } else {
+      transportIssues.push({
+        severity: "error",
+        code: "TRANSPORT_DOWN",
+        message: "transport is not accepting connections"
+      });
+    }
+    checks.push({
+      name: "Transport health",
+      ok: !transportIssues.some((i) => i.severity === "error"),
+      issues: transportIssues
+    });
+    const uptimeIssues = [
+      {
+        severity: "ok",
+        code: "UPTIME_OK",
+        message: `daemon running uptime=${Math.round(process.uptime())}s pid=${process.pid}`
+      }
+    ];
+    checks.push({ name: "Daemon uptime", ok: true, issues: uptimeIssues });
+    return { checks, summary: summarizeChecks(checks) };
+  },
+  shutdown: () => ({ ok: true, message: "shutting down" })
+};
+async function startApps(target, ctx) {
+  const { store, pm } = ctx;
+  let apps;
+  let warnings;
+  if (target.type === "config") {
+    const loaded = await loadConfigFile(target.path, { envName: target.envName });
+    apps = loaded.apps;
+    warnings = loaded.warnings;
+    if (target.cliOverrides) {
+      for (const app of apps) applyCliOverrides(app, target.cliOverrides);
+    }
+  } else {
+    const input = {
+      script: target.path,
+      args: target.args,
+      env: target.env
+    };
+    if (target.name !== void 0) input.name = target.name;
+    if (target.interpreter !== void 0) input.interpreter = target.interpreter;
+    if (target.cwd !== void 0) input.cwd = target.cwd;
+    if (target.cliOverrides) Object.assign(input, target.cliOverrides);
+    const single = normalizeSingleApp(input, path19.dirname(target.path), target.envName);
+    apps = [single.app];
+    warnings = single.warnings;
+  }
+  const expanded = [];
+  for (const app of apps) {
+    if (app.instances <= 1) expanded.push(app);
+    else {
+      for (let i = 0; i < app.instances; i++) {
+        const clone = {
+          ...app,
+          name: `${app.name}:${i}`,
+          env: { ...app.env, NODE_APP_INSTANCE: String(i) }
+        };
+        expanded.push(clone);
+      }
+    }
+  }
+  const results = [];
+  for (const app of expanded) {
+    const existing = store.apps.get(app.name);
+    if (existing !== void 0 && (existing.status === "online" || existing.status === "restarting" || existing.status === "starting")) {
+      results.push({
+        name: app.name,
+        status: existing.status,
+        pid: existing.pid,
+        message: "already running"
+      });
+      continue;
+    }
+    let record;
+    if (existing === void 0) {
+      record = { name: app.name, config: app, status: "stopped", restarts: 0, crashStreak: 0 };
+      store.apps.set(app.name, record);
+    } else {
+      record = existing;
+      record.config = app;
+    }
+    pm.spawnApp(record);
+    store.saveSync();
+    results.push({ name: app.name, status: record.status, pid: record.pid, message: record.error });
+  }
+  return { apps: results, warnings };
+}
+function operate(kind, params, store, pm) {
+  const name = params.name;
+  const targets = name === void 0 || name === "all" ? [...store.apps.values()] : expandTargets(store, name);
+  const result = targets.map((rec) => {
+    pm.stop(rec, kind);
+    store.saveSync();
+    return { name: rec.name, status: rec.status, pid: rec.pid };
+  });
+  return { apps: result };
+}
+function expandTargets(store, name) {
+  if (store.apps.has(name)) return [store.requireApp(name)];
+  const matched = [...store.apps.values()].filter(
+    (r) => r.name === name || r.name.startsWith(`${name}:`)
+  );
+  if (matched.length > 0) return matched;
+  return [store.requireApp(name)];
+}
+function applyCliOverrides(app, overrides) {
+  if (overrides.instances !== void 0) {
+    const v = overrides.instances;
+    if (v === "max" || v === "MAX") app.instances = os8.cpus().length || 1;
+    else {
+      const n = Number(v);
+      if (Number.isFinite(n) && n >= 1) app.instances = Math.round(n);
+    }
+  }
+  if (overrides.exec_mode !== void 0) {
+    const m = String(overrides.exec_mode).toLowerCase();
+    if (m === "cluster" || m === "cluster_mode") app.execMode = "cluster";
+    else if (m === "fork" || m === "fork_mode") app.execMode = "fork";
+  }
+  if (overrides.interpreter !== void 0) app.interpreter = String(overrides.interpreter);
+  if (overrides.cwd !== void 0) app.cwd = String(overrides.cwd);
+  if (overrides.max_memory_restart !== void 0) {
+    try {
+      const mm = String(overrides.max_memory_restart);
+      const num = Number(mm);
+      if (Number.isFinite(num)) app.maxMemoryRestart = num;
+      else {
+        const units = {
+          b: 1,
+          kb: 1024,
+          k: 1024,
+          mb: 1024 * 1024,
+          m: 1024 * 1024,
+          gb: 1024 * 1024 * 1024,
+          g: 1024 * 1024 * 1024
+        };
+        const m = mm.toLowerCase().match(/^([0-9.]+)s*([a-z]*)$/);
+        if (m) app.maxMemoryRestart = Math.round(Number(m[1]) * (units[m[2]] ?? 1));
+      }
+    } catch {
+    }
+  }
+  if (overrides.kill_timeout !== void 0)
+    app.killTimeout = Math.max(0, Number(overrides.kill_timeout) || 1600);
+  if (overrides.restart_delay !== void 0)
+    app.restartDelay = Math.max(0, Number(overrides.restart_delay) || 0);
+  if (overrides.watch_delay !== void 0)
+    app.watchDelay = Math.max(0, Number(overrides.watch_delay) || 1e3);
+}
+function summarize(rec) {
+  return {
+    name: rec.name,
+    status: rec.status,
+    pid: rec.pid,
+    startTime: rec.startTime,
+    restarts: rec.restarts,
+    crashStreak: rec.crashStreak,
+    exitCode: rec.exitCode,
+    exitSignal: rec.exitSignal,
+    error: rec.error
+  };
+}
+function rotateFile(file, retain) {
+  for (let i = retain - 1; i >= 0; i--) {
+    const oldName = i === 0 ? file : `${file}.${i}.gz`;
+    const newName = `${file}.${i + 1}.gz`;
+    if (pathExists(oldName)) {
+      if (i + 1 >= retain) {
+        fs18.unlinkSync(oldName);
+      } else {
+        if (i === 0) {
+          const content = fs18.readFileSync(file);
+          fs18.unlinkSync(file);
+          const gz = zlib.gzipSync(content);
+          fs18.writeFileSync(newName, gz);
+        } else {
+          fs18.renameSync(oldName, newName);
+        }
+      }
+    }
+  }
+}
+function summarizeChecks(checks) {
+  let ok = 0;
+  let warnings = 0;
+  for (const c of checks) {
+    const hasError = c.issues.some((i) => i.severity === "error");
+    const hasWarn = c.issues.some((i) => i.severity === "warn");
+    if (hasError) {
+    } else if (hasWarn) {
+      warnings++;
+    } else {
+      ok++;
+    }
+  }
+  const errors = checks.filter((c) => !c.ok).length;
+  return { total: checks.length, ok, warnings, errors };
+}
+
+// src/cli.ts
+var COMMANDS = {
+  start: run21,
+  stop: run23,
+  restart: run17,
+  reload: run16,
+  delete: run,
+  list: run11,
+  ls: run11,
+  status: run11,
+  describe: run2,
+  ping: run15,
+  kill: run10,
+  logs: run12,
+  flush: run6,
+  rotate: run19,
+  doctor: run4,
+  metrics: run13,
+  monit: run14,
+  find: run5,
+  "from-caddy": run7,
+  save: run20,
+  resurrect: run18,
+  startup: run22,
+  "import-pm2": run8,
+  "inspect-config": run9,
+  dev: run3,
+  "daemon-upgrade": run24,
+  upgrade: run24,
+  version: async () => {
+    printVersion();
+    return 0;
+  },
+  help: async () => {
+    printHelp();
+    return 0;
+  }
+};
+var PLANNED = {};
+async function run25(argv) {
+  if (process.env.RELIFE2_DAEMON === "1") {
+    await runDaemon();
+    return 0;
+  }
+  const args = argv.slice(2);
+  const command = args[0];
+  if (command === void 0) {
+    if (hasFlag(args, "v", "version") || hasFlag(args, "h", "help")) {
+      if (hasFlag(args, "v", "version")) printVersion();
+      else printHelp();
+      return 0;
+    }
+    printHelp();
+    return 0;
+  }
+  if (COMMANDS[command] !== void 0) {
+    if ((command === "--help" || command === "-h") && args.length === 1) {
+      printHelp();
+      return 0;
+    }
+    if ((command === "--version" || command === "-v") && args.length === 1) {
+      printVersion();
+      return 0;
+    }
+    const impl = COMMANDS[command];
+    return impl(args.slice(1));
+  }
+  if (hasFlag(args, "v", "version")) {
+    printVersion();
+    return 0;
+  }
+  if (hasFlag(args, "h", "help")) {
+    printHelp();
+    return 0;
+  }
+  const milestone = PLANNED[command];
+  if (milestone !== void 0) {
+    console.error(
+      `relife2: command '${command}' is not implemented yet (planned in ${milestone}, see TODO.md)`
+    );
+    return 1;
+  }
+  console.error(`relife2: unknown command '${command}'`);
+  console.error("run 'relife2 --help' to see available commands");
+  return 1;
+}
+function hasFlag(args, short, long) {
+  return args.includes(`-${short}`) || args.includes(`--${long}`);
+}
+process.exitCode = await run25(process.argv);
+export {
+  run25 as run
+};
+//# sourceMappingURL=cli.js.map