token-goat 2.9.30 → 2.9.31

package/dist/token-goat-chunk-F6PAUIEK.mjs

@@ -0,0 +1,624 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  windowsPowerShellPath,
+  windowsSystem32Exe
+} from "./token-goat-chunk-65N4RHP4.mjs";
+import {
+  powerShellCommandArgs
+} from "./token-goat-chunk-X2SUP3EI.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync,
+  extractErrorMessage,
+  withFileLock
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/worker_lifecycle.ts
+init_define_import_meta_env();
+import { spawn } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as os2 from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/env_proxy.ts
+init_define_import_meta_env();
+var PROXY_VARS = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
+function proxyConfigured(env = process.env) {
+  return PROXY_VARS.some((k) => (env[k] ?? "").trim() !== "");
+}
+function nodeFetchHonoursEnvProxy(version = process.versions.node) {
+  const [major = 0, minor = 0] = version.split(".").map((n) => Number.parseInt(n, 10));
+  if (major >= 24) return true;
+  return major === 22 && minor >= 21;
+}
+function fetchBypassesProxy(env = process.env, nodeVersion = process.versions.node) {
+  return env["NODE_USE_ENV_PROXY"] === void 0 && proxyConfigured(env) && nodeFetchHonoursEnvProxy(nodeVersion);
+}
+function rerunWithEnvProxy(spawn2, argv = process.argv, env = process.env, nodeVersion = process.versions.node) {
+  if (!fetchBypassesProxy(env, nodeVersion)) return null;
+  const result = spawn2(process.execPath, [...process.execArgv, ...argv.slice(1)], { env: withEnvProxyEnabled(env, nodeVersion), stdio: "inherit" });
+  return result.status ?? 1;
+}
+function withEnvProxyEnabled(env, nodeVersion = process.versions.node) {
+  if (env["NODE_USE_ENV_PROXY"] !== void 0 || !proxyConfigured(env) || !nodeFetchHonoursEnvProxy(nodeVersion)) return env;
+  return { ...env, NODE_USE_ENV_PROXY: "1" };
+}
+
+// src/process_priority.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as os from "node:os";
+var PRIORITY_BY_NAME = {
+  normal: os.constants.priority.PRIORITY_NORMAL,
+  below_normal: os.constants.priority.PRIORITY_BELOW_NORMAL,
+  low: os.constants.priority.PRIORITY_LOW
+};
+var DEFAULT_PRIORITY_NAME = "below_normal";
+function resolveWorkerPriority(name) {
+  const wanted = PRIORITY_BY_NAME[name ?? ""];
+  return wanted ?? PRIORITY_BY_NAME[DEFAULT_PRIORITY_NAME];
+}
+function applyIndexingPriority() {
+  return applyIndexingPriorityTo(0);
+}
+function applyIndexingPriorityTo(pid) {
+  try {
+    const priority = resolveWorkerPriority(loadConfig().worker.priority);
+    os.setPriority(pid, priority);
+    lowerOtherThreads(pid, priority);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function lowerOtherThreads(pid, priority) {
+  if (process.platform !== "linux") return;
+  let threads;
+  try {
+    threads = fs.readdirSync(`/proc/${pid === 0 ? "self" : String(pid)}/task`);
+  } catch {
+    return;
+  }
+  for (const thread of threads) {
+    try {
+      os.setPriority(Number(thread), priority);
+    } catch {
+    }
+  }
+}
+
+// src/resident_process.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import * as fs2 from "node:fs";
+var PROCESS_QUERY_TIMEOUT_MS = 15e3;
+function residentKindOf(cmd) {
+  if (/--worker-daemon(?![\w-])/.test(cmd)) return "worker";
+  if (/\bhook-server\s+run(?![\w-])/.test(cmd)) return "hook-server";
+  return null;
+}
+function isTokenGoatResidentProcess(cmd) {
+  return residentKindOf(cmd) !== null;
+}
+function foldForMatch(text) {
+  const slashed = text.replace(/\\/g, "/");
+  return process.platform === "win32" ? slashed.toLowerCase() : slashed;
+}
+var NODE_EXECUTABLE = /^(?:node|nodejs)(?:\.exe)?$/i;
+function afterNodeExecutable(cmd) {
+  const text = cmd.trimStart();
+  let exe;
+  let rest;
+  const quote = text[0];
+  if (quote === '"' || quote === "'") {
+    const close = text.indexOf(quote, 1);
+    if (close < 0) return null;
+    exe = text.slice(1, close);
+    rest = text.slice(close + 1);
+  } else if (foldForMatch(text).startsWith(foldForMatch(process.execPath)) && /^\s/.test(text.slice(process.execPath.length))) {
+    exe = process.execPath;
+    rest = text.slice(process.execPath.length);
+  } else {
+    const token = /^\S+/.exec(text);
+    if (token === null) return null;
+    exe = token[0];
+    rest = text.slice(exe.length);
+  }
+  if (rest !== "" && !/^\s/.test(rest)) return null;
+  return NODE_EXECUTABLE.test(exe.split(/[\\/]/).pop() ?? "") ? rest : null;
+}
+function isResidentOfInstall(cmd, entryScript, kinds) {
+  const rest = afterNodeExecutable(cmd);
+  if (rest === null) return false;
+  const args = foldForMatch(rest.trimStart());
+  const script = foldForMatch(entryScript);
+  const quote = args[0] === '"' || args[0] === "'" ? args[0] : "";
+  if (!args.startsWith(script, quote.length)) return false;
+  let tail = args.slice(quote.length + script.length);
+  if (quote !== "") {
+    if (tail[0] !== quote) return false;
+    tail = tail.slice(1);
+  }
+  if (!/^\s/.test(tail)) return false;
+  const kind = /^\s+(?:(--worker-daemon)|(hook-server\s+run))(?=\s|$)/.exec(tail);
+  if (kind === null) return false;
+  return kinds.includes(kind[1] === void 0 ? "hook-server" : "worker");
+}
+function readProcessCommandLine(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  const win = process.platform === "win32";
+  const file = win ? windowsPowerShellPath() : "ps";
+  const args = win ? powerShellCommandArgs(`(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine`) : ["-ww", "-o", "args=", "-p", String(pid)];
+  const res = spawnSync(file, args, { encoding: "utf8", windowsHide: true, timeout: PROCESS_QUERY_TIMEOUT_MS });
+  if (res.error !== void 0 || res.status !== 0) return null;
+  const line = res.stdout.trim();
+  return line === "" ? null : line;
+}
+var HAS_PROCFS = process.platform === "linux";
+function statIsZombie(stat) {
+  const close = stat.lastIndexOf(")");
+  return close >= 0 && stat.slice(close + 2, close + 3) === "Z";
+}
+function zombiesInPsRows(stdout) {
+  return stdout.split("\n").flatMap((line) => {
+    const row = /^\s*(\d+)\s+(\S+)/.exec(line);
+    return row !== null && row[2]?.startsWith("Z") === true ? [Number(row[1])] : [];
+  });
+}
+function zombiePids(pids, cheapOnly) {
+  if (process.platform === "win32" || pids.length === 0) return [];
+  if (HAS_PROCFS) {
+    return pids.filter((pid) => {
+      try {
+        return statIsZombie(fs2.readFileSync(`/proc/${pid}/stat`, "utf8"));
+      } catch {
+        return false;
+      }
+    });
+  }
+  if (cheapOnly) return [];
+  const res = spawnSync("ps", ["-o", "pid=,stat=", "-p", pids.join(",")], { encoding: "utf8", timeout: PROCESS_QUERY_TIMEOUT_MS });
+  return res.error !== void 0 || typeof res.stdout !== "string" ? [] : zombiesInPsRows(res.stdout);
+}
+function terminateProcessTree(pid, force) {
+  if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid || pid === process.ppid) return false;
+  if (process.platform === "win32") {
+    const res = spawnSync(windowsSystem32Exe("taskkill.exe"), ["/T", "/F", "/PID", String(pid)], { windowsHide: true, timeout: PROCESS_QUERY_TIMEOUT_MS });
+    return res.error === void 0 && res.status === 0;
+  }
+  const signal = force ? "SIGKILL" : "SIGTERM";
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch {
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/worker_lifecycle.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+function resolvePollIntervalMs(explicit) {
+  if (explicit !== void 0) return explicit;
+  const parsed = parseInt(process.env["TG_WORKER_POLL_MS"] ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_POLL_INTERVAL_MS;
+}
+var WORKER_HEARTBEAT_STALE_MS = 6e4;
+var WORKER_HEARTBEAT_REFRESH_MS = 5e3;
+var WORKER_STARTUP_GRACE_MS = 1e4;
+var heartbeatWriteTimes = /* @__PURE__ */ new Map();
+function drainHeartbeatPathFor(dir) {
+  return path.join(dir, "queue", "drain-heartbeat");
+}
+function writeDrainHeartbeat(dir, force = false) {
+  const now = Date.now();
+  if (!force && now - (heartbeatWriteTimes.get(dir) ?? 0) < WORKER_HEARTBEAT_REFRESH_MS) return;
+  try {
+    atomicWriteText(drainHeartbeatPathFor(dir), `${process.pid}
+`);
+    heartbeatWriteTimes.set(dir, now);
+  } catch {
+  }
+}
+function hasFreshWorkerHeartbeat(dir, pid) {
+  try {
+    const heartbeatPath = drainHeartbeatPathFor(dir);
+    if (Date.now() - fs3.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
+    return fs3.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
+  } catch {
+    return false;
+  }
+}
+function pidFileIsWithinStartupGrace(dir) {
+  try {
+    return Date.now() - fs3.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+function workerPidPath(dir = dataDir()) {
+  return path.join(dir, "worker.pid");
+}
+function workerStampPath(dir = dataDir()) {
+  return path.join(dir, "worker.stamp");
+}
+function workerErrorLogPath(dir) {
+  return path.join(dir, "worker-errors.log");
+}
+function oneLogLine(line) {
+  return displaySafeText(line.replace(/[\n\r]+$/, "")) + "\n";
+}
+function appendWorkerErrorLog(dir, line) {
+  try {
+    fs3.appendFileSync(workerErrorLogPath(dir), oneLogLine(line));
+  } catch {
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readPidFile(dir) {
+  try {
+    const raw = fs3.readFileSync(workerPidPath(dir), "utf8").trim();
+    if (!/^\d+$/.test(raw)) return null;
+    return parseInt(raw, 10);
+  } catch {
+    return null;
+  }
+}
+function isWorkerRunning(dir = dataDir()) {
+  const pid = readPidFile(dir);
+  if (pid === null) return false;
+  return pidAlive(pid) && hasFreshWorkerHeartbeat(dir, pid);
+}
+function workerHealthCheckMarkerPath(dir) {
+  return path.join(dir, "worker-healthcheck.marker");
+}
+var WORKER_HEALTHCHECK_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+var startupWakeRequested = false;
+function ensureWorkerAlive(dir = dataDir()) {
+  if (process.env["TOKEN_GOAT_NO_WORKER_SPAWN"] === "1") return;
+  const markerPath = workerHealthCheckMarkerPath(dir);
+  try {
+    const stat = fs3.statSync(markerPath);
+    if (Date.now() - stat.mtimeMs < WORKER_HEALTHCHECK_MIN_INTERVAL_MS) return;
+  } catch {
+  }
+  try {
+    ensureDirSync(dir);
+    fs3.writeFileSync(markerPath, "");
+  } catch {
+  }
+  const livePid = readPidFile(dir);
+  if (livePid !== null && pidAlive(livePid) && hasFreshWorkerHeartbeat(dir, livePid)) {
+    if (workerBundleMatches(dir)) return;
+    stopWorker(dir, livePid);
+    const nowPid = readPidFile(dir);
+    if (nowPid !== null && nowPid !== livePid) return;
+  }
+  if (process.env["TG_SESSION_START_DEFER_WORKER"] === "1") {
+    if (!startupWakeRequested) {
+      startupWakeRequested = true;
+      process.stderr.write("TG_WORKER_WAKE_V1\n");
+    }
+    return;
+  }
+  try {
+    startDetachedWorker({ dataDir: dir });
+  } catch (e) {
+    if (e instanceof WorkerAlreadyRunningError) return;
+    try {
+      appendWorkerErrorLog(
+        dir,
+        `${(/* @__PURE__ */ new Date()).toISOString()} ensureWorkerAlive: auto-restart failed: ${extractErrorMessage(e)}
+`
+      );
+    } catch {
+    }
+  }
+}
+function stopWorker(dir = dataDir(), expectedPid) {
+  const pid = readPidFile(dir);
+  if (pid === null) return false;
+  if (expectedPid !== void 0 && pid !== expectedPid) return false;
+  const alive = pidAlive(pid);
+  const running = alive && (hasFreshWorkerHeartbeat(dir, pid) || pidFileIsWithinStartupGrace(dir));
+  if (alive && !running) return false;
+  if (running) {
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  }
+  if (readPidFile(dir) === pid) {
+    try {
+      fs3.rmSync(workerPidPath(dir), { force: true });
+    } catch {
+    }
+  }
+  return running;
+}
+var WorkerAlreadyRunningError = class extends Error {
+  constructor(message = "worker already running") {
+    super(message);
+    this.name = "WorkerAlreadyRunningError";
+  }
+};
+var WorkerDataDirUnwritableError = class extends Error {
+  constructor(dir, cause) {
+    super(`the data directory ${displaySafeText(dir)} cannot be written (${extractErrorMessage(cause)}), and the worker keeps its pid file, queue and index there; make it writable and run \`token-goat worker start\` again`, { cause });
+    this.name = "WorkerDataDirUnwritableError";
+  }
+};
+function dataDirWriteRefusal(dir) {
+  const probe = path.join(dir, `.write-probe-${process.pid}`);
+  try {
+    fs3.writeFileSync(probe, "");
+  } catch (e) {
+    return e;
+  }
+  try {
+    fs3.rmSync(probe, { force: true });
+  } catch {
+  }
+  return void 0;
+}
+function discardSpawnedWorker(child, pid) {
+  try {
+    process.kill(pid);
+  } catch {
+  }
+  child.unref();
+}
+function claimWorkerPidFile(dir, pid) {
+  const pidPath = workerPidPath(dir);
+  try {
+    fs3.writeFileSync(pidPath, `${pid}
+`, { flag: "wx" });
+    removeDisplacedNote(dir);
+    return true;
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+  }
+  return withFileLock(`${pidPath}.reclaim`, () => reclaimStalePidFile(dir, pid), { waitMs: 0 }) ?? false;
+}
+function claimCurrentWorker(dir) {
+  if (process.env["TOKEN_GOAT_NO_WORKER_SPAWN"] === "1") return false;
+  ensureDirSync(dir);
+  if (!claimWorkerPidFile(dir, process.pid)) return false;
+  try {
+    fs3.writeFileSync(workerStampPath(dir), currentDaemonStamp());
+  } catch {
+  }
+  return true;
+}
+function displacedWorkerPath(dir) {
+  return `${workerPidPath(dir)}.displaced`;
+}
+function sameDataDir(a, b) {
+  const resolve2 = (d) => process.platform === "win32" ? path.resolve(d).toLowerCase() : path.resolve(d);
+  return resolve2(a) === resolve2(b);
+}
+function readDisplacedPids(dir, nowMs = Date.now(), maxAgeMs = WORKER_STARTUP_GRACE_MS) {
+  let text;
+  try {
+    text = fs3.readFileSync(displacedWorkerPath(dir), "utf8");
+  } catch {
+    return [];
+  }
+  const pids = [];
+  for (const line of text.split("\n")) {
+    const m = /^(\d+) (\d+) (.+?)\r?$/.exec(line);
+    if (m === null) continue;
+    const pid = Number(m[1]);
+    const age = nowMs - Number(m[2]);
+    if (pid > 0 && age >= 0 && age < maxAgeMs && sameDataDir(m[3], dir) && !pids.includes(pid)) pids.push(pid);
+  }
+  return pids;
+}
+function removeDisplacedNote(dir) {
+  try {
+    fs3.rmSync(displacedWorkerPath(dir), { force: true });
+  } catch {
+  }
+}
+function retireDisplacedWorker(dir, opts = {}) {
+  const holders = readDisplacedPids(dir);
+  try {
+    fs3.rmSync(displacedWorkerPath(dir), { force: true });
+  } catch {
+    return;
+  }
+  const entry = daemonEntryScript();
+  const readCommandLine = opts.readCommandLine ?? readProcessCommandLine;
+  const deadline = Date.now() + (opts.deadlineMs ?? PROCESS_QUERY_TIMEOUT_MS);
+  for (const holder of holders) {
+    if (Date.now() >= deadline) break;
+    if (holder === process.pid || !pidAlive(holder) || hasFreshWorkerHeartbeat(dir, holder)) continue;
+    const cmd = readCommandLine(holder);
+    if (cmd === null || !isResidentOfInstall(cmd, entry, ["worker"])) continue;
+    const latest = readCommandLine(holder);
+    if (latest !== null && isResidentOfInstall(latest, entry, ["worker"])) terminateProcessTree(holder, false);
+  }
+}
+function reclaimStalePidFile(dir, pid) {
+  const pidPath = workerPidPath(dir);
+  const existingPid = readPidFile(dir);
+  if (existingPid !== null && pidAlive(existingPid) && (hasFreshWorkerHeartbeat(dir, existingPid) || pidFileIsWithinStartupGrace(dir))) {
+    return false;
+  }
+  try {
+    const held = readDisplacedPids(dir).filter((p) => p !== pid && pidAlive(p));
+    if (existingPid !== null && existingPid !== pid && pidAlive(existingPid) && !held.includes(existingPid)) held.push(existingPid);
+    const stamp = Date.now();
+    if (held.length === 0) fs3.rmSync(displacedWorkerPath(dir), { force: true });
+    else fs3.writeFileSync(displacedWorkerPath(dir), held.map((p) => `${p} ${stamp} ${dir}
+`).join(""));
+  } catch {
+  }
+  try {
+    fs3.rmSync(pidPath, { force: true });
+  } catch {
+  }
+  try {
+    fs3.writeFileSync(pidPath, `${pid}
+`, { flag: "wx" });
+    return true;
+  } catch (e2) {
+    removeDisplacedNote(dir);
+    if (e2.code === "EEXIST") return false;
+    throw e2;
+  }
+}
+function daemonEntryScript() {
+  const self = fileURLToPath(import.meta.url);
+  const launcher = path.join(path.dirname(self), "token-goat.mjs");
+  try {
+    if (fs3.existsSync(launcher)) return launcher;
+  } catch {
+  }
+  return self;
+}
+function currentDaemonStamp() {
+  const entry = daemonEntryScript();
+  try {
+    const st = fs3.statSync(entry);
+    return `${entry}|${st.size}|${Math.trunc(st.mtimeMs)}`;
+  } catch {
+    return entry;
+  }
+}
+function workerBundleMatches(dir) {
+  let raw;
+  try {
+    raw = fs3.readFileSync(workerStampPath(dir), "utf8").trim();
+  } catch {
+    return false;
+  }
+  const parts = raw.split("|");
+  if (parts.length !== 3) return false;
+  const [entry, sizeStr, mtimeStr] = parts;
+  if (entry !== daemonEntryScript()) return true;
+  const size = Number(sizeStr);
+  const mtimeMs = Number(mtimeStr);
+  if (!Number.isFinite(size) || !Number.isFinite(mtimeMs)) return false;
+  try {
+    const st = fs3.statSync(entry);
+    return st.size === size && Math.trunc(st.mtimeMs) === mtimeMs;
+  } catch {
+    return false;
+  }
+}
+function startDetachedWorker(opts) {
+  const pollIntervalMs = resolvePollIntervalMs(opts?.pollIntervalMs);
+  const dir = path.resolve(opts?.dataDir ?? dataDir());
+  try {
+    ensureDirSync(dir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs3.existsSync(dir)) throw e;
+  }
+  const refusal = dataDirWriteRefusal(dir);
+  if (refusal !== void 0) throw new WorkerDataDirUnwritableError(dir, refusal);
+  const cwd = fs3.existsSync(os2.tmpdir()) ? os2.tmpdir() : dir;
+  const child = spawn(
+    process.execPath,
+    [daemonEntryScript(), "--worker-daemon"],
+    {
+      cwd,
+      // owner: none, the daemon outlives its launcher on purpose; dies when its pid file or data directory is gone, when it sits idle, or on `worker stop` (runWorkerLoop, runDetachedWorkerDaemon).
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: {
+        ...withEnvProxyEnabled(process.env),
+        TG_WORKER_POLL_MS: String(pollIntervalMs),
+        TG_WORKER_DATA_DIR: dir
+      }
+    }
+  );
+  child.on("error", () => void 0);
+  const pid = child.pid;
+  if (pid === void 0) {
+    throw new Error("startDetachedWorker: spawn produced no pid");
+  }
+  applyIndexingPriorityTo(pid);
+  let claimed;
+  try {
+    claimed = claimWorkerPidFile(dir, pid);
+  } catch (e) {
+    discardSpawnedWorker(child, pid);
+    throw e;
+  }
+  if (!claimed) {
+    discardSpawnedWorker(child, pid);
+    throw new WorkerAlreadyRunningError();
+  }
+  try {
+    fs3.writeFileSync(workerStampPath(dir), currentDaemonStamp());
+  } catch {
+  }
+  child.unref();
+  return pid;
+}
+
+export {
+  proxyConfigured,
+  nodeFetchHonoursEnvProxy,
+  fetchBypassesProxy,
+  rerunWithEnvProxy,
+  applyIndexingPriority,
+  PROCESS_QUERY_TIMEOUT_MS,
+  isTokenGoatResidentProcess,
+  isResidentOfInstall,
+  readProcessCommandLine,
+  zombiePids,
+  terminateProcessTree,
+  resolvePollIntervalMs,
+  WORKER_STARTUP_GRACE_MS,
+  drainHeartbeatPathFor,
+  writeDrainHeartbeat,
+  workerPidPath,
+  workerStampPath,
+  workerErrorLogPath,
+  oneLogLine,
+  appendWorkerErrorLog,
+  pidAlive,
+  readPidFile,
+  isWorkerRunning,
+  ensureWorkerAlive,
+  stopWorker,
+  WorkerAlreadyRunningError,
+  WorkerDataDirUnwritableError,
+  dataDirWriteRefusal,
+  claimWorkerPidFile,
+  claimCurrentWorker,
+  displacedWorkerPath,
+  readDisplacedPids,
+  retireDisplacedWorker,
+  daemonEntryScript,
+  currentDaemonStamp,
+  startDetachedWorker
+};