@neat.is/core 0.4.17 → 0.4.18

package/dist/index.cjs

@@ -473,8 +473,10 @@ async function buildOtelReceiver(opts) {
     for (const s of spans) projectQueue.push({ project, span: s });
     projectDrainPromise = projectDrainPromise.then(() => drainProject());
   };
+  const offersProjectRouting = opts.onProjectSpan !== void 0;
   const legacyEndpointWarned = /* @__PURE__ */ new Set();
   function warnLegacyEndpoint(serviceName) {
+    if (!offersProjectRouting) return;
     if (legacyEndpointWarned.has(serviceName)) return;
     legacyEndpointWarned.add(serviceName);
     console.warn(
@@ -7029,6 +7031,7 @@ init_otel_grpc();
 init_cjs_shims();
 var import_node_fs25 = require("fs");
 var import_node_path42 = __toESM(require("path"), 1);
+var import_node_module = require("module");
 init_otel();
 init_auth();
 
@@ -7054,6 +7057,59 @@ function unroutedErrorsPath(neatHome2) {
 }
 
 // src/daemon.ts
+function daemonJsonPath(scanPath) {
+  return import_node_path42.default.join(scanPath, "neat-out", "daemon.json");
+}
+function daemonsDiscoveryDir(home) {
+  const base = home && home.length > 0 ? home : neatHomeFromEnv();
+  return import_node_path42.default.join(base, "daemons");
+}
+function daemonDiscoveryPath(project, home) {
+  return import_node_path42.default.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 import_node_path42.default.resolve(env);
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return import_node_path42.default.join(home, ".neat");
+}
+function resolveNeatVersion() {
+  if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
+    return process.env.NEAT_LOCAL_VERSION;
+  }
+  try {
+    const req = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req("../package.json");
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function writeDaemonRecord(record, home) {
+  const body = JSON.stringify(record, null, 2) + "\n";
+  await writeAtomically(daemonJsonPath(record.projectPath), body);
+  try {
+    await writeAtomically(daemonDiscoveryPath(record.project, home), body);
+  } catch (err) {
+    console.warn(
+      `neatd: could not write discovery copy for "${record.project}" \u2014 ${err.message}`
+    );
+  }
+}
+async function clearDaemonRecord(record, home) {
+  try {
+    const stopped = { ...record, status: "stopped" };
+    await writeAtomically(daemonJsonPath(record.projectPath), JSON.stringify(stopped, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    await import_node_fs25.promises.unlink(daemonDiscoveryPath(record.project, home));
+  } catch {
+  }
+}
 function teardownSlot(slot) {
   try {
     slot.stopPersist();
@@ -7170,6 +7226,23 @@ function resolveOtlpPort(opts) {
   }
   return 4318;
 }
+function resolveWebPort() {
+  const env = process.env.NEAT_WEB_PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 6328;
+}
+function portFromListenAddress(address, fallback) {
+  try {
+    const port = new URL(address).port;
+    const n = Number.parseInt(port, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  } catch {
+  }
+  return fallback;
+}
 function resolveHost(opts, authTokenSet) {
   if (opts.host && opts.host.length > 0) return opts.host;
   const env = process.env.HOST;
@@ -7180,13 +7253,24 @@ function resolveHost(opts, authTokenSet) {
 async function startDaemon(opts = {}) {
   const home = neatHomeFor(opts);
   const regPath = registryPath();
-  try {
-    await import_node_fs25.promises.access(regPath);
-  } catch {
+  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 ? import_node_path42.default.resolve(projectPathArg) : null;
+  if (singleProject && !singleProjectPath) {
     throw new Error(
-      `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
+      `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
     );
   }
+  if (!singleProject) {
+    try {
+      await import_node_fs25.promises.access(regPath);
+    } catch {
+      throw new Error(
+        `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
+      );
+    }
+  }
   const pidPath = import_node_path42.default.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
@@ -7275,21 +7359,37 @@ async function startDaemon(opts = {}) {
       });
     }
   }
+  async function enumerateProjects() {
+    if (singleProject && singleProjectPath) {
+      return [
+        {
+          name: singleProject,
+          path: singleProjectPath,
+          registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          languages: [],
+          status: "active"
+        }
+      ];
+    }
+    return listProjects();
+  }
   async function loadAll() {
-    try {
-      const pruned = await pruneRegistry();
-      for (const entry of pruned) {
-        console.log(
-          `neatd: pruned project "${entry.name}" \u2014 registered path ${entry.path} is gone`
-        );
-        slots.delete(entry.name);
-        bootstrapStatus.delete(entry.name);
-        bootstrapStartedAt.delete(entry.name);
+    if (!singleProject) {
+      try {
+        const pruned = await pruneRegistry();
+        for (const entry of pruned) {
+          console.log(
+            `neatd: pruned project "${entry.name}" \u2014 registered path ${entry.path} is gone`
+          );
+          slots.delete(entry.name);
+          bootstrapStatus.delete(entry.name);
+          bootstrapStartedAt.delete(entry.name);
+        }
+      } catch (err) {
+        console.warn(`neatd: registry prune skipped \u2014 ${err.message}`);
       }
-    } catch (err) {
-      console.warn(`neatd: registry prune skipped \u2014 ${err.message}`);
     }
-    const projects = await listProjects();
+    const projects = await enumerateProjects();
     const seen = /* @__PURE__ */ new Set();
     const pending = [];
     for (const entry of projects) {
@@ -7314,7 +7414,7 @@ async function startDaemon(opts = {}) {
     }
     await Promise.allSettled(pending);
   }
-  const initialEntries = await listProjects().catch(() => []);
+  const initialEntries = await enumerateProjects().catch(() => []);
   for (const entry of initialEntries) {
     bootstrapStatus.set(entry.name, "bootstrapping");
     bootstrapStartedAt.set(entry.name, Date.now());
@@ -7324,6 +7424,7 @@ async function startDaemon(opts = {}) {
   let otlpApp = null;
   let restAddress = "";
   let otlpAddress = "";
+  let daemonRecord = null;
   if (bind) {
     const auth = readAuthEnv();
     const host = resolveHost(opts, Boolean(auth.authToken));
@@ -7348,6 +7449,20 @@ async function startDaemon(opts = {}) {
           }
         }
       });
+      if (singleProject) {
+        restApp.addHook("onSend", async (req, _reply, payload) => {
+          if (req.url.split("?")[0] !== "/health") return payload;
+          if (typeof payload !== "string") return payload;
+          try {
+            const body = JSON.parse(payload);
+            if (typeof body !== "object" || body === null) return payload;
+            body.project = singleProject;
+            return JSON.stringify(body);
+          } catch {
+            return payload;
+          }
+        });
+      }
       restAddress = await restApp.listen({ port: restPort, host });
       console.log(`neatd: REST listening on ${restAddress}`);
     } catch (err) {
@@ -7363,6 +7478,25 @@ async function startDaemon(opts = {}) {
       );
     }
     async function resolveTargetSlot(serviceName, traceId) {
+      if (singleProject) {
+        let slot2 = slots.get(singleProject);
+        if (!slot2) {
+          slot2 = await tryRecoverSlot({
+            name: singleProject,
+            path: singleProjectPath,
+            registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            languages: [],
+            status: "active"
+          });
+        } else if (slot2.status === "broken") {
+          slot2 = await tryRecoverSlot(slot2.entry);
+        }
+        if (!slot2 || slot2.status !== "active") {
+          warnDroppedSpan(singleProject, slot2?.errorReason ?? "unknown");
+          return null;
+        }
+        return slot2;
+      }
       const liveEntries = await listProjects().catch(() => []);
       const target = routeSpanToProject(serviceName, liveEntries);
       let slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
@@ -7465,6 +7599,42 @@ async function startDaemon(opts = {}) {
         `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
       );
     }
+    if (singleProject && singleProjectPath) {
+      const ports = {
+        rest: portFromListenAddress(restAddress, restPort),
+        otlp: portFromListenAddress(otlpAddress, otlpPort),
+        // The daemon doesn't bind the web port itself (neatd spawns the web
+        // child); it records the allocated value passed through so the
+        // dashboard and `neat ps` agree on where to look.
+        web: typeof opts.webPort === "number" ? opts.webPort : resolveWebPort()
+      };
+      daemonRecord = {
+        project: singleProject,
+        projectPath: singleProjectPath,
+        pid: process.pid,
+        status: "running",
+        ports,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        neatVersion: resolveNeatVersion()
+      };
+      try {
+        await writeDaemonRecord(daemonRecord, home);
+        console.log(
+          `neatd: project "${singleProject}" \u2192 REST ${ports.rest} / OTLP ${ports.otlp} / web ${ports.web} (daemon.json written)`
+        );
+      } catch (err) {
+        for (const slot of slots.values()) teardownSlot(slot);
+        if (restApp) await restApp.close().catch(() => {
+        });
+        if (otlpApp) await otlpApp.close().catch(() => {
+        });
+        await import_node_fs25.promises.unlink(pidPath).catch(() => {
+        });
+        throw new Error(
+          `neatd: failed to write daemon.json for "${singleProject}" \u2014 ${err.message}`
+        );
+      }
+    }
   }
   const initialBootstrap = loadAll().catch((err) => {
     console.warn(`neatd: initial bootstrap pass failed \u2014 ${err.message}`);
@@ -7504,7 +7674,7 @@ async function startDaemon(opts = {}) {
   const REGISTRY_RELOAD_DEBOUNCE_MS = 500;
   let registryWatcher = null;
   let reloadTimer = null;
-  try {
+  if (!singleProject) try {
     const regDir = import_node_path42.default.dirname(regPath);
     const regBase = import_node_path42.default.basename(regPath);
     registryWatcher = (0, import_node_fs25.watch)(regDir, (_eventType, filename) => {
@@ -7547,6 +7717,9 @@ async function startDaemon(opts = {}) {
     for (const slot of slots.values()) {
       teardownSlot(slot);
     }
+    if (daemonRecord) {
+      await clearDaemonRecord(daemonRecord, home);
+    }
     await import_node_fs25.promises.unlink(pidPath).catch(() => {
     });
   };
@@ -7558,7 +7731,8 @@ async function startDaemon(opts = {}) {
     restAddress,
     otlpAddress,
     bootstrap: tracker,
-    initialBootstrap
+    initialBootstrap,
+    daemonRecord
   };
 }
 // Annotate the CommonJS export names for ESM import in node: