@gachlab/devup 0.10.1 → 0.11.0

package/dist/index.js

@@ -3,15 +3,15 @@
 // src/index.ts
 import React7 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync4, realpathSync } from "fs";
-import { dirname as dirname7, join as join10 } from "path";
+import { readFileSync as readFileSync5, realpathSync } from "fs";
+import { dirname as dirname8, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir5 } from "os";
 
 // src/config/loader.ts
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { readFile } from "fs/promises";
-import { resolve, join } from "path";
+import { resolve, join, dirname } from "path";
 import { pathToFileURL } from "url";
 var CONFIG_NAMES = [
   "devup.config.ts",
@@ -33,7 +33,43 @@ function findConfigFile(cwd, explicit) {
 Or use --config <path>`
   );
 }
+function extractEnvFilePath(configPath, raw) {
+  if (configPath.endsWith(".json")) {
+    try {
+      return JSON.parse(raw).envFile ?? null;
+    } catch {
+      return null;
+    }
+  }
+  const m = raw.match(/envFile\s*:\s*['"`]([^'"`]+)['"`]/);
+  return m ? m[1] : null;
+}
+function loadEnvFile(envFilePath) {
+  if (!existsSync(envFilePath)) return;
+  try {
+    const content = readFileSync(envFilePath, "utf8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq < 1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      const val = trimmed.slice(eq + 1).trim().replace(/^(['"`])(.*)\1$/, "$2");
+      if (!(key in process.env)) process.env[key] = val;
+    }
+  } catch {
+  }
+}
 async function loadConfig(configPath) {
+  const configDir = dirname(configPath);
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const envFileRelPath = extractEnvFilePath(configPath, raw);
+    if (envFileRelPath) {
+      loadEnvFile(resolve(configDir, envFileRelPath));
+    }
+  } catch {
+  }
   if (configPath.endsWith(".json")) {
     const raw = await readFile(configPath, "utf8");
     return JSON.parse(raw);
@@ -439,9 +475,9 @@ function filterServices(services, args, config) {
 
 // src/orchestrator/subcommands.ts
 import { spawn as spawn5 } from "child_process";
-import { createReadStream as createReadStream2, watchFile as watchFile2, unwatchFile as unwatchFile2, existsSync as existsSync11, statSync as statSync2 } from "fs";
+import { createReadStream as createReadStream2, watchFile as watchFile2, unwatchFile as unwatchFile2, existsSync as existsSync11, statSync as statSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { join as join9, dirname as dirname3 } from "path";
+import { join as join9, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 import { homedir as homedir4 } from "os";
 import { createInterface as createInterface4 } from "readline";
@@ -496,27 +532,24 @@ function checkHttp(port, opts = {}) {
   };
   return new Promise((resolve4) => {
     const req = http.get({ host, port, path, timeout: timeoutMs }, (res) => {
-      const ok = typeof res.statusCode === "number" && accept(res.statusCode);
+      const code = res.statusCode ?? 0;
+      const ok = typeof res.statusCode === "number" && accept(code);
       res.resume();
-      resolve4(ok);
+      resolve4(ok ? { ok: true } : { ok: false, reason: `HTTP ${code}` });
     });
-    req.on("error", () => resolve4(false));
+    req.on("error", (e) => resolve4({ ok: false, reason: e.code ?? e.message }));
     req.on("timeout", () => {
       req.destroy();
-      resolve4(false);
+      resolve4({ ok: false, reason: `timed out after ${timeoutMs}ms` });
     });
   });
 }
-function checkHealth(port, hc) {
+async function checkHealth(port, hc) {
   if (hc?.type === "http") {
-    return checkHttp(port, {
-      path: hc.path,
-      expect: hc.expect,
-      host: hc.host,
-      timeoutMs: hc.timeoutMs
-    });
+    return checkHttp(port, { path: hc.path, expect: hc.expect, host: hc.host, timeoutMs: hc.timeoutMs });
   }
-  return checkPort(port, "127.0.0.1", hc?.timeoutMs);
+  const ok = await checkPort(port, "127.0.0.1", hc?.timeoutMs);
+  return ok ? { ok: true } : { ok: false, reason: `connection refused on :${port}` };
 }
 function waitForPort(port, opts = {}) {
   const { timeout = 45e3, interval = 1e3 } = opts;
@@ -539,11 +572,11 @@ function deriveHealth(isUp, currentStatus) {
 }
 
 // src/utils/env.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 function parseEnvFile(filePath, baseEnv = {}) {
   const env = { ...baseEnv };
   if (!existsSync3(filePath)) return env;
-  for (const line of readFileSync(filePath, "utf8").split("\n")) {
+  for (const line of readFileSync2(filePath, "utf8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
     const eqIdx = trimmed.indexOf("=");
@@ -606,23 +639,23 @@ function redactSecrets(env) {
 }
 
 // src/utils/install-stamp.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { createHash } from "crypto";
 import { join as join2 } from "path";
 function needsInstall(fullCwd) {
   const nm = join2(fullCwd, "node_modules");
   if (!existsSync4(nm)) return true;
   try {
-    const pkgHash = createHash("md5").update(readFileSync2(join2(fullCwd, "package.json"))).digest("hex");
+    const pkgHash = createHash("md5").update(readFileSync3(join2(fullCwd, "package.json"))).digest("hex");
     const stampFile = join2(nm, ".install-stamp");
-    if (existsSync4(stampFile) && readFileSync2(stampFile, "utf8") === pkgHash) return false;
+    if (existsSync4(stampFile) && readFileSync3(stampFile, "utf8") === pkgHash) return false;
   } catch {
   }
   return true;
 }
 function writeInstallStamp(fullCwd) {
   try {
-    const pkgHash = createHash("md5").update(readFileSync2(join2(fullCwd, "package.json"))).digest("hex");
+    const pkgHash = createHash("md5").update(readFileSync3(join2(fullCwd, "package.json"))).digest("hex");
     writeFileSync(join2(fullCwd, "node_modules", ".install-stamp"), pkgHash);
   } catch {
   }
@@ -703,7 +736,7 @@ import { existsSync as existsSync6 } from "fs";
 import { createServer } from "net";
 import { createInterface } from "readline";
 import { existsSync as existsSync5, unlinkSync, chmodSync, mkdirSync, statSync } from "fs";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 import { join as join3 } from "path";
 import { homedir } from "os";
 function defaultSocketPath(projectName) {
@@ -712,7 +745,7 @@ function defaultSocketPath(projectName) {
 }
 async function startSocketServer(projectName, ctx, opts = {}) {
   const path = opts.path ?? defaultSocketPath(projectName);
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   if (existsSync5(path)) {
     try {
       const st = statSync(path);
@@ -835,7 +868,8 @@ function serializeState(name, st) {
     errors: st.errors,
     restarts: st.restarts,
     pid: st.pid,
-    startedAt: st.startedAt
+    startedAt: st.startedAt,
+    crashLog: st.crashLog ?? null
   };
 }
 function respond(socket, payload) {
@@ -954,7 +988,7 @@ function openStream(socketPath, method, params, onFrame, onError) {
 
 // src/orchestrator/daemon.ts
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync10, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, createReadStream } from "fs";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync4, existsSync as existsSync10, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, createReadStream } from "fs";
 import { join as join8 } from "path";
 import { homedir as homedir3, totalmem, freemem, cpus } from "os";
 import { setTimeout as sleep } from "timers/promises";
@@ -1060,6 +1094,8 @@ var MAX_RESTARTS = 3;
 var BACKOFF_BASE_MS = 2e3;
 
 // src/process/spawner.ts
+var CRASH_LOG_LINES = 20;
+var STARTUP_TIMEOUT_DEFAULT_MS = 45e3;
 var Spawner = class {
   baseCwd;
   env;
@@ -1068,6 +1104,7 @@ var Spawner = class {
   events;
   lifecycle;
   onCrash;
+  startupTimers = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.baseCwd = opts.baseCwd;
     this.env = opts.env;
@@ -1079,6 +1116,7 @@ var Spawner = class {
   }
   async start(svc, colorIdx, isRestart = false) {
     const cwd = join4(this.baseCwd, svc.cwd);
+    this.clearStartupTimer(svc.name);
     if (svc.type === "api") {
       const bindable = await isPortBindable(svc.port);
       if (!bindable && !isRestart) {
@@ -1114,18 +1152,41 @@ var Spawner = class {
       restarts: prev?.restarts ?? 0,
       startedAt: Date.now(),
       intentionalStop: false,
-      colorIdx
+      colorIdx,
+      crashLog: null
     };
     this.state.set(svc.name, state);
     this.procs.add(proc);
     this.events.onStateChange(svc.name, state);
     this.wireStdio(proc, svc, state, colorIdx);
     this.wireCloseHandler(proc, svc, state, colorIdx);
+    this.scheduleStartupTimeout(svc, state, colorIdx);
     if (svc.watchBuild) {
       state.watchProc = this.spawnWatchBuild(svc, cwd, env, colorIdx);
     }
     this.log(svc.name, isRestart ? `\u{1F504} restarted (:${svc.port})` : `\u{1F680} started (:${svc.port})`, colorIdx);
   }
+  scheduleStartupTimeout(svc, state, colorIdx) {
+    const timeoutMs = svc.healthCheck?.startupTimeoutMs ?? STARTUP_TIMEOUT_DEFAULT_MS;
+    if (timeoutMs <= 0) return;
+    const timer = setTimeout(() => {
+      this.startupTimers.delete(svc.name);
+      const current = this.state.get(svc.name);
+      if (!current || current !== state || current.health === "up") return;
+      current.status = "timeout";
+      current.health = "down";
+      this.log(svc.name, `\u23F1 startup timeout after ${timeoutMs / 1e3}s \u2014 service never became healthy`, colorIdx);
+      this.events.onStateChange(svc.name, current);
+    }, timeoutMs);
+    this.startupTimers.set(svc.name, timer);
+  }
+  clearStartupTimer(name) {
+    const t = this.startupTimers.get(name);
+    if (t) {
+      clearTimeout(t);
+      this.startupTimers.delete(name);
+    }
+  }
   wireStdio(proc, svc, state, colorIdx) {
     const readyRegex = compileReadyPattern(svc.readyPattern);
     const markReadyIfMatch = (line) => {
@@ -1133,29 +1194,37 @@ var Spawner = class {
       if (readyRegex.test(line)) {
         state.health = "up";
         if (state.status === "starting") state.status = "running";
+        this.clearStartupTimer(svc.name);
         this.events.onStateChange(svc.name, state);
       }
     };
     const errorRegex = compileReadyPattern(svc.errorPattern);
     const countsAsError = (line) => errorRegex ? errorRegex.test(line) : true;
+    const stderrBuf = [];
     const stdoutBuf = lineBuffer((line) => {
       markReadyIfMatch(line);
       this.log(svc.name, line, colorIdx);
     });
-    const stderrBuf = lineBuffer((line) => {
+    const stderrLineBuf = lineBuffer((line) => {
       if (countsAsError(line)) state.errors += 1;
       markReadyIfMatch(line);
+      stderrBuf.push(line);
+      if (stderrBuf.length > CRASH_LOG_LINES) stderrBuf.shift();
       this.log(svc.name, line, colorIdx);
     });
     proc.stdout?.on("data", (d) => stdoutBuf.push(d));
-    proc.stderr?.on("data", (d) => stderrBuf.push(d));
+    proc.stderr?.on("data", (d) => stderrLineBuf.push(d));
     proc.stdout?.on("end", () => stdoutBuf.flush());
-    proc.stderr?.on("end", () => stderrBuf.flush());
+    proc.stderr?.on("end", () => {
+      stderrLineBuf.flush();
+      state._stderrBuf = stderrBuf;
+    });
   }
   wireCloseHandler(proc, svc, state, colorIdx) {
     proc.on("close", (code) => {
       this.procs.delete(proc);
       this.lifecycle.stopWatchProc(state);
+      this.clearStartupTimer(svc.name);
       if (state.intentionalStop) {
         state.intentionalStop = false;
         return;
@@ -1168,6 +1237,8 @@ var Spawner = class {
       }
       state.status = "crashed";
       state.health = "down";
+      const buf = state._stderrBuf;
+      state.crashLog = buf && buf.length ? [...buf] : null;
       this.log(svc.name, `\u274C exited with code ${code}`, colorIdx);
       this.events.onStateChange(svc.name, state);
       this.onCrash(svc, state, colorIdx);
@@ -1205,9 +1276,7 @@ var Spawner = class {
   spawnWatchBuild(svc, cwd, env, colorIdx) {
     this.log(svc.name, `\u{1F440} watchBuild: ${svc.watchBuild}`, colorIdx);
     const isWin = process.platform === "win32";
-    const shell = isWin ? "cmd.exe" : "sh";
-    const shellFlag = isWin ? "/c" : "-c";
-    const child = spawn2(shell, [shellFlag, svc.watchBuild], {
+    const child = spawn2(isWin ? "cmd.exe" : "sh", [isWin ? "/c" : "-c", svc.watchBuild], {
       cwd,
       env,
       detached: true,
@@ -1220,8 +1289,6 @@ var Spawner = class {
     child.on("error", (err) => this.log(svc.name, `[watch] \u274C ${err.message}`, colorIdx));
     return child;
   }
-  /** Create a state entry in 'crashed' status without spawning a process
-   *  (used when preBuild fails or pre-flight checks fail). */
   recordCrashedState(svc, colorIdx) {
     const prev = this.state.get(svc.name);
     this.state.set(svc.name, {
@@ -1234,7 +1301,8 @@ var Spawner = class {
       restarts: prev?.restarts ?? 0,
       startedAt: null,
       intentionalStop: false,
-      colorIdx
+      colorIdx,
+      crashLog: null
     });
     this.events.onStateChange(svc.name, this.state.get(svc.name));
   }
@@ -1281,13 +1349,14 @@ var Restarter = class {
 var HealthPoller = class {
   state;
   events;
+  failureCounts = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.state = opts.state;
     this.events = opts.events;
   }
   async checkAll() {
     for (const [name, st] of this.state) {
-      if (!st.pid || st.status === "idle") {
+      if (!st.pid || st.status === "idle" || st.status === "timeout") {
         st.health = st.status === "idle" ? "idle" : "down";
         continue;
       }
@@ -1295,10 +1364,22 @@ var HealthPoller = class {
       if (startPeriodMs > 0 && st.startedAt && Date.now() - st.startedAt < startPeriodMs) {
         continue;
       }
-      const isUp = await checkHealth(st.svc.port, st.svc.healthCheck);
+      const result = await checkHealth(st.svc.port, st.svc.healthCheck);
+      const threshold = st.svc.healthCheck?.failureThreshold ?? 2;
       const prev = st.health;
-      st.health = deriveHealth(isUp, st.status);
-      if (st.health === "up" && st.status === "starting") st.status = "running";
+      if (result.ok) {
+        this.failureCounts.delete(name);
+        st.health = deriveHealth(true, st.status);
+        if (st.health === "up" && st.status === "starting") st.status = "running";
+      } else {
+        const count = (this.failureCounts.get(name) ?? 0) + 1;
+        this.failureCounts.set(name, count);
+        if (count >= threshold) {
+          const reason = result.reason ?? "probe failed";
+          this.events.onLog(name, `[health] \u2717 ${name}: ${reason} (${count} consecutive failure${count > 1 ? "s" : ""})`, st.colorIdx);
+          st.health = deriveHealth(false, st.status);
+        }
+      }
       if (prev !== st.health) this.events.onStateChange(name, st);
     }
   }
@@ -1444,44 +1525,82 @@ var ProcessManager = class {
 };
 
 // src/process/log-sink.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync2, renameSync, createWriteStream } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, renameSync, createWriteStream, statSync as statSync2 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 import { homedir as homedir2 } from "os";
+var DEFAULT_MAX_LOG_BYTES = 10 * 1024 * 1024;
 var LogSink = class {
   dir;
   rotateOnStart;
+  maxLogBytes;
   streams = /* @__PURE__ */ new Map();
   seen = /* @__PURE__ */ new Set();
+  bytesWritten = /* @__PURE__ */ new Map();
   constructor(opts) {
     const root = opts.rootDir ?? join6(homedir2(), ".devup", "logs");
     this.dir = join6(root, sanitize(opts.projectName));
     this.rotateOnStart = opts.rotateOnStart ?? true;
+    this.maxLogBytes = opts.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
     mkdirSync2(this.dir, { recursive: true });
   }
-  /** Returns the file path for a service log (useful for tests / UI). */
   pathFor(svcName) {
     return join6(this.dir, `${sanitize(svcName)}.log`);
   }
   write(svcName, line) {
+    const entry = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`;
+    const bytes = Buffer.byteLength(entry, "utf8");
+    const current = this.bytesWritten.get(svcName) ?? this.estimateCurrentSize(svcName);
+    if (current + bytes > this.maxLogBytes) {
+      this.rotateFile(svcName);
+    }
     const stream = this.streamFor(svcName);
-    stream.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${line}
-`);
+    stream.write(entry, (err) => {
+      if (err && svcName !== "devup") {
+        this.streamFor("devup").write(
+          `${(/* @__PURE__ */ new Date()).toISOString()} \u26A0 log write error for "${svcName}": ${err.message}
+`
+        );
+      }
+    });
+    this.bytesWritten.set(svcName, (this.bytesWritten.get(svcName) ?? 0) + bytes);
   }
   async close() {
-    const closes = [...this.streams.values()].map(
-      (s) => new Promise((r) => s.end(() => r()))
-    );
+    const closes = [...this.streams.values()].map((s) => new Promise((r) => s.end(() => r())));
     this.streams.clear();
     this.seen.clear();
+    this.bytesWritten.clear();
     await Promise.all(closes);
   }
+  rotateFile(svcName) {
+    const existing = this.streams.get(svcName);
+    if (existing) {
+      existing.destroy();
+      this.streams.delete(svcName);
+    }
+    const file = this.pathFor(svcName);
+    if (existsSync9(file)) {
+      try {
+        renameSync(file, file + ".prev");
+      } catch {
+      }
+    }
+    this.bytesWritten.set(svcName, 0);
+  }
+  estimateCurrentSize(svcName) {
+    try {
+      return statSync2(this.pathFor(svcName)).size;
+    } catch {
+      return 0;
+    }
+  }
   streamFor(svcName) {
     let s = this.streams.get(svcName);
     if (s) return s;
     const file = this.pathFor(svcName);
     if (this.rotateOnStart && !this.seen.has(svcName) && existsSync9(file)) {
       try {
-        mkdirSync2(dirname2(file), { recursive: true });
+        mkdirSync2(dirname3(file), { recursive: true });
         renameSync(file, file + ".prev");
       } catch {
       }
@@ -1589,7 +1708,7 @@ async function waitHealthy(svc, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   const port = svc.port;
   while (Date.now() < deadline) {
-    if (await checkHealth(port, svc.healthCheck)) return true;
+    if ((await checkHealth(port, svc.healthCheck)).ok) return true;
     await new Promise((r) => setTimeout(r, 500));
   }
   return false;
@@ -1856,7 +1975,7 @@ function isDaemonRunning(projectName) {
   if (!existsSync10(path)) return { pid: null, stale: false };
   let pid;
   try {
-    pid = Number(readFileSync3(path, "utf8").trim());
+    pid = Number(readFileSync4(path, "utf8").trim());
     if (!pid || !Number.isFinite(pid)) return { pid: null, stale: true };
   } catch {
     return { pid: null, stale: true };
@@ -2133,7 +2252,8 @@ async function bootLazy(mgr, services, lazyCfg, lazyTimeout, lazyProxies) {
       restarts: 0,
       startedAt: null,
       intentionalStop: false,
-      colorIdx: ci
+      colorIdx: ci,
+      crashLog: null
     });
     const proxy = createLazyProxy({
       listenPort: svc.port,
@@ -2212,7 +2332,7 @@ async function runDetached(opts) {
   const deadline = Date.now() + 9e4;
   while (Date.now() < deadline) {
     if (existsSync10(pidPath)) {
-      const pid = Number(readFileSync3(pidPath, "utf8").trim());
+      const pid = Number(readFileSync4(pidPath, "utf8").trim());
       out("");
       out(`\u{1F680} devup detached (PID ${pid})`);
       out("   inspect:  devup ctl status");
@@ -2221,7 +2341,7 @@ async function runDetached(opts) {
       return 0;
     }
     if (existsSync10(errPath)) {
-      const msg = readFileSync3(errPath, "utf8").trim();
+      const msg = readFileSync4(errPath, "utf8").trim();
       out(`\u274C daemon boot failed: ${msg}`);
       try {
         unlinkSync2(errPath);
@@ -2294,7 +2414,7 @@ async function stopDaemon(projectName, opts = {}) {
 }
 
 // src/orchestrator/subcommands.ts
-var KNOWN = /* @__PURE__ */ new Set(["logs", "install", "status", "help", "ctl", "up", "down"]);
+var KNOWN = /* @__PURE__ */ new Set(["logs", "install", "status", "help", "ctl", "up", "down", "config"]);
 function detectSubcommand(argv) {
   const first = argv[0];
   return first && KNOWN.has(first) ? first : null;
@@ -2326,7 +2446,7 @@ async function runLogs(argv, opts) {
   }
   await streamFile(file, out);
   if (!follow) return 0;
-  return await followFile(file, out, statSync2(file).size);
+  return await followFile(file, out, statSync3(file).size);
 }
 async function streamFile(file, out) {
   return new Promise((resolve4, reject) => {
@@ -2341,7 +2461,7 @@ async function followFile(file, out, startAt = 0) {
   while (!existsSync11(file)) await new Promise((r) => setTimeout(r, 500));
   return new Promise((resolve4) => {
     const tick = async () => {
-      const size = statSync2(file).size;
+      const size = statSync3(file).size;
       if (size > pos) {
         await new Promise((res) => {
           const rl = createInterface4({ input: createReadStream2(file, { encoding: "utf8", start: pos, end: size - 1 }) });
@@ -2422,7 +2542,7 @@ async function runStatus(opts) {
   out(`${"Service".padEnd(maxLen)}  ${"Port".padStart(5)}  ${"Type".padEnd(4)}  Health`);
   out("-".repeat(maxLen + 24));
   for (const svc of opts.config.services) {
-    const up = await checkHealth(svc.port, svc.healthCheck);
+    const { ok: up } = await checkHealth(svc.port, svc.healthCheck);
     const health = up ? "\u2713 up" : "\u2717 down";
     out(`${svc.name.padEnd(maxLen)}  ${String(svc.port).padStart(5)}  ${svc.type.padEnd(4)}  ${health}`);
   }
@@ -2465,15 +2585,6 @@ async function runCtl(argv, opts) {
       out(`pong  ts=${res.ts}`);
       return 0;
     }
-    if (method === "status" && !follow) {
-      const res = await sendRpc(socketPath, "status");
-      if (!res.services.length) {
-        out("(no services)");
-        return 0;
-      }
-      fmtStatus(res.services, out);
-      return 0;
-    }
     if (method === "status" && follow) {
       return await new Promise((resolve4) => {
         const abort = openStream(socketPath, "status.follow", {}, (frame) => {
@@ -2516,15 +2627,47 @@ async function runCtl(argv, opts) {
         });
       });
     }
+    if (method === "status" && !follow) {
+      const json = argv.includes("--json");
+      const res = await sendRpc(socketPath, "status");
+      if (json) {
+        out(JSON.stringify(res.services, null, 2));
+      } else {
+        if (!res.services.length) {
+          out("(no services)");
+          return 0;
+        }
+        fmtStatus(res.services, out);
+      }
+      return 0;
+    }
     if (method === "restart") {
       const svc = argv[1];
       if (!svc) {
-        out("usage: devup ctl restart <service>");
+        out("usage: devup ctl restart <service> [--wait] [--timeout <s>]");
         return 1;
       }
+      const wait = argv.includes("--wait");
+      const timeoutIdx = argv.indexOf("--timeout");
+      const timeoutSec = timeoutIdx >= 0 ? Number(argv[timeoutIdx + 1] ?? 60) : 60;
       await sendRpc(socketPath, "restart", { svc });
-      out(`\u2713 restart sent to ${svc}`);
-      return 0;
+      if (!wait) {
+        out(`\u2713 restart sent to ${svc}`);
+        return 0;
+      }
+      out(`\u23F3 waiting for ${svc} to become healthy\u2026`);
+      const deadline = Date.now() + timeoutSec * 1e3;
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 500));
+        const status = await sendRpc(socketPath, "status");
+        const row = status.services.find((s) => s.name === svc);
+        if (row?.health === "up") {
+          out(`\u2713 ${svc} is healthy`);
+          return 0;
+        }
+      }
+      out(`\u2717 ${svc} did not become healthy within ${timeoutSec}s`);
+      return 1;
     }
     if (method === "stop") {
       const svc = argv[1];
@@ -2543,6 +2686,63 @@ async function runCtl(argv, opts) {
     return 1;
   }
 }
+async function runConfig(argv, opts) {
+  const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
+  const subcmd = argv[0];
+  const json = argv.includes("--json");
+  if (!subcmd || subcmd === "help") {
+    out("Usage: devup config <subcommand>");
+    out("  validate [--json]   Validate the config and print errors/warnings");
+    out("  show [--no-redact]  Print the fully-resolved config as JSON");
+    return 0;
+  }
+  let cfgPath;
+  try {
+    cfgPath = findConfigFile(opts.cwd, opts.configPath);
+  } catch (e) {
+    out(`\u274C ${e.message}`);
+    return 1;
+  }
+  let config;
+  try {
+    config = await loadConfig(cfgPath);
+  } catch (e) {
+    out(`\u274C failed to load config: ${e.message}`);
+    return 1;
+  }
+  if (subcmd === "validate") {
+    const errors = validateConfig(config, opts.cwd);
+    const warnings = collectWarnings(config);
+    if (json) {
+      out(JSON.stringify({ valid: errors.length === 0, errors: errors.map((e) => `${e.field}: ${e.message}`), warnings: warnings.map((w) => `${w.field}: ${w.message}`) }, null, 2));
+    } else {
+      if (errors.length) {
+        out(formatValidationErrors(errors));
+      }
+      if (warnings.length) {
+        out(formatValidationWarnings(warnings));
+      }
+      if (!errors.length) out(`\u2713 config is valid (${config.services.length} services${warnings.length ? `, ${warnings.length} warning${warnings.length > 1 ? "s" : ""}` : ""})`);
+    }
+    return errors.length ? 1 : 0;
+  }
+  if (subcmd === "show") {
+    const noRedact = argv.includes("--no-redact");
+    const resolved = noRedact ? config : redactConfig(config);
+    out(JSON.stringify(resolved, null, 2));
+    return 0;
+  }
+  out(`unknown config subcommand: ${subcmd}`);
+  return 1;
+}
+function redactConfig(config) {
+  const clone = JSON.parse(JSON.stringify(config));
+  for (const svc of clone.services ?? []) {
+    if (svc.extraEnv) svc.extraEnv = redactSecrets(svc.extraEnv);
+  }
+  if (clone.env) clone.env = redactSecrets(clone.env);
+  return clone;
+}
 async function runDown(opts) {
   const out = opts.out ?? ((l) => process.stdout.write(l + "\n"));
   return stopDaemon(opts.config.name, { out });
@@ -2741,7 +2941,7 @@ async function detectPlatform() {
 
 // src/proxy-config/traefik.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 var EMPTY_CONFIG = "http:\n  routers: {}\n  services: {}\n";
 var TraefikProvider = class {
   name = "traefik";
@@ -2778,7 +2978,7 @@ ${svcs.join("\n")}
 `;
   }
   write(content, opts) {
-    const dir = dirname4(opts.confPath);
+    const dir = dirname5(opts.confPath);
     if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
     writeFileSync3(opts.confPath, content);
   }
@@ -2789,7 +2989,7 @@ ${svcs.join("\n")}
 
 // src/proxy-config/nginx.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 var EMPTY_CONFIG2 = "# devup: no healthy services\n";
 var NginxProvider = class {
   name = "nginx";
@@ -2826,7 +3026,7 @@ var NginxProvider = class {
     return blocks.join("\n\n") + "\n";
   }
   write(content, opts) {
-    const dir = dirname5(opts.confPath);
+    const dir = dirname6(opts.confPath);
     if (!existsSync13(dir)) mkdirSync5(dir, { recursive: true });
     writeFileSync4(opts.confPath, content);
   }
@@ -2837,7 +3037,7 @@ var NginxProvider = class {
 
 // src/proxy-config/caddy.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 var EMPTY_CONFIG3 = "# devup: no healthy services\n";
 var CaddyProvider = class {
   name = "caddy";
@@ -2860,7 +3060,7 @@ var CaddyProvider = class {
     return blocks.join("\n\n") + "\n";
   }
   write(content, opts) {
-    const dir = dirname6(opts.confPath);
+    const dir = dirname7(opts.confPath);
     if (!existsSync14(dir)) mkdirSync6(dir, { recursive: true });
     writeFileSync5(opts.confPath, content);
   }
@@ -3574,7 +3774,8 @@ function useBootSequence(manager, config, services, cliArgs, platform, env, base
             restarts: 0,
             startedAt: null,
             intentionalStop: false,
-            colorIdx: ci
+            colorIdx: ci,
+            crashLog: null
           };
           mgr.state.set(svc.name, idleState);
           const proxy = createLazyProxy({
@@ -4108,7 +4309,7 @@ async function runOnce(opts) {
 }
 async function waitHealthy2(svc, deadline) {
   while (Date.now() < deadline) {
-    const ok = await checkHealth(svc.port, svc.healthCheck);
+    const { ok } = await checkHealth(svc.port, svc.healthCheck);
     if (ok) return true;
     await new Promise((r) => setTimeout(r, 500));
   }
@@ -4123,9 +4324,9 @@ function defineConfig(config) {
 // src/index.ts
 function readVersion() {
   try {
-    const here = dirname7(fileURLToPath2(import.meta.url));
+    const here = dirname8(fileURLToPath2(import.meta.url));
     const pkgPath = join10(here, "..", "package.json");
-    return JSON.parse(readFileSync4(pkgPath, "utf8")).version ?? "unknown";
+    return JSON.parse(readFileSync5(pkgPath, "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -4162,6 +4363,7 @@ async function main() {
     if (subcmd === "status") process.exit(await runStatus(subOpts));
     if (subcmd === "ctl") process.exit(await runCtl(subArgs, subOpts));
     if (subcmd === "down") process.exit(await runDown(subOpts));
+    if (subcmd === "config") process.exit(await runConfig(subArgs, { cwd, configPath: cliArgs.configPath }));
   }
   let configPath;
   try {