relife2 1.0.1 → 1.0.2

package/dist/cli.js

@@ -14,13 +14,13 @@ var jsloader_exports = {};
 __export(jsloader_exports, {
   loadJsFile: () => loadJsFile
 });
-import * as fs5 from "node:fs";
+import * as fs7 from "node:fs";
 import { createRequire } from "node:module";
-import path6 from "node:path";
+import path7 from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadJsFile(file) {
-  const ext = path6.extname(file).toLowerCase();
-  const source = fs5.readFileSync(file, "utf8");
+  const ext = path7.extname(file).toLowerCase();
+  const source = fs7.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);
@@ -51,7 +51,7 @@ function compileCjs(file, source) {
   const nodeModule = req("node:module");
   const mod = new nodeModule.Module(file, null);
   mod.filename = file;
-  mod.paths = nodeModule._nodeModulePaths(path6.dirname(file));
+  mod.paths = nodeModule._nodeModulePaths(path7.dirname(file));
   mod._compile(source, file);
   return mod.exports;
 }
@@ -65,6 +65,7 @@ var init_jsloader = __esm({
 
 // src/daemon/client.ts
 import { spawn } from "node:child_process";
+import fs3 from "node:fs";
 import net from "node:net";
 import path3 from "node:path";
 
@@ -318,28 +319,82 @@ var RpcClient = class {
 async function ensureDaemonClient() {
   const runtime = runtimeDir();
   const data = dataDir();
+  ensureDirs(runtime, data);
   let sock = await tryConnect(runtime);
+  if (sock !== null) {
+    return await validateClient(sock);
+  }
+  cleanStaleLockIfNeeded(runtime);
+  spawnDaemon();
+  for (let i = 0; i < 80 && sock === null; i++) {
+    await sleep(100);
+    sock = await tryConnect(runtime);
+  }
   if (sock === null) {
+    cleanStaleLockIfNeeded(runtime);
     spawnDaemon();
-    for (let i = 0; i < 100 && sock === null; i++) {
+    for (let i = 0; i < 40 && 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")}`
+      `cannot connect to relife2 daemon (runtime: ${runtime}, data: ${data}); try 'relife2 doctor --fix' or inspect ${path3.join(data, "logs", "daemon.log")}`
     );
   }
+  return await validateClient(sock);
+}
+async function validateClient(sock) {
   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`
-    );
+  try {
+    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;
+  } catch (err) {
+    try {
+      client.close();
+    } catch {
+    }
+    throw err;
+  }
+}
+function ensureDirs(runtime, data) {
+  for (const dir of [runtime, data, path3.join(data, "logs"), path3.join(data, "state")]) {
+    try {
+      fs3.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+  }
+}
+function cleanStaleLockIfNeeded(runtime) {
+  const file = lockPath(runtime);
+  try {
+    const raw = fs3.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    const pid = typeof parsed.pid === "number" ? parsed.pid : null;
+    if (pid === null) {
+      fs3.unlinkSync(file);
+      return;
+    }
+    try {
+      process.kill(pid, 0);
+    } catch (e) {
+      const code = e.code;
+      if (code === "ESRCH") {
+        try {
+          fs3.unlinkSync(file);
+        } catch {
+        }
+      }
+    }
+  } catch {
   }
-  return client;
 }
 function spawnDaemon() {
   const arg1 = process.argv[1];
@@ -493,7 +548,7 @@ async function run2(args) {
 
 // src/commands/dev.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 import path4 from "node:path";
 var DEV_VALUE_OPTS = /* @__PURE__ */ new Set(["watch", "interpreter", "env", "name", "w"]);
 function hasBun() {
@@ -511,7 +566,7 @@ 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")))
+    if (fs4.existsSync(path4.join(cur, "bun.lockb")) || fs4.existsSync(path4.join(cur, "bun.lock")))
       return true;
     if (cur === home || cur === path4.dirname(cur)) break;
     cur = path4.dirname(cur);
@@ -526,7 +581,7 @@ function collectSubDirs(root) {
     if (!dir) continue;
     let entries = [];
     try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -556,7 +611,7 @@ async function run3(args) {
     return 1;
   }
   const script = path4.resolve(scriptArg);
-  if (!fs3.existsSync(script)) {
+  if (!fs4.existsSync(script)) {
     console.error(`dev: script not found: ${script}`);
     return 1;
   }
@@ -664,16 +719,16 @@ async function runManualWatch(script, cwd, interpreter, appArgs, watchRaw) {
     }, 200);
   };
   for (const target of targets) {
-    if (!fs3.existsSync(target)) {
+    if (!fs4.existsSync(target)) {
       console.error(`dev: watch path does not exist: ${target} \u2014 skipping`);
       continue;
     }
-    const stat = fs3.statSync(target);
+    const stat = fs4.statSync(target);
     if (!stat.isDirectory()) {
       const dir = path4.dirname(target);
       const base = path4.basename(target);
       try {
-        const w = fs3.watch(dir, (_ev, filename) => {
+        const w = fs4.watch(dir, (_ev, filename) => {
           if (filename && filename !== base) return;
           scheduleRestart(target);
         });
@@ -685,7 +740,7 @@ async function runManualWatch(script, cwd, interpreter, appArgs, watchRaw) {
     }
     if (process.platform === "win32" || process.platform === "darwin") {
       try {
-        const w = fs3.watch(target, { recursive: true }, () => scheduleRestart(target));
+        const w = fs4.watch(target, { recursive: true }, () => scheduleRestart(target));
         watchers.push(w);
       } catch (err) {
         console.error(`dev: cannot watch ${target}: ${err.message}`);
@@ -694,7 +749,7 @@ async function runManualWatch(script, cwd, interpreter, appArgs, watchRaw) {
       const dirs = collectSubDirs(target);
       for (const dir of dirs) {
         try {
-          const w = fs3.watch(dir, () => scheduleRestart(dir));
+          const w = fs4.watch(dir, () => scheduleRestart(dir));
           watchers.push(w);
         } catch {
         }
@@ -789,8 +844,32 @@ Examples:
 }
 
 // src/commands/doctor.ts
-async function run4(_args) {
-  const client = await ensureDaemonClient();
+import fs5 from "node:fs";
+import os2 from "node:os";
+import path5 from "node:path";
+async function run4(args) {
+  const fix = args.includes("--fix") || args.includes("-f");
+  if (fix) {
+    const healed = healLocally();
+    if (healed.length > 0) {
+      for (const m of healed) console.log(`healed: ${m}`);
+    } else {
+      console.log("heal: nothing to fix locally");
+    }
+  }
+  let client;
+  try {
+    client = await ensureDaemonClient();
+  } catch (err) {
+    if (fix) {
+      console.error(`doctor: daemon still not reachable after heal: ${err.message}`);
+      console.error("try: rm -rf ~/.relife2/state/* && relife2 kill; relife2 list");
+    } else {
+      console.error(err.message);
+      console.error("hint: relife2 doctor --fix  (cleans stale lock + *.tmp.cjs)");
+    }
+    return 1;
+  }
   try {
     const report = await client.call("doctor", {});
     let hadErrors = false;
@@ -807,21 +886,143 @@ async function run4(_args) {
     console.log(
       `checks: ${report.summary.total} total, ${report.summary.ok} ok, ${report.summary.warnings} warnings, ${report.summary.errors} errors`
     );
+    if (hadErrors && !fix) {
+      console.log("hint: relife2 doctor --fix  (cleans stale lock + *.tmp.cjs)");
+    }
     return hadErrors ? 1 : 0;
   } finally {
     client.close();
   }
 }
+function healLocally() {
+  const out = [];
+  const runtime = runtimeDir();
+  const data = dataDir();
+  for (const dir of [runtime, data, path5.join(data, "logs"), path5.join(data, "state")]) {
+    try {
+      fs5.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+  }
+  const lockFile = path5.join(runtime, "daemon.lock");
+  try {
+    const raw = fs5.readFileSync(lockFile, "utf8");
+    const parsed = JSON.parse(raw);
+    const pid = typeof parsed.pid === "number" ? parsed.pid : null;
+    let alive = false;
+    if (pid !== null) {
+      try {
+        process.kill(pid, 0);
+        alive = true;
+      } catch (e) {
+        const code = e.code;
+        if (code === "EPERM") alive = true;
+        else if (code === "ESRCH") alive = false;
+      }
+    }
+    if (pid === null || !alive) {
+      fs5.unlinkSync(lockFile);
+      out.push(`removed stale lock ${lockFile} (pid=${pid})`);
+    }
+  } catch {
+  }
+  const home = os2.homedir();
+  if (home && fs5.existsSync(home)) {
+    try {
+      const tmpLeftovers = collectTmpLeftovers(home, 6, 50);
+      for (const f of tmpLeftovers) {
+        try {
+          fs5.unlinkSync(f);
+          out.push(`removed leftover ${path5.relative(home, f)}`);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const tmpDir = os2.tmpdir();
+    const entries = fs5.readdirSync(tmpDir);
+    const now = Date.now();
+    for (const name of entries) {
+      if (!name.startsWith("relife2-") || !name.endsWith(".tmp.cjs")) continue;
+      const full = path5.join(tmpDir, name);
+      try {
+        const st = fs5.statSync(full);
+        if (now - st.mtimeMs > 60 * 60 * 1e3) {
+          fs5.unlinkSync(full);
+          out.push(`removed old tmp ${name}`);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function collectTmpLeftovers(root, maxDepth, limit) {
+  const out = [];
+  const stack = [{ dir: root, depth: 0 }];
+  const ignored = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    ".hg",
+    ".svn",
+    "vendor",
+    ".next",
+    ".output",
+    "dist",
+    "build",
+    "target",
+    "__pycache__",
+    ".cache",
+    ".pnpm",
+    ".yarn",
+    ".turbo",
+    ".parcel-cache",
+    "Library",
+    "AppData",
+    ".local",
+    "proc",
+    "sys",
+    "dev"
+  ]);
+  while (stack.length > 0 && out.length < limit) {
+    const cur = stack.pop();
+    if (!cur) break;
+    if (cur.depth > maxDepth) continue;
+    let entries;
+    try {
+      entries = fs5.readdirSync(cur.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (out.length >= limit) break;
+      const full = path5.join(cur.dir, ent.name);
+      if (ent.isFile() && ent.name.includes(".tmp.") && ent.name.endsWith(".cjs")) {
+        if (ent.name.includes(".config.")) out.push(full);
+        continue;
+      }
+      if (!ent.isDirectory()) continue;
+      if (ignored.has(ent.name)) continue;
+      if (ent.name.startsWith(".") && cur.depth < 2) continue;
+      if (ent.isSymbolicLink()) continue;
+      if (cur.depth + 1 <= maxDepth) stack.push({ dir: full, depth: cur.depth + 1 });
+    }
+  }
+  return out;
+}
 
 // src/commands/find.ts
-import * as fs7 from "node:fs";
-import os4 from "node:os";
-import path8 from "node:path";
+import * as fs9 from "node:fs";
+import os5 from "node:os";
+import path9 from "node:path";
 
 // src/config/loader.ts
-import * as fs6 from "node:fs";
-import os3 from "node:os";
-import path7 from "node:path";
+import * as fs8 from "node:fs";
+import os4 from "node:os";
+import path8 from "node:path";
 
 // src/util/cron.ts
 var FIELD_RANGES = [
@@ -940,19 +1141,19 @@ function parseMemory(v) {
 }
 
 // src/util/portable.ts
-import * as fs4 from "node:fs";
-import os2 from "node:os";
-import path5 from "node:path";
+import * as fs6 from "node:fs";
+import os3 from "node:os";
+import path6 from "node:path";
 function isDir(p) {
   try {
-    return fs4.statSync(p).isDirectory();
+    return fs6.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function isFile(p) {
   try {
-    return fs4.statSync(p).isFile();
+    return fs6.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -974,18 +1175,18 @@ function searchByBasename(root, basename, maxDepth = 4) {
     if (cur.depth > maxDepth) continue;
     let entries;
     try {
-      entries = fs4.readdirSync(cur.dir, { withFileTypes: true });
+      entries = fs6.readdirSync(cur.dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path5.join(cur.dir, e.name);
+      const full = path6.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);
+            return fs6.realpathSync(full);
           } catch {
             return full;
           }
@@ -1003,20 +1204,20 @@ function fixCwd(staleCwd, sourceDir) {
   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);
+    candidates.push(path6.join(os3.homedir(), tail));
+    candidates.push(path6.join(path6.dirname(os3.homedir()), tail));
+    candidates.push(path6.join(path6.dirname(sourceDir), tail));
+    if (isDir(sourceDir) && !staleCwd.startsWith(os3.homedir())) candidates.push(sourceDir);
   }
-  const proj = path5.basename(sourceDir);
+  const proj = path6.basename(sourceDir);
   if (proj) {
-    const marker = `${path5.sep}${proj}${path5.sep}`;
+    const marker = `${path6.sep}${proj}${path6.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));
+      candidates.push(path6.join(sourceDir, suffix));
+      candidates.push(path6.join(path6.dirname(sourceDir), proj, suffix));
     }
   }
   for (const c of candidates) {
@@ -1031,33 +1232,33 @@ function fixCwd(staleCwd, sourceDir) {
 }
 function fixScript(staleScript, cwd, sourceDir) {
   if (isFile(staleScript)) return { path: staleScript, fixed: false };
-  const base = path5.basename(staleScript);
+  const base = path6.basename(staleScript);
   const candidates = [];
-  candidates.push(path5.join(cwd, base));
-  candidates.push(path5.join(sourceDir, base));
+  candidates.push(path6.join(cwd, base));
+  candidates.push(path6.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));
+    candidates.push(path6.join(os3.homedir(), tail));
+    candidates.push(path6.join(path6.dirname(os3.homedir()), tail));
+    candidates.push(path6.join(sourceDir, tail));
     const tailParts = tail.split("/");
-    if (tailParts.length > 1) candidates.push(path5.join(sourceDir, tailParts.slice(1).join("/")));
+    if (tailParts.length > 1) candidates.push(path6.join(sourceDir, tailParts.slice(1).join("/")));
   }
-  const proj = path5.basename(sourceDir);
+  const proj = path6.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));
+      candidates.push(path6.join(sourceDir, suffix));
+      candidates.push(path6.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));
+    const lastTwo = parts.slice(-2).join(path6.sep);
+    candidates.push(path6.join(sourceDir, lastTwo));
+    candidates.push(path6.join(cwd, lastTwo));
   }
   for (const c of candidates) {
     if (c && isFile(c))
@@ -1137,9 +1338,17 @@ var LATER_KEYS = {
   uid: "M6",
   gid: "M6"
 };
-var CONFIG_FILE_RE = /^(?:(?:ecosystem|pm2|relife2)[\w.-]*|[\w.-]*?)\.config\.(?:c?js|mjs|json|ts)$/i;
+var RELIFE2_CONFIG_RE = /^(?:ecosystem|pm2|relife2)[\w.-]*\.config\.(?:c?js|mjs|json|ts)$/i;
+var ANY_CONFIG_RE = /^[\w.-]*\.config\.(?:c?js|mjs|json|ts)$/i;
 function looksLikeConfigFile(file) {
-  return CONFIG_FILE_RE.test(path7.basename(file));
+  const base = path8.basename(file);
+  if (base.includes(".tmp.")) return false;
+  return ANY_CONFIG_RE.test(base);
+}
+function isRelife2ConfigFile(file) {
+  const base = path8.basename(file);
+  if (base.includes(".tmp.")) return false;
+  return RELIFE2_CONFIG_RE.test(base);
 }
 function findDefaultConfig(cwd) {
   const candidates = [
@@ -1156,16 +1365,16 @@ function findDefaultConfig(cwd) {
     "pm2.config.cjs"
   ];
   for (const name of candidates) {
-    const full = path7.join(cwd, name);
-    if (fs6.existsSync(full)) return full;
+    const full = path8.join(cwd, name);
+    if (fs8.existsSync(full)) return full;
   }
   return null;
 }
 async function loadConfigFile(filePath, opts) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   let exported;
   if (ext === ".json") {
-    exported = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+    exported = JSON.parse(fs8.readFileSync(filePath, "utf8"));
   } else if (ext === ".ts") {
     exported = await loadTsFile(filePath);
   } else {
@@ -1175,7 +1384,7 @@ async function loadConfigFile(filePath, opts) {
     }
     if (exported instanceof Promise) exported = await exported;
   }
-  return normalizeExported(exported, path7.dirname(filePath), opts);
+  return normalizeExported(exported, path8.dirname(filePath), opts);
 }
 async function loadTsFile(file) {
   try {
@@ -1184,16 +1393,19 @@ async function loadTsFile(file) {
     const mod = await import(url);
     return mod.default ?? mod;
   } catch {
-    const raw = fs6.readFileSync(file, "utf8");
+    const raw = fs8.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`;
+    const tmp = path8.join(
+      os4.tmpdir(),
+      `relife2-${path8.basename(file).replace(/[^a-zA-Z0-9._-]/g, "_")}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.tmp.cjs`
+    );
     try {
-      fs6.writeFileSync(tmp, stripped, "utf8");
+      fs8.writeFileSync(tmp, stripped, "utf8");
       const { loadJsFile: lf } = await Promise.resolve().then(() => (init_jsloader(), jsloader_exports));
       return await lf(tmp);
     } finally {
       try {
-        fs6.unlinkSync(tmp);
+        fs8.unlinkSync(tmp);
       } catch {
       }
     }
@@ -1249,20 +1461,20 @@ function normalizeApp(raw, sourceDir, warnings, index, envName) {
   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 cwdRaw = path8.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;
+  const scriptRawResolved = hasSep || isJsExt ? path8.resolve(cwd, scriptRaw) : scriptRaw;
   let script = scriptRawResolved;
-  if (path7.isAbsolute(scriptRawResolved)) {
+  if (path8.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) {
+    } else if (!fs8.existsSync(scriptRawResolved) && f.reason) {
       warnings.push(f.reason);
     }
   }
@@ -1279,11 +1491,11 @@ function normalizeApp(raw, sourceDir, warnings, index, envName) {
   }
   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);
+    const envPath = path8.resolve(cwd, envFile);
     let parsed = null;
-    if (fs6.existsSync(envPath) && fs6.statSync(envPath).isFile()) {
+    if (fs8.existsSync(envPath) && fs8.statSync(envPath).isFile()) {
       try {
-        parsed = parseDotenv(fs6.readFileSync(envPath, "utf8"));
+        parsed = parseDotenv(fs8.readFileSync(envPath, "utf8"));
       } catch (err) {
         warnings.push(
           `apps[${index}] env_file '${envFile}' could not be read: ${err.message}`
@@ -1406,7 +1618,7 @@ function parseWatchField(v, field, index) {
 }
 function parseInstances(v, index) {
   if (v === void 0 || v === null) return 1;
-  if (v === "max" || v === "MAX") return os3.cpus().length || 1;
+  if (v === "max" || v === "MAX") return os4.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'`);
@@ -1421,7 +1633,7 @@ function parseExecMode(v, index) {
   throw new ConfigError(`apps[${index}] 'exec_mode' must be 'fork' or 'cluster'`);
 }
 function defaultName(script) {
-  const base = path7.basename(script);
+  const base = path8.basename(script);
   return base.replace(/\.(?:c?js|mjs|ts|mts|cts)$/i, "") || base;
 }
 function normalizeSingleApp(input, sourceDir, envName) {
@@ -1469,7 +1681,7 @@ function findConfigs(root, maxDepth) {
     if (depth > maxDepth) continue;
     let real;
     try {
-      real = fs7.realpathSync(dir);
+      real = fs9.realpathSync(dir);
     } catch {
       continue;
     }
@@ -1477,13 +1689,13 @@ function findConfigs(root, maxDepth) {
     visited.add(real);
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const ent of entries) {
-      const full = path8.join(dir, ent.name);
-      if (ent.isFile() && looksLikeConfigFile(ent.name)) {
+      const full = path9.join(dir, ent.name);
+      if (ent.isFile() && isRelife2ConfigFile(ent.name)) {
         out.push(full);
         continue;
       }
@@ -1512,8 +1724,8 @@ async function enrich(found) {
   return entries;
 }
 function relToRoot(p, root) {
-  const rel = path8.relative(root, p);
-  return rel === "" ? path8.basename(p) : rel;
+  const rel = path9.relative(root, p);
+  return rel === "" ? path9.basename(p) : rel;
 }
 async function run5(args) {
   const { positionals, opts } = parseCliArgs(args, VALUE_OPTS);
@@ -1523,12 +1735,12 @@ async function run5(args) {
   let root = opts.get("root");
   if (root === void 0) {
     if (allFlag) {
-      root = process.platform === "win32" ? path8.parse(process.cwd()).root : "/";
+      root = process.platform === "win32" ? path9.parse(process.cwd()).root : "/";
     } else {
-      root = os4.homedir() || process.cwd();
+      root = os5.homedir() || process.cwd();
     }
   }
-  root = path8.resolve(root);
+  root = path9.resolve(root);
   let depth = 6;
   const depthRaw = opts.get("depth");
   if (depthRaw !== void 0) {
@@ -1540,7 +1752,7 @@ async function run5(args) {
     depth = Math.round(n);
   }
   if (allFlag) depth = Math.max(depth, 8);
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) {
+  if (!fs9.existsSync(root) || !fs9.statSync(root).isDirectory()) {
     console.error(`find: root '${root}' does not exist or is not a directory`);
     return 1;
   }
@@ -1631,10 +1843,10 @@ Starting ${toStart.length} config(s) not yet running\u2026
         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 w of res.warnings ?? []) console.error(`warning ${path9.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"}`);
+            console.error(`x ${a.name} (${path9.basename(r.path)}): ${a.message ?? "failed"}`);
             failed++;
           } else {
             console.log(
@@ -1644,7 +1856,7 @@ Starting ${toStart.length} config(s) not yet running\u2026
           }
         }
       } catch (err) {
-        console.error(`x ${path8.basename(r.path)}: ${err.message}`);
+        console.error(`x ${path9.basename(r.path)}: ${err.message}`);
         failed++;
       }
     }
@@ -1678,9 +1890,9 @@ async function run6(args) {
 }
 
 // src/commands/fromCaddy.ts
-import * as fs8 from "node:fs";
-import os5 from "node:os";
-import path9 from "node:path";
+import * as fs10 from "node:fs";
+import os6 from "node:os";
+import path10 from "node:path";
 var LOOPBACK_RE = /(?:127\.0\.0\.1|localhost|::1):(\d{2,5})/g;
 var ENTRY_PATTERNS = [
   ".output/server/index.mjs",
@@ -1853,37 +2065,37 @@ function parseCaddyfile(content) {
 }
 function findEntry(dir) {
   for (const pat of ENTRY_PATTERNS) {
-    const p = path9.join(dir, pat);
-    if (fs8.existsSync(p)) return { script: pat, exists: true };
+    const p = path10.join(dir, pat);
+    if (fs10.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);
+    const d = path10.isAbsolute(hint.dir) ? hint.dir : path10.resolve(caddyfileDir, hint.dir);
     return { dir: d, warnings };
   }
   const searchRoots = [];
-  const homedir = os5.homedir();
+  const homedir = os6.homedir();
   if (homedir) searchRoots.push(homedir);
   if (caddyfileDir) searchRoots.push(caddyfileDir);
-  if (caddyfileDir) searchRoots.push(path9.resolve(caddyfileDir, ".."));
+  if (caddyfileDir) searchRoots.push(path10.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));
+  if (homedir) candidates.push(path10.join(homedir, siteName));
+  if (homedir) candidates.push(path10.join(homedir, siteName.split("-")[0]));
+  for (const r of uniqRoots) candidates.push(path10.join(r, siteName));
   const rawDir = site.split(".")[0].replace(/[^a-zA-Z0-9_-]/g, "");
-  if (rawDir && homedir) candidates.push(path9.join(homedir, rawDir));
+  if (rawDir && homedir) candidates.push(path10.join(homedir, rawDir));
   for (const cand of candidates) {
-    if (fs8.existsSync(cand) && fs8.statSync(cand).isDirectory()) {
+    if (fs10.existsSync(cand) && fs10.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);
+  const fallback = homedir ? path10.join(homedir, siteName) : path10.join(caddyfileDir || process.cwd(), siteName);
   warnings.push(
     `no existing dir found for ${site} \u2192 using fallback ${fallback} (create or set via '# relife2: dir=...')`
   );
@@ -1915,15 +2127,15 @@ async function run7(args) {
     caddyfilePath ? null : "./Caddyfile",
     caddyfilePath ? null : "Caddyfile",
     caddyfilePath ? null : "/etc/caddy/Caddyfile",
-    caddyfilePath ? null : path9.join(os5.homedir(), "Caddyfile")
+    caddyfilePath ? null : path10.join(os6.homedir(), "Caddyfile")
   ].filter(Boolean);
   let resolvedCaddy = null;
   let content = null;
   for (const cand of candidates) {
-    const p = path9.resolve(cand);
-    if (fs8.existsSync(p)) {
+    const p = path10.resolve(cand);
+    if (fs10.existsSync(p)) {
       resolvedCaddy = p;
-      content = fs8.readFileSync(p, "utf8");
+      content = fs10.readFileSync(p, "utf8");
       break;
     }
   }
@@ -1934,7 +2146,7 @@ async function run7(args) {
     );
     return 1;
   }
-  const caddyfileDir = path9.dirname(resolvedCaddy);
+  const caddyfileDir = path10.dirname(resolvedCaddy);
   const { sites } = parseCaddyfile(content);
   if (sites.length === 0) {
     console.error(`from-caddy: no sites found in ${resolvedCaddy}`);
@@ -1982,7 +2194,7 @@ async function run7(args) {
       let relScript = "";
       if (entry) {
         relScript = entry;
-        exists = fs8.existsSync(path9.isAbsolute(entry) ? entry : path9.join(dir, entry));
+        exists = fs10.existsSync(path10.isAbsolute(entry) ? entry : path10.join(dir, entry));
         if (!exists) warnings.push(`hint script '${entry}' for ${name} not found under ${dir}`);
       } else {
         const found = findEntry(dir);
@@ -2000,7 +2212,7 @@ async function run7(args) {
       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"));
+          const hasBun2 = fs10.existsSync(path10.join(dir, "bun.lockb")) || fs10.existsSync(path10.join(dir, "bun.lock"));
           if (hasBun2) interpreter = "bun";
         }
       }
@@ -2081,7 +2293,7 @@ Would write ${planned.length} app(s) to ${outPath ?? "relife2.config.cjs (dry-ru
     console.log(`Run without --dry-run to generate.`);
     return 0;
   }
-  const resolvedOut = path9.resolve(outPath ?? "relife2.config.cjs");
+  const resolvedOut = path10.resolve(outPath ?? "relife2.config.cjs");
   const appsCode = planned.map((p) => {
     const interp = p._interpreter;
     const isCaddy = p.name === "caddy";
@@ -2138,7 +2350,7 @@ ${appsCode}
   ]
 };
 `;
-  fs8.writeFileSync(resolvedOut, fileContent, "utf8");
+  fs10.writeFileSync(resolvedOut, fileContent, "utf8");
   console.log(
     `from-caddy: parsed ${sites.length} site(s), ${planned.length} upstream(s) from ${resolvedCaddy}`
   );
@@ -2156,7 +2368,7 @@ Warnings:`);
   console.log(`
 Wrote ${resolvedOut} (${planned.length} app(s))`);
   console.log(
-    `Next: relife2 inspect-config ${path9.basename(resolvedOut)}  \u2192  relife2 start ${path9.basename(resolvedOut)}`
+    `Next: relife2 inspect-config ${path10.basename(resolvedOut)}  \u2192  relife2 start ${path10.basename(resolvedOut)}`
   );
   return 0;
 }
@@ -2185,7 +2397,7 @@ function printUsage2() {
 }
 
 // src/version.ts
-var VERSION = "1.0.1";
+var VERSION = "1.0.2";
 
 // src/commands/help.ts
 var HELP_TEXT = `relife2 ${VERSION} \u2014 process manager for Node.js & Bun apps (PM2 alternative, done right)
@@ -2211,7 +2423,7 @@ Commands:
   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)
+  doctor [--fix]         Run integrity checks on the running daemon (M3) \u2014 --fix heals stale lock + *.tmp.cjs
   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]
@@ -2243,13 +2455,13 @@ function printHelp() {
 }
 
 // src/commands/importpm2.ts
-import * as fs9 from "node:fs";
-import os6 from "node:os";
-import path10 from "node:path";
+import * as fs11 from "node:fs";
+import os7 from "node:os";
+import path11 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)) {
+  const dumpPath = target !== void 0 ? path11.resolve(target) : path11.join(os7.homedir(), ".pm2", "dump.pm2");
+  if (!fs11.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:"
@@ -2259,7 +2471,7 @@ async function run8(args) {
   }
   let raw;
   try {
-    raw = JSON.parse(fs9.readFileSync(dumpPath, "utf8"));
+    raw = JSON.parse(fs11.readFileSync(dumpPath, "utf8"));
   } catch (err) {
     console.error(`import-pm2: cannot parse ${dumpPath}: ${err.message}`);
     return 1;
@@ -2302,11 +2514,11 @@ async function run8(args) {
           }
         ]
       };
-      const tmpPath = path10.join(
-        os6.tmpdir(),
+      const tmpPath = path11.join(
+        os7.tmpdir(),
         `relife2-import-${Date.now()}-${Math.random().toString(36).slice(2)}.cjs`
       );
-      fs9.writeFileSync(tmpPath, `module.exports = ${JSON.stringify(tmpConfig)}`, "utf8");
+      fs11.writeFileSync(tmpPath, `module.exports = ${JSON.stringify(tmpConfig)}`, "utf8");
       try {
         const res = await client.call("start", {
           target: { type: "config", path: tmpPath }
@@ -2322,7 +2534,7 @@ async function run8(args) {
         console.error(`import ${name}: ${err.message}`);
       } finally {
         try {
-          fs9.unlinkSync(tmpPath);
+          fs11.unlinkSync(tmpPath);
         } catch {
         }
       }
@@ -2339,7 +2551,7 @@ imported ${imported} app(s) from ${dumpPath}`);
 }
 
 // src/commands/inspectconfig.ts
-import path11 from "node:path";
+import path12 from "node:path";
 async function run9(args) {
   const { positionals } = parseCliArgs(args);
   const file = positionals[0];
@@ -2349,7 +2561,7 @@ async function run9(args) {
   }
   let loaded;
   try {
-    loaded = await loadConfigFile(path11.resolve(file));
+    loaded = await loadConfigFile(path12.resolve(file));
   } catch (err) {
     console.error(`relife2: ${err.message}`);
     return 1;
@@ -2418,7 +2630,7 @@ function printTable(rows) {
 }
 
 // src/commands/logs.ts
-import * as fs10 from "node:fs";
+import * as fs12 from "node:fs";
 var VALUE_OPTS2 = /* @__PURE__ */ new Set(["lines"]);
 async function run12(args) {
   const { positionals, opts } = parseCliArgs(args, VALUE_OPTS2);
@@ -2458,7 +2670,7 @@ function parseLines(v) {
 }
 function printTail(file, lines) {
   try {
-    const text = fs10.readFileSync(file, "utf8");
+    const text = fs12.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));
@@ -2484,13 +2696,13 @@ async function followFiles(files) {
       const from = positions.get(f) ?? 0;
       if (size > from) {
         try {
-          const fd = fs10.openSync(f, "r");
+          const fd = fs12.openSync(f, "r");
           try {
             const buf = Buffer.alloc(size - from);
-            fs10.readSync(fd, buf, 0, buf.length, from);
+            fs12.readSync(fd, buf, 0, buf.length, from);
             process.stdout.write(buf);
           } finally {
-            fs10.closeSync(fd);
+            fs12.closeSync(fd);
           }
         } catch {
         }
@@ -2501,7 +2713,7 @@ async function followFiles(files) {
 }
 function fileSize(file) {
   try {
-    return fs10.statSync(file).size;
+    return fs12.statSync(file).size;
   } catch {
     return 0;
   }
@@ -2791,7 +3003,7 @@ async function run20(_args) {
 }
 
 // src/commands/start.ts
-import path12 from "node:path";
+import path13 from "node:path";
 var VALUE_OPTS4 = /* @__PURE__ */ new Set([
   "name",
   "env",
@@ -2840,7 +3052,7 @@ async function run21(args) {
     const res = await client.call("start", {
       target: {
         type: isConfig ? "config" : "script",
-        path: path12.resolve(target),
+        path: path13.resolve(target),
         name,
         args: passthrough.length > 0 ? passthrough : void 0,
         envName: envName ?? void 0,
@@ -2867,11 +3079,11 @@ async function run21(args) {
 
 // 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 * as fs13 from "node:fs";
+import os8 from "node:os";
+import path14 from "node:path";
 import { fileURLToPath } from "node:url";
-var SYSTEMD_USER_DIR = path13.join(os7.homedir(), ".config", "systemd", "user");
+var SYSTEMD_USER_DIR = path14.join(os8.homedir(), ".config", "systemd", "user");
 var UNIT_NAME = "relife2.service";
 function getRelife2Bin() {
   const which = spawnSync2(process.platform === "win32" ? "where" : "which", ["relife2"], {
@@ -2889,13 +3101,13 @@ function getRelife2Bin() {
   }
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const cliPath = path13.resolve(path13.dirname(thisFile), "..", "cli.js");
-    if (fs11.existsSync(cliPath)) {
+    const cliPath = path14.resolve(path14.dirname(thisFile), "..", "cli.js");
+    if (fs13.existsSync(cliPath)) {
       return `node ${cliPath}`;
     }
   } catch {
   }
-  return `node ${path13.resolve(arg1 ?? process.cwd())}`;
+  return `node ${path14.resolve(arg1 ?? process.cwd())}`;
 }
 function generateUnit(bin) {
   const envHint = process.env.RELIFE2_DIR !== void 0 ? `
@@ -2916,6 +3128,49 @@ Environment=RELIFE2_DAEMON=1${envHint}
 WantedBy=default.target
 `;
 }
+function isLingerEnabled(user) {
+  try {
+    const out = execSync(`loginctl show-user ${user} -p Linger --value`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3e3
+    });
+    const v = out.trim().toLowerCase();
+    if (v === "yes") return true;
+    if (v === "no") return false;
+  } catch {
+  }
+  try {
+    const out = execSync(`loginctl show-user ${user}`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3e3
+    });
+    if (/Linger=yes/i.test(out)) return true;
+    if (/Linger=no/i.test(out)) return false;
+  } catch {
+  }
+  return null;
+}
+function tryEnableLinger(user) {
+  const attempts = [
+    { cmd: `loginctl enable-linger ${user}`, label: "loginctl" },
+    { cmd: `sudo -n loginctl enable-linger ${user}`, label: "sudo -n" },
+    { cmd: `sudo loginctl enable-linger ${user}`, label: "sudo" }
+  ];
+  for (const a of attempts) {
+    try {
+      execSync(a.cmd, { stdio: ["ignore", "pipe", "pipe"], timeout: 8e3 });
+      const enabled = isLingerEnabled(user);
+      if (enabled === true || enabled === null) {
+        console.log(`enabled linger for user ${user} via ${a.label}`);
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
 async function run22(_args) {
   if (process.platform === "win32") {
     console.error(
@@ -2929,47 +3184,67 @@ async function run22(_args) {
   }
   const bin = getRelife2Bin();
   const unitContent = generateUnit(bin);
-  const unitPath = path13.join(SYSTEMD_USER_DIR, UNIT_NAME);
+  const unitPath = path14.join(SYSTEMD_USER_DIR, UNIT_NAME);
   try {
-    fs11.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+    fs13.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
   } catch (err) {
     console.error(`cannot create ${SYSTEMD_USER_DIR}: ${err.message}`);
     return 1;
   }
   try {
-    fs11.writeFileSync(unitPath, unitContent);
+    fs13.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}`);
+  const user = process.env.USER ?? process.env.LOGNAME ?? os8.userInfo().username ?? "opc";
+  const lingerState = isLingerEnabled(user);
+  if (lingerState === true) {
+    console.log(`linger already enabled for user ${user}`);
+  } else if (lingerState === false) {
+    console.log(`linger is disabled for ${user} \u2014 enabling\u2026`);
+    const ok = tryEnableLinger(user);
+    if (!ok) {
+      console.error(`warning: could not enable linger (is systemd-logind running?)`);
+      console.error(`your apps will only start after you log in. Run manually:`);
+      console.error(`  sudo loginctl enable-linger ${user}`);
+    }
+  } else {
+    const ok = tryEnableLinger(user);
+    if (!ok) {
+      console.error(`note: could not verify linger status (no logind?) \u2014 skipping`);
+    }
   }
   try {
-    execSync("systemctl --user daemon-reload", { stdio: ["ignore", "pipe", "pipe"] });
-    execSync(`systemctl --user enable ${UNIT_NAME}`, { stdio: ["ignore", "pipe", "pipe"] });
+    execSync("systemctl --user daemon-reload", {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 8e3
+    });
+    execSync(`systemctl --user enable ${UNIT_NAME}`, {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 8e3
+    });
     console.log(`enabled and reloaded: systemctl --user enable ${UNIT_NAME}`);
+    try {
+      execSync(`systemctl --user start ${UNIT_NAME}`, {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 8e3
+      });
+      console.log(`started: systemctl --user start ${UNIT_NAME}`);
+    } catch {
+    }
   } 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.error(`  systemctl --user enable --now ${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;
 }
@@ -3165,14 +3440,14 @@ function detectRuntime() {
 }
 
 // src/daemon/daemon.ts
-import * as fs18 from "node:fs";
-import os8 from "node:os";
-import path19 from "node:path";
+import * as fs20 from "node:fs";
+import os9 from "node:os";
+import path20 from "node:path";
 import * as zlib from "node:zlib";
 
 // src/daemon/applog.ts
-import * as fs12 from "node:fs";
-import path14 from "node:path";
+import * as fs14 from "node:fs";
+import path15 from "node:path";
 
 // src/util/datefmt.ts
 function formatDate(pattern, date = /* @__PURE__ */ new Date()) {
@@ -3197,12 +3472,12 @@ function formatDate(pattern, date = /* @__PURE__ */ new Date()) {
 
 // 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");
+var DEFAULT_LOGS_DIR = (base) => path15.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`);
+  const out = app.outFile ? path15.resolve(app.cwd, app.outFile) : path15.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`);
+  const err = app.errFile ? path15.resolve(app.cwd, app.errFile) : path15.join(DEFAULT_LOGS_DIR(base), `${safe}.err.log`);
   return { out, err };
 }
 var AppLogSink = class {
@@ -3247,8 +3522,8 @@ var AppLogSink = class {
       const out = `${this.prefix}${line}
 `;
       try {
-        ensureDirSync(path14.dirname(target));
-        fs12.appendFileSync(target, out);
+        ensureDirSync(path15.dirname(target));
+        fs14.appendFileSync(target, out);
       } catch {
       }
     }
@@ -3256,18 +3531,18 @@ var AppLogSink = class {
 };
 
 // src/daemon/logger.ts
-import fs13 from "node:fs";
-import path15 from "node:path";
+import fs15 from "node:fs";
+import path16 from "node:path";
 function createDaemonLogger(base) {
-  const logsDir = path15.join(base, "logs");
+  const logsDir = path16.join(base, "logs");
   ensureDirSync(logsDir);
-  const mainFile = path15.join(logsDir, "daemon.log");
+  const mainFile = path16.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);
+      fs15.appendFileSync(mainFile, line);
     } catch {
     }
   }
@@ -3276,13 +3551,13 @@ function createDaemonLogger(base) {
   }
   function appOut(name, chunk) {
     try {
-      fs13.appendFileSync(path15.join(outRoot, `${safeName(name)}.out.log`), chunk);
+      fs15.appendFileSync(path16.join(outRoot, `${safeName(name)}.out.log`), chunk);
     } catch {
     }
   }
   function appErr(name, chunk) {
     try {
-      fs13.appendFileSync(path15.join(outRoot, `${safeName(name)}.err.log`), chunk);
+      fs15.appendFileSync(path16.join(outRoot, `${safeName(name)}.err.log`), chunk);
     } catch {
     }
   }
@@ -3291,12 +3566,12 @@ function createDaemonLogger(base) {
 
 // src/daemon/pm.ts
 import { spawn as spawn3 } from "node:child_process";
-import * as fs15 from "node:fs";
-import path17 from "node:path";
+import * as fs17 from "node:fs";
+import path18 from "node:path";
 
 // src/daemon/command.ts
 import { existsSync as existsSync8 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 import process2 from "node:process";
 var JS_RE = /\.(?:c?js|mjs|ts|mts|cts)$/i;
 function isJsScript(p) {
@@ -3306,10 +3581,10 @@ 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"))) {
+    if (existsSync8(path17.join(dir, "bun.lockb")) || existsSync8(path17.join(dir, "bun.lock"))) {
       return true;
     }
-    const parent = path16.dirname(dir);
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     if (home !== "" && dir === home) break;
     dir = parent;
@@ -3345,7 +3620,7 @@ function buildSpawnSpec(app) {
 
 // src/daemon/memproc.ts
 import { execFileSync } from "node:child_process";
-import * as fs14 from "node:fs";
+import * as fs16 from "node:fs";
 function processRss(pid) {
   if (pid <= 0) return void 0;
   try {
@@ -3361,7 +3636,7 @@ function processRss(pid) {
   }
 }
 function rssFromProc(pid) {
-  const status = fs14.readFileSync(`/proc/${pid}/status`, "utf8");
+  const status = fs16.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;
@@ -3436,7 +3711,7 @@ var ProcessManager = class {
       });
       record.config.cwd = cwdFix.path;
     }
-    if (path17.isAbsolute(record.config.script) && !fs15.existsSync(record.config.script)) {
+    if (path18.isAbsolute(record.config.script) && !fs17.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);
@@ -3450,7 +3725,7 @@ var ProcessManager = class {
       } 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.`
+          `script not found: '${record.config.script}'. ${sFix.reason ?? ""} Run 'relife2 find --root ${path18.dirname(record.config.sourceDir)}' to locate configs or fix the config.`
         );
         this.store.saveSync();
         return;
@@ -3766,19 +4041,19 @@ var ProcessManager = class {
     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 rawPaths = Array.isArray(watch3) ? watch3.map((p) => path18.resolve(record.config.cwd, p)) : [record.config.cwd];
     const watchers = [];
     for (const target of rawPaths) {
       try {
-        if (!fs15.existsSync(target)) {
+        if (!fs17.existsSync(target)) {
           this.logger.log(`watch: path '${target}' does not exist yet; skipping`);
           continue;
         }
-        const stat = fs15.statSync(target);
+        const stat = fs17.statSync(target);
         if (!stat.isDirectory()) {
-          const dir = path17.dirname(target);
-          const base = path17.basename(target);
-          const watcher = fs15.watch(dir, (_eventType, filename) => {
+          const dir = path18.dirname(target);
+          const base = path18.basename(target);
+          const watcher = fs17.watch(dir, (_eventType, filename) => {
             if (filename !== null && filename !== base) return;
             this.onWatchChange(record.name, target);
           });
@@ -3786,7 +4061,7 @@ var ProcessManager = class {
           continue;
         }
         if (process.platform === "win32" || process.platform === "darwin") {
-          const watcher = fs15.watch(target, { recursive: true }, () => {
+          const watcher = fs17.watch(target, { recursive: true }, () => {
             this.onWatchChange(record.name, target);
           });
           watchers.push(watcher);
@@ -3794,7 +4069,7 @@ var ProcessManager = class {
           const dirs = this.collectSubDirs(target);
           for (const dir of dirs) {
             try {
-              const watcher = fs15.watch(dir, () => {
+              const watcher = fs17.watch(dir, () => {
                 this.onWatchChange(record.name, target);
               });
               watchers.push(watcher);
@@ -3821,7 +4096,7 @@ var ProcessManager = class {
       const dir = queue.shift();
       let entries;
       try {
-        entries = fs15.readdirSync(dir, { withFileTypes: true });
+        entries = fs17.readdirSync(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -3829,7 +4104,7 @@ var ProcessManager = class {
         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);
+        const full = path18.join(dir, entry.name);
         if (seen.has(full)) continue;
         seen.add(full);
         out.push(full);
@@ -3929,17 +4204,17 @@ var ProcessManager = class {
 };
 
 // src/daemon/state.ts
-import fs16 from "node:fs";
-import path18 from "node:path";
+import fs18 from "node:fs";
+import path19 from "node:path";
 var StateStore = class {
   apps = /* @__PURE__ */ new Map();
   snapshotPath;
   journalPath;
   constructor(base) {
-    const stateDir = path18.join(base, "state");
+    const stateDir = path19.join(base, "state");
     ensureDirSync(stateDir);
-    this.snapshotPath = path18.join(stateDir, "snapshot.json");
-    this.journalPath = path18.join(stateDir, "journal.jsonl");
+    this.snapshotPath = path19.join(stateDir, "snapshot.json");
+    this.journalPath = path19.join(stateDir, "journal.jsonl");
   }
   load() {
     const data = readJsonFile(this.snapshotPath);
@@ -3976,7 +4251,7 @@ var StateStore = class {
     const line = `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), type, ...data ?? {} })}
 `;
     try {
-      fs16.appendFileSync(this.journalPath, line);
+      fs18.appendFileSync(this.journalPath, line);
     } catch {
     }
   }
@@ -3988,7 +4263,7 @@ var StateStore = class {
 };
 
 // src/daemon/transport.ts
-import fs17 from "node:fs";
+import fs19 from "node:fs";
 import net2 from "node:net";
 async function createDaemonTransport(base) {
   return process.platform === "win32" ? createWinTransport(base) : createPosixTransport(base);
@@ -4002,7 +4277,7 @@ async function createPosixTransport(base) {
     if (err.code !== "EADDRINUSE") return null;
     if (await probeActive(sockPath)) return null;
     try {
-      fs17.unlinkSync(sockPath);
+      fs19.unlinkSync(sockPath);
     } catch {
     }
   }
@@ -4055,7 +4330,7 @@ function probeActive(sockPath) {
 }
 function readPortFile(base) {
   try {
-    const raw = fs17.readFileSync(portFilePath(base), "utf8");
+    const raw = fs19.readFileSync(portFilePath(base), "utf8");
     return Number.parseInt(raw.trim(), 10) || null;
   } catch {
     return null;
@@ -4063,7 +4338,7 @@ function readPortFile(base) {
 }
 function writePortFile(base, port) {
   try {
-    fs17.writeFileSync(portFilePath(base), String(port));
+    fs19.writeFileSync(portFilePath(base), String(port));
   } catch {
   }
 }
@@ -4072,7 +4347,7 @@ function writePortFile(base, port) {
 async function runDaemon() {
   const data = dataDir();
   const runtime = runtimeDir();
-  ensureDirSync(path19.join(data, "logs"));
+  ensureDirSync(path20.join(data, "logs"));
   const logger = createDaemonLogger(data);
   logger.log("daemon starting", { pid: process.pid, version: VERSION, platform: process.platform });
   const lock = acquireLock(runtime);
@@ -4287,8 +4562,8 @@ var METHODS = {
       const files = paths.err === null ? [paths.out] : [paths.out, paths.err];
       for (const f of files) {
         try {
-          ensureDirSync(path19.dirname(f));
-          fs18.writeFileSync(f, "");
+          ensureDirSync(path20.dirname(f));
+          fs20.writeFileSync(f, "");
         } catch (err) {
           logger.log(`flush ${rec.name}: cannot truncate ${f}: ${err.message}`);
         }
@@ -4321,7 +4596,7 @@ var METHODS = {
       for (const f of files) {
         if (!pathExists(f)) continue;
         try {
-          const stat = fs18.statSync(f);
+          const stat = fs20.statSync(f);
           if (stat.size >= max) {
             rotateFile(f, n);
             rotated.push(f);
@@ -4375,11 +4650,11 @@ var METHODS = {
   },
   doctor: (_params, { store, base, transport }) => {
     const checks = [];
-    const snapshotPath = path19.join(base, "state", "snapshot.json");
+    const snapshotPath = path20.join(base, "state", "snapshot.json");
     const stateIssues = [];
     if (pathExists(snapshotPath)) {
       try {
-        const data = JSON.parse(fs18.readFileSync(snapshotPath, "utf8"));
+        const data = JSON.parse(fs20.readFileSync(snapshotPath, "utf8"));
         if (data.schema === 1 && typeof data.apps === "object") {
           stateIssues.push({
             severity: "ok",
@@ -4412,11 +4687,11 @@ var METHODS = {
       ok: !stateIssues.some((i) => i.severity === "error"),
       issues: stateIssues
     });
-    const lockFile = path19.join(runtimeDir(), "daemon.lock");
+    const lockFile = path20.join(runtimeDir(), "daemon.lock");
     const lockIssues = [];
     if (pathExists(lockFile)) {
       try {
-        const lock = JSON.parse(fs18.readFileSync(lockFile, "utf8"));
+        const lock = JSON.parse(fs20.readFileSync(lockFile, "utf8"));
         if (typeof lock.pid === "number" && isAlive(lock.pid)) {
           lockIssues.push({
             severity: "ok",
@@ -4527,7 +4802,7 @@ async function startApps(target, ctx) {
     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);
+    const single = normalizeSingleApp(input, path20.dirname(target.path), target.envName);
     apps = [single.app];
     warnings = single.warnings;
   }
@@ -4592,7 +4867,7 @@ function expandTargets(store, 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;
+    if (v === "max" || v === "MAX") app.instances = os9.cpus().length || 1;
     else {
       const n = Number(v);
       if (Number.isFinite(n) && n >= 1) app.instances = Math.round(n);
@@ -4652,15 +4927,15 @@ function rotateFile(file, retain) {
     const newName = `${file}.${i + 1}.gz`;
     if (pathExists(oldName)) {
       if (i + 1 >= retain) {
-        fs18.unlinkSync(oldName);
+        fs20.unlinkSync(oldName);
       } else {
         if (i === 0) {
-          const content = fs18.readFileSync(file);
-          fs18.unlinkSync(file);
+          const content = fs20.readFileSync(file);
+          fs20.unlinkSync(file);
           const gz = zlib.gzipSync(content);
-          fs18.writeFileSync(newName, gz);
+          fs20.writeFileSync(newName, gz);
         } else {
-          fs18.renameSync(oldName, newName);
+          fs20.renameSync(oldName, newName);
         }
       }
     }