@neat.is/core 0.9.11 → 0.9.12

package/dist/{chunk-UNO3X6ZV.js → chunk-WE3AFQYL.js}

@@ -2,10 +2,12 @@ import {
   DEFAULT_PROJECT,
   Projects,
   attachGraphToEventBus,
+  bearerAuthHeader,
   buildApi,
   extractFromDirectory,
   getGraph,
   handleSpan,
+  junctionFetch,
   listProjects,
   loadGraphFromDisk,
   makeErrorSpanWriter,
@@ -13,14 +15,17 @@ import {
   pruneRegistry,
   registryPath,
   resetGraph,
+  resolveCredential,
+  resolveFusedServiceId,
   saveGraphToDisk,
   setStatus,
+  startConnectorPollLoop,
   startConnectorPolling,
   startPersistLoop,
   startStalenessLoop,
   touchLastSeen,
   writeAtomically
-} from "./chunk-3UAUMPIY.js";
+} from "./chunk-RBZNXA5L.js";
 import {
   assertBindAuthority,
   buildOtelReceiver,
@@ -36,12 +41,441 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
-import path2 from "path";
+import path3 from "path";
 import { createRequire } from "module";
 
+// src/connectors/kubernetes/client.ts
+import { Agent, request as httpsRequest } from "https";
+function deploymentsPath(namespace) {
+  return `/apis/apps/v1/namespaces/${namespace}/deployments`;
+}
+function podsPath(namespace) {
+  return `/api/v1/namespaces/${namespace}/pods`;
+}
+function makeK8sFetchImpl(transport) {
+  const agent = new Agent({
+    ...transport.ca ? { ca: transport.ca } : {},
+    ...transport.clientCert ? { cert: transport.clientCert } : {},
+    ...transport.clientKey ? { key: transport.clientKey } : {},
+    rejectUnauthorized: !transport.insecureSkipTlsVerify
+  });
+  return ((url, init) => new Promise((resolve, reject) => {
+    const u = new URL(String(url));
+    const req = httpsRequest(
+      u,
+      {
+        method: (init?.method ?? "GET").toUpperCase(),
+        headers: init?.headers ?? {},
+        agent
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const body = Buffer.concat(chunks).toString("utf8");
+          const status = res.statusCode ?? 0;
+          resolve({
+            ok: status >= 200 && status < 300,
+            status,
+            statusText: res.statusMessage ?? "",
+            json: async () => JSON.parse(body),
+            text: async () => body
+          });
+        });
+      }
+    );
+    req.on("error", reject);
+    const signal = init?.signal;
+    if (signal) {
+      if (signal.aborted) req.destroy(new Error("aborted"));
+      else signal.addEventListener("abort", () => req.destroy(new Error("aborted")), { once: true });
+    }
+    req.end();
+  }));
+}
+async function listResource(transport, namespace, path4, opts = {}) {
+  const base = opts.apiUrl ?? transport.server;
+  const url = `${base.replace(/\/$/, "")}${path4}`;
+  const fetchImpl = opts.fetchImpl ?? makeK8sFetchImpl(transport);
+  const res = await junctionFetch(
+    url,
+    { method: "GET", headers: { ...transport.token ? bearerAuthHeader(transport.token) : {}, Accept: "application/json" } },
+    // accountKey: the (cluster, namespace) pair — an identifier, safe to log, the
+    // rate-limit bucket for one namespace on one cluster (ADR-131).
+    { provider: "kubernetes", accountKey: `${safeHost(transport.server)}/${namespace}`, fetchImpl }
+  );
+  if (!res.ok) {
+    throw new Error(`kubernetes ${path4} failed: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return Array.isArray(json.items) ? json.items : [];
+}
+function safeHost(server) {
+  try {
+    return new URL(server).host;
+  } catch {
+    return "cluster";
+  }
+}
+async function fetchDeployments(transport, namespace, opts = {}) {
+  return listResource(transport, namespace, deploymentsPath(namespace), opts);
+}
+async function fetchPods(transport, namespace, opts = {}) {
+  return listResource(transport, namespace, podsPath(namespace), opts);
+}
+
+// src/connectors/kubernetes/kubeconfig.ts
+import { readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function pemFrom(dataField, pathField) {
+  if (typeof dataField === "string" && dataField.length > 0) {
+    return Buffer.from(dataField, "base64").toString("utf8");
+  }
+  if (typeof pathField === "string" && pathField.length > 0) {
+    return readFileSync(pathField, "utf8");
+  }
+  return void 0;
+}
+function named(list, name) {
+  if (!Array.isArray(list)) return void 0;
+  const hit = list.find((e) => e && e.name === name);
+  return hit;
+}
+function parseKubeconfig(kubeconfig) {
+  const looksInline = /\n/.test(kubeconfig) || /(^|\s)clusters\s*:/.test(kubeconfig);
+  const text = looksInline ? kubeconfig : readFileSync(kubeconfig, "utf8");
+  let doc;
+  try {
+    doc = parseYaml(text);
+  } catch {
+    throw new Error("kubernetes connector: kubeconfig is not valid YAML");
+  }
+  if (!doc || typeof doc !== "object") {
+    throw new Error("kubernetes connector: kubeconfig is empty or malformed");
+  }
+  const currentContext = doc["current-context"];
+  if (typeof currentContext !== "string" || currentContext.length === 0) {
+    throw new Error("kubernetes connector: kubeconfig has no current-context");
+  }
+  const ctxEntry = named(doc["contexts"], currentContext);
+  const ctx = ctxEntry?.context;
+  if (!ctx) {
+    throw new Error(`kubernetes connector: kubeconfig context "${currentContext}" not found`);
+  }
+  const clusterEntry = named(doc["clusters"], String(ctx["cluster"] ?? ""));
+  const cluster = clusterEntry?.cluster;
+  if (!cluster || typeof cluster["server"] !== "string") {
+    throw new Error("kubernetes connector: kubeconfig current context has no cluster server");
+  }
+  const userEntry = named(doc["users"], String(ctx["user"] ?? ""));
+  const user = userEntry?.user ?? {};
+  const transport = {
+    server: cluster["server"],
+    insecureSkipTlsVerify: cluster["insecure-skip-tls-verify"] === true
+  };
+  const ca = pemFrom(cluster["certificate-authority-data"], cluster["certificate-authority"]);
+  if (ca) transport.ca = ca;
+  if (typeof user["token"] === "string" && user["token"].length > 0) transport.token = user["token"];
+  const clientCert = pemFrom(user["client-certificate-data"], user["client-certificate"]);
+  const clientKey = pemFrom(user["client-key-data"], user["client-key"]);
+  if (clientCert) transport.clientCert = clientCert;
+  if (clientKey) transport.clientKey = clientKey;
+  return transport;
+}
+function resolveK8sTransport(creds, config) {
+  if (creds.kubeconfig) return parseKubeconfig(creds.kubeconfig);
+  if (!config.apiServerUrl) {
+    throw new Error("kubernetes connector: options.apiServerUrl is required with a token credential");
+  }
+  const transport = {
+    server: config.apiServerUrl,
+    insecureSkipTlsVerify: config.insecureSkipTlsVerify === true
+  };
+  if (creds.token) transport.token = creds.token;
+  if (config.caCert) transport.ca = config.caCert;
+  return transport;
+}
+
+// src/connectors/kubernetes/types.ts
+function readK8sCredentials(raw) {
+  const token = typeof raw["token"] === "string" && raw["token"].length > 0 ? raw["token"] : void 0;
+  const kubeconfig = typeof raw["kubeconfig"] === "string" && raw["kubeconfig"].length > 0 ? raw["kubeconfig"] : void 0;
+  if (!token && !kubeconfig) {
+    throw new Error("kubernetes connector: credentials must carry a token or a kubeconfig");
+  }
+  const out = {};
+  if (token) out.token = token;
+  if (kubeconfig) out.kubeconfig = kubeconfig;
+  return out;
+}
+var IMAGE_PULL_REASONS = /* @__PURE__ */ new Set(["ImagePullBackOff", "ErrImagePull", "InvalidImageName"]);
+var CRASH_LOOP_REASON = "CrashLoopBackOff";
+var FIELD_SEP = "\0";
+var K8S_TARGET_KIND = "k8s-workload";
+function packK8sTargetName(identity) {
+  return [identity.serviceName, identity.fault].join(FIELD_SEP);
+}
+function parseK8sTargetName(targetName) {
+  const sep = targetName.indexOf(FIELD_SEP);
+  if (sep === -1) return null;
+  const serviceName = targetName.slice(0, sep);
+  const fault = targetName.slice(sep + 1);
+  if (!serviceName || !fault) return null;
+  return { serviceName, fault };
+}
+
+// src/connectors/kubernetes/map.ts
+function serviceNameFor(deployment, config) {
+  const name = deployment.metadata?.name ?? "";
+  return config.serviceMap?.[name] ?? name;
+}
+function podMatchesSelector(pod, selector) {
+  if (!selector || Object.keys(selector).length === 0) return false;
+  const labels = pod.metadata?.labels ?? {};
+  return Object.entries(selector).every(([k, v]) => labels[k] === v);
+}
+function podsForDeployment(deployment, pods) {
+  const selector = deployment.spec?.selector?.matchLabels;
+  return pods.filter((p) => podMatchesSelector(p, selector));
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function podLevelFault(deployment, pods) {
+  const name = deployment.metadata?.name ?? "";
+  const owned = podsForDeployment(deployment, pods);
+  let crash = null;
+  for (const pod of owned) {
+    for (const cs of pod.status?.containerStatuses ?? []) {
+      const reason = cs.state?.waiting?.reason;
+      if (typeof reason !== "string") continue;
+      if (IMAGE_PULL_REASONS.has(reason)) {
+        const image = typeof cs.image === "string" ? cs.image : "unknown image";
+        const attrs = { "k8s.image": image, "k8s.waitingReason": reason };
+        const wm = cs.state?.waiting?.message;
+        if (typeof wm === "string" && wm.length > 0) attrs["k8s.waitingMessage"] = wm;
+        return {
+          fault: "image-pull",
+          message: `Deployment ${name} cannot pull image ${image} (${reason})`,
+          timestamp: pod.status?.startTime ?? nowIso(),
+          attributes: attrs
+        };
+      }
+      if (reason === CRASH_LOOP_REASON && !crash) crash = { cs, pod };
+    }
+  }
+  if (crash) {
+    const { cs, pod } = crash;
+    const term = cs.lastState?.terminated;
+    const termReason = typeof term?.reason === "string" ? term.reason : void 0;
+    const termMsg = typeof term?.message === "string" ? term.message.trim() : void 0;
+    const restarts = typeof cs.restartCount === "number" ? cs.restartCount : 0;
+    const detail = termReason ? `last terminated: ${termReason}${termMsg ? ` \u2014 ${termMsg}` : ""}${typeof term?.exitCode === "number" ? ` (exit ${term.exitCode})` : ""}` : "no last-termination detail reported";
+    const attrs = { "k8s.waitingReason": CRASH_LOOP_REASON, "k8s.restartCount": restarts };
+    if (termReason) attrs["k8s.terminatedReason"] = termReason;
+    if (termMsg) attrs["k8s.terminatedMessage"] = termMsg;
+    if (typeof term?.exitCode === "number") attrs["k8s.exitCode"] = term.exitCode;
+    if (typeof cs.image === "string") attrs["k8s.image"] = cs.image;
+    return {
+      fault: "crash-loop",
+      message: `Deployment ${name} is crashlooping (restarts: ${restarts}); ${detail}`,
+      timestamp: term?.finishedAt ?? pod.status?.startTime ?? nowIso(),
+      attributes: attrs
+    };
+  }
+  return null;
+}
+function classifyDeployment(deployment, pods, expectedZero) {
+  const name = deployment.metadata?.name ?? "";
+  const desired = typeof deployment.spec?.replicas === "number" ? deployment.spec.replicas : 1;
+  const ready = typeof deployment.status?.readyReplicas === "number" ? deployment.status.readyReplicas : 0;
+  if (desired === 0) {
+    if (expectedZero?.has(name)) return null;
+    return {
+      fault: "scaled-to-zero",
+      message: `Deployment ${name} is scaled to 0 \u2014 no running pods (desired 0)`,
+      timestamp: nowIso(),
+      attributes: { "k8s.desiredReplicas": 0, "k8s.readyReplicas": ready }
+    };
+  }
+  if (ready >= desired) return null;
+  const podFault = podLevelFault(deployment, pods);
+  if (podFault) {
+    podFault.attributes["k8s.desiredReplicas"] = desired;
+    podFault.attributes["k8s.readyReplicas"] = ready;
+    return podFault;
+  }
+  return {
+    fault: "no-ready-replicas",
+    message: `Deployment ${name} has no ready replicas (desired ${desired}, ready ${ready})`,
+    timestamp: nowIso(),
+    attributes: { "k8s.desiredReplicas": desired, "k8s.readyReplicas": ready }
+  };
+}
+function mapDeploymentToSignal(deployment, pods, config) {
+  const name = deployment.metadata?.name;
+  if (typeof name !== "string" || name.length === 0) return null;
+  const expectedZero = config.expectedZero ? new Set(config.expectedZero) : void 0;
+  const finding = classifyDeployment(deployment, pods, expectedZero);
+  if (!finding) return null;
+  const serviceName = serviceNameFor(deployment, config);
+  const namespace = deployment.metadata?.namespace ?? config.namespace;
+  const attributes = {
+    "k8s.namespace": namespace,
+    "k8s.deployment": name,
+    "k8s.fault": finding.fault,
+    ...finding.attributes
+  };
+  return {
+    targetKind: K8S_TARGET_KIND,
+    targetName: packK8sTargetName({ serviceName, fault: finding.fault }),
+    // Incident-only — no edge, so no call/error count to replay.
+    callCount: 0,
+    errorCount: 0,
+    lastObservedIso: finding.timestamp,
+    incident: {
+      id: `k8s:deploy:${namespace}:${name}:${finding.fault}`,
+      timestamp: finding.timestamp,
+      service: serviceName,
+      errorType: "k8s-deploy-failure",
+      errorMessage: finding.message,
+      attributes
+    }
+  };
+}
+function mapWorkloadsToSignals(deployments, pods, config) {
+  const out = [];
+  for (const deployment of deployments) {
+    const signal = mapDeploymentToSignal(deployment, pods, config);
+    if (signal) out.push(signal);
+  }
+  return out;
+}
+
+// src/connectors/kubernetes/resolve.ts
+import { EdgeType } from "@neat.is/types";
+var NO_ENV = "unknown";
+function createK8sResolveTarget(graph) {
+  return (signal) => {
+    if (signal.targetKind !== K8S_TARGET_KIND) return null;
+    const identity = parseK8sTargetName(signal.targetName);
+    if (!identity) return null;
+    const { serviceName } = identity;
+    return {
+      targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV),
+      serviceName,
+      edgeType: EdgeType.CALLS
+    };
+  };
+}
+
+// src/connectors/kubernetes/substrate.ts
+import { readFile } from "fs/promises";
+import os from "os";
+import path from "path";
+function defaultHome() {
+  const override = process.env.NEAT_HOME;
+  if (override && override.length > 0) return path.resolve(override);
+  return path.join(os.homedir(), ".neat");
+}
+function k8sSubstrateConfigPath(home = defaultHome()) {
+  return path.join(home, "k8s.json");
+}
+async function readK8sSubstrateConfig(home = defaultHome()) {
+  let raw;
+  try {
+    raw = await readFile(k8sSubstrateConfigPath(home), "utf8");
+  } catch {
+    return { version: 1, deployments: [] };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.deployments)) return { version: 1, deployments: [] };
+    return parsed;
+  } catch {
+    return { version: 1, deployments: [] };
+  }
+}
+async function startK8sSubstratePolling(input) {
+  const config = await readK8sSubstrateConfig(input.home);
+  const env = input.env ?? process.env;
+  const stops = [];
+  for (const entry of config.deployments) {
+    if (entry.project !== void 0 && entry.project !== input.project) continue;
+    if (typeof entry.namespace !== "string" || entry.namespace.length === 0) {
+      input.onSkip?.(entry, "missing namespace");
+      continue;
+    }
+    let credentials;
+    try {
+      const resolved = resolveCredential(entry.credential, env);
+      credentials = resolved.kind === "fields" ? { ...resolved.fields } : { token: resolved.value };
+    } catch (err) {
+      input.onSkip?.(entry, err.message);
+      continue;
+    }
+    const cfg = {
+      namespace: entry.namespace,
+      ...entry.apiServerUrl ? { apiServerUrl: entry.apiServerUrl } : {},
+      ...entry.caCert ? { caCert: entry.caCert } : {},
+      ...entry.insecureSkipTlsVerify ? { insecureSkipTlsVerify: true } : {},
+      ...entry.serviceMap ? { serviceMap: entry.serviceMap } : {},
+      ...entry.expectedZero ? { expectedZero: entry.expectedZero } : {}
+    };
+    const { connector, resolveTarget } = createKubernetesConnector(input.graph, cfg, input.fetchImpl);
+    const stop = startConnectorPollLoop(
+      connector,
+      {
+        projectDir: input.projectDir,
+        project: input.project,
+        credentials,
+        ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
+      },
+      input.graph,
+      resolveTarget,
+      { connectorId: `k8s:${entry.id}`, ...entry.intervalMs ? { intervalMs: entry.intervalMs } : {} }
+    );
+    stops.push(stop);
+  }
+  return () => {
+    for (const stop of stops) stop();
+  };
+}
+
+// src/connectors/kubernetes/index.ts
+var KubernetesConnector = class {
+  constructor(config, fetchImpl) {
+    this.config = config;
+    this.fetchImpl = fetchImpl;
+  }
+  config;
+  fetchImpl;
+  provider = "kubernetes";
+  async poll(ctx) {
+    const creds = readK8sCredentials(ctx.credentials);
+    const transport = resolveK8sTransport(creds, this.config);
+    const namespace = this.config.namespace;
+    const opts = {
+      ...this.config.apiUrl ? { apiUrl: this.config.apiUrl } : {},
+      ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
+    };
+    const [deployments, pods] = await Promise.all([
+      fetchDeployments(transport, namespace, opts),
+      fetchPods(transport, namespace, opts)
+    ]);
+    return mapWorkloadsToSignals(deployments, pods, this.config);
+  }
+};
+function createKubernetesConnector(graph, config, fetchImpl) {
+  return {
+    connector: new KubernetesConnector(config, fetchImpl),
+    resolveTarget: createK8sResolveTarget(graph)
+  };
+}
+
 // src/unrouted.ts
 import { promises as fs } from "fs";
-import path from "path";
+import path2 from "path";
 function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new Date()) {
   return {
     timestamp: now.toISOString(),
@@ -51,34 +485,34 @@ function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new
   };
 }
 async function appendUnroutedSpan(neatHome, record) {
-  const target = path.join(neatHome, "errors.ndjson");
+  const target = path2.join(neatHome, "errors.ndjson");
   await fs.mkdir(neatHome, { recursive: true });
   await fs.appendFile(target, JSON.stringify(record) + "\n", "utf8");
 }
 function unroutedErrorsPath(neatHome) {
-  return path.join(neatHome, "errors.ndjson");
+  return path2.join(neatHome, "errors.ndjson");
 }
 
 // src/daemon.ts
 import { NodeType } from "@neat.is/types";
 function daemonJsonPath(scanPath) {
-  return path2.join(scanPath, "neat-out", "daemon.json");
+  return path3.join(scanPath, "neat-out", "daemon.json");
 }
 function daemonsDiscoveryDir(home) {
   const base = home && home.length > 0 ? home : neatHomeFromEnv();
-  return path2.join(base, "daemons");
+  return path3.join(base, "daemons");
 }
 function daemonDiscoveryPath(project, home) {
-  return path2.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
+  return path3.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
 }
 function sanitizeDiscoveryName(project) {
   return project.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function neatHomeFromEnv() {
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path2.resolve(env);
+  if (env && env.length > 0) return path3.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path2.join(home, ".neat");
+  return path3.join(home, ".neat");
 }
 async function readDaemonRecord(scanPath) {
   try {
@@ -153,17 +587,21 @@ function teardownSlot(slot) {
     slot.stopConnectors();
   } catch {
   }
+  try {
+    slot.stopK8sSubstrate();
+  } catch {
+  }
   try {
     slot.detachEvents();
   } catch {
   }
 }
 function neatHomeFor(opts) {
-  if (opts.neatHome && opts.neatHome.length > 0) return path2.resolve(opts.neatHome);
+  if (opts.neatHome && opts.neatHome.length > 0) return path3.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path2.resolve(env);
+  if (env && env.length > 0) return path3.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path2.join(home, ".neat");
+  return path3.join(home, ".neat");
 }
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
@@ -215,7 +653,7 @@ function spanBelongsToSingleProject(graph, project, serviceName) {
   );
 }
 async function bootstrapProject(entry, connectors = [], neatHome) {
-  const paths = pathsForProject(entry.name, path2.join(entry.path, "neat-out"));
+  const paths = pathsForProject(entry.name, path3.join(entry.path, "neat-out"));
   try {
     const stat = await fs2.stat(entry.path);
     if (!stat.isDirectory()) {
@@ -237,6 +675,8 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
       },
       stopConnectors: () => {
       },
+      stopK8sSubstrate: () => {
+      },
       detachEvents: () => {
       },
       status: "broken",
@@ -269,6 +709,14 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
         `neatd: connector "${skipped.id}" (${skipped.provider}) skipped for project "${entry.name}" \u2014 ${reason}`
       )
     });
+    const stopK8sSubstrate = await startK8sSubstratePolling({
+      project: entry.name,
+      graph,
+      projectDir: entry.path,
+      errorsPath: paths.errorsPath,
+      ...neatHome ? { home: neatHome } : {},
+      onSkip: (skipped, reason) => console.warn(`neatd: k8s substrate "${skipped.id}" skipped for project "${entry.name}" \u2014 ${reason}`)
+    });
     await touchLastSeen(entry.name).catch(() => {
     });
     return {
@@ -279,6 +727,7 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
       stopPersist,
       stopStaleness,
       stopConnectors,
+      stopK8sSubstrate,
       detachEvents,
       status: "active"
     };
@@ -335,7 +784,7 @@ async function startDaemon(opts = {}) {
   const projectArg = typeof opts.project === "string" && opts.project.length > 0 ? opts.project : process.env.NEAT_PROJECT && process.env.NEAT_PROJECT.length > 0 ? process.env.NEAT_PROJECT : null;
   const projectPathArg = opts.projectPath && opts.projectPath.length > 0 ? opts.projectPath : process.env.NEAT_PROJECT_PATH && process.env.NEAT_PROJECT_PATH.length > 0 ? process.env.NEAT_PROJECT_PATH : null;
   const singleProject = projectArg;
-  const singleProjectPath = singleProject && projectPathArg ? path2.resolve(projectPathArg) : null;
+  const singleProjectPath = singleProject && projectPathArg ? path3.resolve(projectPathArg) : null;
   if (singleProject && !singleProjectPath) {
     throw new Error(
       `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
@@ -350,7 +799,7 @@ async function startDaemon(opts = {}) {
       );
     }
   }
-  const pidPath = path2.join(home, "neatd.pid");
+  const pidPath = path3.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();
@@ -822,8 +1271,8 @@ async function startDaemon(opts = {}) {
   let registryWatcher = null;
   let reloadTimer = null;
   if (!singleProject) try {
-    const regDir = path2.dirname(regPath);
-    const regBase = path2.basename(regPath);
+    const regDir = path3.dirname(regPath);
+    const regBase = path3.basename(regPath);
     registryWatcher = watch(regDir, (_eventType, filename) => {
       if (filename !== null && filename !== regBase) return;
       if (reloadTimer) clearTimeout(reloadTimer);
@@ -901,4 +1350,4 @@ export {
   resolveHost,
   startDaemon
 };
-//# sourceMappingURL=chunk-UNO3X6ZV.js.map
+//# sourceMappingURL=chunk-WE3AFQYL.js.map