@gachlab/devup 0.2.0 → 0.3.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import React7 from "react";
 import { render } from "ink";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/config/loader.ts
@@ -112,6 +112,25 @@ function validateConfig(config, cwd) {
     if (svc.cwd && !existsSync2(resolve2(cwd, svc.cwd))) {
       errors.push({ field: `services[${svc.name}].cwd`, message: `Directory not found: ${svc.cwd}` });
     }
+    if (svc.readyPattern !== void 0) {
+      if (typeof svc.readyPattern !== "string" || !svc.readyPattern.length) {
+        errors.push({ field: `services[${svc.name}].readyPattern`, message: `readyPattern must be a non-empty string` });
+      } else {
+        const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(svc.readyPattern);
+        try {
+          if (slashed) new RegExp(slashed[1], slashed[2] || "i");
+          else new RegExp(svc.readyPattern, "i");
+        } catch (e) {
+          errors.push({ field: `services[${svc.name}].readyPattern`, message: `Invalid regex: ${e.message}` });
+        }
+      }
+    }
+    if (svc.preBuild !== void 0 && (typeof svc.preBuild !== "string" || !svc.preBuild.trim())) {
+      errors.push({ field: `services[${svc.name}].preBuild`, message: `preBuild must be a non-empty string` });
+    }
+    if (svc.watchBuild !== void 0 && (typeof svc.watchBuild !== "string" || !svc.watchBuild.trim())) {
+      errors.push({ field: `services[${svc.name}].watchBuild`, message: `watchBuild must be a non-empty string` });
+    }
     if (svc.healthCheck) {
       const hc = svc.healthCheck;
       if (hc.type !== "tcp" && hc.type !== "http") {
@@ -145,6 +164,34 @@ function validateConfig(config, cwd) {
       }
     }
   }
+  if (config.external) {
+    const extNames = /* @__PURE__ */ new Set();
+    for (const ext of config.external) {
+      if (!ext.name?.trim()) {
+        errors.push({ field: "external[].name", message: "External service name is required" });
+        continue;
+      }
+      if (extNames.has(ext.name)) {
+        errors.push({ field: `external[${ext.name}].name`, message: `Duplicate external name: ${ext.name}` });
+      }
+      extNames.add(ext.name);
+      if (!ext.cmd?.trim()) {
+        errors.push({ field: `external[${ext.name}].cmd`, message: "cmd is required" });
+      }
+      if (ext.healthCheck) {
+        const hc = ext.healthCheck;
+        if (hc.type !== "tcp" && hc.type !== "http") {
+          errors.push({ field: `external[${ext.name}].healthCheck.type`, message: `Invalid healthCheck.type: ${hc.type}` });
+        }
+        if ((hc.type === "tcp" || hc.type === "http") && (typeof ext.port !== "number" || ext.port <= 0)) {
+          errors.push({ field: `external[${ext.name}].port`, message: `port is required when healthCheck is set (got ${ext.port})` });
+        }
+        if (hc.type === "http" && hc.path && !hc.path.startsWith("/")) {
+          errors.push({ field: `external[${ext.name}].healthCheck.path`, message: `must start with "/"` });
+        }
+      }
+    }
+  }
   if (config.proxy?.routes) {
     for (const ref of Object.keys(config.proxy.routes)) {
       if (!names.has(ref)) {
@@ -152,6 +199,19 @@ function validateConfig(config, cwd) {
       }
     }
   }
+  if (config.profiles) {
+    for (const [profile, svcNames] of Object.entries(config.profiles)) {
+      if (!Array.isArray(svcNames) || !svcNames.length) {
+        errors.push({ field: `profiles.${profile}`, message: `Profile "${profile}" must be a non-empty array of service names` });
+        continue;
+      }
+      for (const ref of svcNames) {
+        if (!names.has(ref)) {
+          errors.push({ field: `profiles.${profile}`, message: `Unknown service: ${ref}` });
+        }
+      }
+    }
+  }
   return errors;
 }
 function formatValidationErrors(errors) {
@@ -194,6 +254,10 @@ function parseCliArgs(argv) {
         args.services = next?.split(",");
         i++;
         break;
+      case "--profile":
+        args.profile = next;
+        i++;
+        break;
       case "--lazy":
         args.lazy = true;
         break;
@@ -246,9 +310,18 @@ function parseCliArgs(argv) {
   }
   return args;
 }
-function filterServices(services, args) {
+function filterServices(services, args, config) {
   let result = services;
-  if (args.services) {
+  if (args.profile) {
+    const profileNames = config?.profiles?.[args.profile];
+    if (!profileNames) {
+      const available = Object.keys(config?.profiles ?? {});
+      const hint = available.length ? `Available: ${available.join(", ")}` : "No profiles defined in config.";
+      throw new Error(`Unknown profile: "${args.profile}". ${hint}`);
+    }
+    const set = new Set(profileNames);
+    result = result.filter((s) => set.has(s.name));
+  } else if (args.services) {
     const explicit = new Set(args.services);
     result = result.filter((s) => explicit.has(s.name));
   } else if (args.only) {
@@ -666,6 +739,16 @@ function installService(cwd, env, onLog) {
 // src/process/manager.ts
 var MAX_RESTARTS = 3;
 var BACKOFF_BASE_MS = 2e3;
+function compileReadyPattern(pattern) {
+  if (!pattern) return null;
+  const slashed = /^\/(.+)\/([gimsuy]*)$/.exec(pattern);
+  try {
+    if (slashed) return new RegExp(slashed[1], slashed[2] || "i");
+    return new RegExp(pattern, "i");
+  } catch {
+    return null;
+  }
+}
 function lineBuffer(onLine) {
   let buf = "";
   return {
@@ -713,6 +796,13 @@ var ProcessManager = class {
         return;
       }
     }
+    if (svc.preBuild) {
+      const built = await this.runPreBuild(svc, cwd, colorIdx);
+      if (!built) {
+        this.recordCrashedState(svc, colorIdx);
+        return;
+      }
+    }
     const args = buildProcessArgs(svc);
     const env = buildProcessEnv(svc, this.env);
     const proc = spawn2(svc.cmd, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
@@ -732,9 +822,22 @@ var ProcessManager = class {
     this.state.set(svc.name, state);
     this.procs.add(proc);
     this.events.onStateChange(svc.name, state);
-    const stdoutBuf = lineBuffer((line) => this.log(svc.name, line, colorIdx));
+    const readyRegex = compileReadyPattern(svc.readyPattern);
+    const markReadyIfMatch = (line) => {
+      if (!readyRegex || state.health === "up") return;
+      if (readyRegex.test(line)) {
+        state.health = "up";
+        if (state.status === "starting") state.status = "running";
+        this.events.onStateChange(svc.name, state);
+      }
+    };
+    const stdoutBuf = lineBuffer((line) => {
+      markReadyIfMatch(line);
+      this.log(svc.name, line, colorIdx);
+    });
     const stderrBuf = lineBuffer((line) => {
       state.errors += 1;
+      markReadyIfMatch(line);
       this.log(svc.name, line, colorIdx);
     });
     proc.stdout?.on("data", (d) => stdoutBuf.push(d));
@@ -743,6 +846,7 @@ var ProcessManager = class {
     proc.stderr?.on("end", () => stderrBuf.flush());
     proc.on("close", (code) => {
       this.procs.delete(proc);
+      this.stopWatchProc(state);
       if (state.intentionalStop) {
         state.intentionalStop = false;
         return;
@@ -766,13 +870,90 @@ var ProcessManager = class {
         this.log(svc.name, "\u26D4 max restarts reached", 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);
   }
+  runPreBuild(svc, cwd, colorIdx) {
+    this.log(svc.name, `\u{1F528} preBuild: ${svc.preBuild}`, colorIdx);
+    return new Promise((resolve3) => {
+      const isWin = process.platform === "win32";
+      const shell = isWin ? "cmd.exe" : "sh";
+      const shellFlag = isWin ? "/c" : "-c";
+      const env = buildProcessEnv(svc, this.env);
+      const child = spawn2(shell, [shellFlag, svc.preBuild], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+      const outBuf = lineBuffer((line) => this.log(svc.name, `[build] ${line}`, colorIdx));
+      const errBuf = lineBuffer((line) => this.log(svc.name, `[build] ${line}`, colorIdx));
+      child.stdout?.on("data", (d) => outBuf.push(d));
+      child.stderr?.on("data", (d) => errBuf.push(d));
+      child.on("error", (err) => {
+        this.log(svc.name, `[build] \u274C ${err.message}`, colorIdx);
+        resolve3(false);
+      });
+      child.on("close", (code) => {
+        outBuf.flush();
+        errBuf.flush();
+        if (code === 0) {
+          this.log(svc.name, `[build] \u2705 done`, colorIdx);
+          resolve3(true);
+        } else {
+          this.log(svc.name, `[build] \u274C exited with code ${code}`, colorIdx);
+          resolve3(false);
+        }
+      });
+    });
+  }
+  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], {
+      cwd,
+      env,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const outBuf = lineBuffer((line) => this.log(svc.name, `[watch] ${line}`, colorIdx));
+    const errBuf = lineBuffer((line) => this.log(svc.name, `[watch] ${line}`, colorIdx));
+    child.stdout?.on("data", (d) => outBuf.push(d));
+    child.stderr?.on("data", (d) => errBuf.push(d));
+    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). */
+  recordCrashedState(svc, colorIdx) {
+    const prev = this.state.get(svc.name);
+    this.state.set(svc.name, {
+      svc,
+      proc: null,
+      pid: null,
+      status: "crashed",
+      health: "down",
+      errors: prev?.errors ?? 0,
+      restarts: prev?.restarts ?? 0,
+      startedAt: null,
+      intentionalStop: false,
+      colorIdx
+    });
+    this.events.onStateChange(svc.name, this.state.get(svc.name));
+  }
   stop(name) {
     const st = this.state.get(name);
     if (!st?.proc || !st.pid) return;
     st.intentionalStop = true;
     this.platform.killTree(st.pid);
+    this.stopWatchProc(st);
+  }
+  stopWatchProc(state) {
+    const wp = state.watchProc;
+    if (!wp || !wp.pid) return;
+    try {
+      this.platform.killTree(wp.pid);
+    } catch {
+    }
+    state.watchProc = null;
   }
   async restart(name) {
     const st = this.state.get(name);
@@ -803,9 +984,13 @@ var ProcessManager = class {
     if (!procs.length) return;
     for (const proc of procs) {
       const st = this.findStateByProc(proc);
-      if (st) st.intentionalStop = true;
+      if (st) {
+        st.intentionalStop = true;
+        this.stopWatchProc(st);
+      }
       if (proc.pid) this.platform.killTree(proc.pid);
     }
+    for (const st of this.state.values()) this.stopWatchProc(st);
     const waits = procs.map(
       (p) => p.exitCode !== null || p.signalCode !== null ? Promise.resolve() : new Promise((resolve3) => p.once("close", () => resolve3()))
     );
@@ -913,6 +1098,21 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
     pendingLogsRef.current = [];
     setLogs([]);
   }, []);
+  const pushLog = useCallback((svcName, text, colorIdx = 0) => {
+    sinkRef.current?.write(svcName, text);
+    const entry = { svcName, text, colorIdx, ts: Date.now() };
+    if (pausedRef.current) {
+      pendingLogsRef.current.push(entry);
+      if (pendingLogsRef.current.length > 5e3) {
+        pendingLogsRef.current = pendingLogsRef.current.slice(-5e3);
+      }
+      return;
+    }
+    setLogs((prev) => {
+      const next = prev.concat(entry);
+      return next.length > 5e3 ? next.slice(-5e3) : next;
+    });
+  }, []);
   const setPaused = useCallback((paused) => {
     pausedRef.current = paused;
     if (!paused && pendingLogsRef.current.length) {
@@ -935,6 +1135,7 @@ function useProcessManager(platform, baseCwd, env, logSink = null) {
     cleanup: useCallback(() => mgr?.cleanup(), [mgr]),
     clearLogs,
     setPaused,
+    pushLog,
     manager: mgr
   };
 }
@@ -1445,6 +1646,86 @@ function createLazyProxy(opts) {
   };
 }
 
+// src/process/external.ts
+import { spawn as spawn3 } from "child_process";
+import { join as join4 } from "path";
+var DEFAULT_START_TIMEOUT_S = 60;
+async function startExternals(externals, opts) {
+  const procs = [];
+  const failed = [];
+  for (const svc of externals) {
+    const proc = spawnExternal(svc, opts);
+    procs.push({ svc, proc, pid: proc.pid ?? null });
+    if (!svc.healthCheck) {
+      opts.onLog?.(svc.name, "\u2705 started (no healthCheck)");
+      continue;
+    }
+    if (svc.healthCheck.type === "tcp" && !svc.port) {
+      opts.onLog?.(svc.name, "\u26A0 tcp healthCheck requires `port` \u2014 skipping wait");
+      continue;
+    }
+    const timeoutMs = (svc.startTimeout ?? DEFAULT_START_TIMEOUT_S) * 1e3;
+    const ok = await waitHealthy(svc, timeoutMs);
+    if (ok) {
+      opts.onLog?.(svc.name, "\u2705 healthy");
+    } else {
+      opts.onLog?.(svc.name, `\u274C never became healthy (timeout ${timeoutMs / 1e3}s)`);
+      failed.push(svc.name);
+    }
+  }
+  return { procs, allHealthy: failed.length === 0, failed };
+}
+async function stopExternals(procs, platform, opts = {}) {
+  for (const { svc, proc, pid } of procs) {
+    try {
+      if (pid) platform.killTree(pid);
+      if (svc.stopCmd) {
+        opts.onLog?.(svc.name, `\u{1F9F9} ${svc.stopCmd}`);
+        await new Promise((resolve3) => {
+          const isWin = process.platform === "win32";
+          const shell = isWin ? "cmd.exe" : "sh";
+          const flag = isWin ? "/c" : "-c";
+          const cwd = svc.cwd ? join4(opts.baseCwd, svc.cwd) : opts.baseCwd;
+          const env = { ...opts.env, ...svc.extraEnv ?? {} };
+          const child = spawn3(shell, [flag, svc.stopCmd], { cwd, env, stdio: "ignore" });
+          child.on("close", () => resolve3());
+          child.on("error", () => resolve3());
+          setTimeout(() => resolve3(), 1e4);
+        });
+      }
+    } catch {
+    }
+    void proc;
+  }
+}
+function spawnExternal(svc, opts) {
+  const isWin = process.platform === "win32";
+  const shell = isWin ? "cmd.exe" : "sh";
+  const flag = isWin ? "/c" : "-c";
+  const cwd = svc.cwd ? join4(opts.baseCwd, svc.cwd) : opts.baseCwd;
+  const env = { ...opts.env, ...svc.extraEnv ?? {} };
+  opts.onLog?.(svc.name, `\u{1F680} ${svc.cmd}`);
+  const child = spawn3(shell, [flag, svc.cmd], {
+    cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.stderr?.on("data", (d) => opts.onLog?.(svc.name, d.toString().trimEnd()));
+  child.on("error", (err) => opts.onLog?.(svc.name, `\u274C spawn error: ${err.message}`));
+  return child;
+}
+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;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
 // src/tui/App.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider, proxyOpts, logSink }) {
@@ -1464,6 +1745,7 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   const pm = useProcessManager(platform, baseCwd, env, logSink);
   const [booted, setBooted] = useState5(false);
   const lazyProxies = useRef3(/* @__PURE__ */ new Map());
+  const externals = useRef3([]);
   const kb = useKeyBindings({
     onQuit: () => {
       void shutdown();
@@ -1475,9 +1757,17 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
   const shutdown = useCallback3(async () => {
     lazyProxies.current.forEach((p) => p.destroy());
     await pm.cleanup();
+    if (externals.current.length) {
+      await stopExternals(externals.current, platform, {
+        baseCwd,
+        env,
+        onLog: (svc, msg) => pm.pushLog(`ext:${svc}`, msg, 12)
+      });
+      externals.current = [];
+    }
     await logSink?.close();
     process.exit(0);
-  }, [pm, logSink]);
+  }, [pm, logSink, platform, baseCwd, env]);
   useEffect5(() => {
     pm.setPaused(kb.logsPaused || kb.logsScrollOffset > 0);
   }, [kb.logsPaused, kb.logsScrollOffset, pm]);
@@ -1489,6 +1779,19 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
     (async () => {
       const lazyMode = cliArgs.lazy;
       const lazyTimeout = cliArgs.lazyTimeout;
+      if (config.external?.length) {
+        const result = await startExternals(config.external, {
+          baseCwd,
+          env,
+          platform,
+          onLog: (svc, msg) => pm.pushLog(`ext:${svc}`, msg, 12)
+        });
+        externals.current = result.procs;
+        if (!result.allHealthy) {
+          pm.pushLog("devup", `\u274C external(s) failed: ${result.failed.join(", ")}. Aborting boot.`, 5);
+          return;
+        }
+      }
       if (lazyMode && config.lazy) {
         const { alwaysOn, lazy } = classifyServices(services, config.lazy);
         const aoPhases = groupByPhase(alwaysOn);
@@ -1637,7 +1940,7 @@ function App({ config, services, cliArgs, platform, env, baseCwd, proxyProvider,
 
 // src/process/log-sink.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync, createWriteStream } from "fs";
-import { join as join4, dirname as dirname4 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { homedir } from "os";
 var LogSink = class {
   dir;
@@ -1645,14 +1948,14 @@ var LogSink = class {
   streams = /* @__PURE__ */ new Map();
   seen = /* @__PURE__ */ new Set();
   constructor(opts) {
-    const root = opts.rootDir ?? join4(homedir(), ".devup", "logs");
-    this.dir = join4(root, sanitize(opts.projectName));
+    const root = opts.rootDir ?? join5(homedir(), ".devup", "logs");
+    this.dir = join5(root, sanitize(opts.projectName));
     this.rotateOnStart = opts.rotateOnStart ?? true;
     mkdirSync4(this.dir, { recursive: true });
   }
   /** Returns the file path for a service log (useful for tests / UI). */
   pathFor(svcName) {
-    return join4(this.dir, `${sanitize(svcName)}.log`);
+    return join5(this.dir, `${sanitize(svcName)}.log`);
   }
   write(svcName, line) {
     const stream = this.streamFor(svcName);
@@ -1696,8 +1999,18 @@ function renderDryRun(opts) {
   const lines = [];
   lines.push(`Project:  ${config.icon ?? "\u{1F4E6}"} ${config.name}`);
   lines.push(`Mode:     ${cliArgs.lazy && config.lazy ? "lazy" : "normal"}`);
+  if (cliArgs.profile) lines.push(`Profile:  ${cliArgs.profile}`);
   lines.push(`Services: ${services.length}`);
   lines.push("");
+  if (config.external?.length) {
+    lines.push(`Externals (${config.external.length}):`);
+    for (const ext of config.external) {
+      const hc = ext.healthCheck;
+      const hcTag = hc ? ` health=${hc.type}${hc.type === "http" ? " " + (hc.path ?? "/") : ""} :${ext.port ?? "?"}` : "";
+      lines.push(`  - ${ext.name.padEnd(20)} ${ext.cmd}${hcTag}`);
+    }
+    lines.push("");
+  }
   const lazyMode = cliArgs.lazy && !!config.lazy;
   let alwaysOn = services;
   let lazy = [];
@@ -1771,6 +2084,26 @@ async function runOnce(opts) {
       }
     }
   });
+  let externals = [];
+  if (config.external?.length) {
+    out(`\u25B6 externals (${config.external.length})`);
+    const result = await startExternals(config.external, {
+      baseCwd,
+      env,
+      platform,
+      onLog: (svc, msg) => {
+        logSink?.write(`ext:${svc}`, msg);
+        out(`[ext:${svc}] ${msg}`);
+      }
+    });
+    externals = result.procs;
+    if (!result.allHealthy) {
+      out(`\u2717 externals failed: ${result.failed.join(", ")}`);
+      await stopExternals(externals, platform, { baseCwd, env });
+      await mgr.cleanup();
+      return 1;
+    }
+  }
   const phases = groupByPhase(services);
   const phaseNums = Object.keys(phases).map(Number).sort((a, b) => a - b);
   const apiNames = services.filter((s) => s.type === "api").map((s) => s.name);
@@ -1784,16 +2117,18 @@ async function runOnce(opts) {
       if (!installed) {
         out(`\u2717 install failed for ${svc.name}`);
         await mgr.cleanup();
+        await stopExternals(externals, platform, { baseCwd, env });
         return 1;
       }
       await mgr.start(svc, ci);
     }
     const apis = phases[num].filter((s) => s.type === "api");
     for (const api of apis) {
-      const ok = await waitHealthy(api, deadline);
+      const ok = await waitHealthy2(api, deadline);
       if (!ok) {
         out(`\u2717 ${api.name} did not become healthy within ${cliArgs.onceTimeout}s`);
         await mgr.cleanup();
+        await stopExternals(externals, platform, { baseCwd, env });
         return 1;
       }
       out(`\u2713 ${api.name} ready`);
@@ -1807,9 +2142,10 @@ async function runOnce(opts) {
   const summary = `ready: ${apiNames.length} APIs in ${((cliArgs.onceTimeout * 1e3 - (deadline - Date.now())) / 1e3).toFixed(1)}s`;
   out(summary);
   await mgr.cleanup();
+  await stopExternals(externals, platform, { baseCwd, env });
   return 0;
 }
-async function waitHealthy(svc, deadline) {
+async function waitHealthy2(svc, deadline) {
   while (Date.now() < deadline) {
     const ok = await checkHealth(svc.port, svc.healthCheck);
     if (ok) return true;
@@ -1841,13 +2177,19 @@ async function main() {
 ${formatValidationErrors(errors)}`);
     process.exit(1);
   }
-  const services = filterServices(config.services, cliArgs);
+  let services;
+  try {
+    services = filterServices(config.services, cliArgs, config);
+  } catch (e) {
+    console.error(`\u274C ${e.message}`);
+    process.exit(1);
+  }
   if (!services.length) {
     console.error("\u274C No services to run after filtering");
     process.exit(1);
   }
   const platform = await detectPlatform();
-  const envFile = config.envFile ? join5(cwd, config.envFile) : join5(cwd, ".env");
+  const envFile = config.envFile ? join6(cwd, config.envFile) : join6(cwd, ".env");
   const env = parseEnvFile(envFile, process.env);
   if (config.env) {
     for (const [k, v] of Object.entries(config.env)) {
@@ -1864,7 +2206,7 @@ ${formatValidationErrors(errors)}`);
       routes: config.proxy.routes,
       tls: cliArgs.proxyTls ?? config.proxy.tls ?? true,
       entrypoint: cliArgs.proxyEntrypoint ?? config.proxy.entrypoint ?? "websecure",
-      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join5(homedir2(), ".traefik", "traefik_conf.yaml")
+      confPath: cliArgs.proxyConf ?? config.proxy.confPath ?? join6(homedir2(), ".traefik", "traefik_conf.yaml")
     };
   }
   if (cliArgs.dryRun) {