@neat.is/core 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -1653,6 +1653,29 @@ async function appendErrorEvent(ctx, ev) {
   await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs3.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+function buildErrorEventForReceiver(span) {
+  if (span.statusCode !== 2) return null;
+  const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `${span.traceId}:${span.spanId}`,
+    timestamp: ts,
+    service: span.service,
+    traceId: span.traceId,
+    spanId: span.spanId,
+    errorMessage: span.exception?.message ?? span.errorMessage ?? span.name ?? "unknown error",
+    ...span.exception?.type ? { exceptionType: span.exception.type } : {},
+    ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+    affectedNode: (0, import_types3.serviceId)(span.service)
+  };
+}
+function makeErrorSpanWriter(errorsPath) {
+  return async (span) => {
+    const ev = buildErrorEventForReceiver(span);
+    if (!ev) return;
+    await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(errorsPath), { recursive: true });
+    await import_node_fs3.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  };
+}
 async function handleSpan(ctx, span) {
   const ts = span.startTimeIso ?? nowIso(ctx);
   const nowMs = ctx.now ? ctx.now() : Date.now();
@@ -4895,6 +4918,7 @@ init_otel_grpc();
 init_cjs_shims();
 var import_node_fs19 = require("fs");
 var import_node_path33 = __toESM(require("path"), 1);
+init_otel();
 function neatHomeFor(opts) {
   if (opts.neatHome && opts.neatHome.length > 0) return import_node_path33.default.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
@@ -4913,6 +4937,7 @@ function routeSpanToProject(serviceName, projects) {
   return DEFAULT_PROJECT;
 }
 async function bootstrapProject(entry) {
+  const paths = pathsForProject(entry.name, import_node_path33.default.join(entry.path, "neat-out"));
   try {
     const stat = await import_node_fs19.promises.stat(entry.path);
     if (!stat.isDirectory()) {
@@ -4927,6 +4952,7 @@ async function bootstrapProject(entry) {
       // output; nothing routes to it because it's not 'active'.
       graph: getGraph(`__broken__:${entry.name}`),
       outPath: "",
+      paths,
       stopPersist: () => {
       },
       status: "broken",
@@ -4935,10 +4961,7 @@ async function bootstrapProject(entry) {
   }
   resetGraph(entry.name);
   const graph = getGraph(entry.name);
-  const outPath = pathsForProject(
-    entry.name,
-    import_node_path33.default.join(entry.path, "neat-out")
-  ).snapshotPath;
+  const outPath = paths.snapshotPath;
   await loadGraphFromDisk(graph, outPath);
   await extractFromDirectory(graph, entry.path);
   const stopPersist = startPersistLoop(graph, outPath);
@@ -4948,10 +4971,35 @@ async function bootstrapProject(entry) {
     entry,
     graph,
     outPath,
+    paths,
     stopPersist,
     status: "active"
   };
 }
+function resolveRestPort(opts) {
+  if (typeof opts.restPort === "number") return opts.restPort;
+  const env = process.env.PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 8080;
+}
+function resolveOtlpPort(opts) {
+  if (typeof opts.otlpPort === "number") return opts.otlpPort;
+  const env = process.env.OTEL_PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 4318;
+}
+function resolveHost(opts) {
+  if (opts.host && opts.host.length > 0) return opts.host;
+  const env = process.env.HOST;
+  if (env && env.length > 0) return env;
+  return "0.0.0.0";
+}
 async function startDaemon(opts = {}) {
   const home = neatHomeFor(opts);
   const regPath = registryPath();
@@ -4966,6 +5014,15 @@ async function startDaemon(opts = {}) {
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();
+  const registry = new Projects();
+  function upsertRegistryFromSlot(slot) {
+    if (slot.status !== "active") return;
+    registry.set(slot.entry.name, {
+      scanPath: slot.entry.path,
+      paths: slot.paths,
+      graph: slot.graph
+    });
+  }
   async function loadAll() {
     const projects = await listProjects();
     const seen = /* @__PURE__ */ new Set();
@@ -4975,6 +5032,7 @@ async function startDaemon(opts = {}) {
       try {
         const slot = await bootstrapProject(entry);
         slots.set(entry.name, slot);
+        upsertRegistryFromSlot(slot);
         if (slot.status === "broken") {
           console.warn(`neatd: project "${entry.name}" broken \u2014 ${slot.errorReason}`);
         } else {
@@ -4999,6 +5057,80 @@ async function startDaemon(opts = {}) {
     }
   }
   await loadAll();
+  const bind = opts.bindListeners !== false;
+  let restApp = null;
+  let otlpApp = null;
+  let restAddress = "";
+  let otlpAddress = "";
+  if (bind) {
+    const host = resolveHost(opts);
+    const restPort = resolveRestPort(opts);
+    const otlpPort = resolveOtlpPort(opts);
+    try {
+      restApp = await buildApi({ projects: registry });
+      restAddress = await restApp.listen({ port: restPort, host });
+      console.log(`neatd: REST listening on ${restAddress}`);
+    } catch (err) {
+      for (const slot of slots.values()) {
+        try {
+          slot.stopPersist();
+        } catch {
+        }
+      }
+      if (restApp) await restApp.close().catch(() => {
+      });
+      await import_node_fs19.promises.unlink(pidPath).catch(() => {
+      });
+      throw new Error(
+        `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
+      );
+    }
+    try {
+      otlpApp = await buildOtelReceiver({
+        onSpan: async (span) => {
+          const liveEntries = await listProjects().catch(() => []);
+          const target = routeSpanToProject(span.service, liveEntries);
+          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+          if (!slot || slot.status !== "active") return;
+          await handleSpan(
+            {
+              graph: slot.graph,
+              errorsPath: slot.paths.errorsPath,
+              project: slot.entry.name,
+              // Receiver already wrote the error event synchronously below.
+              writeErrorEventInline: false
+            },
+            span
+          );
+        },
+        onErrorSpanSync: async (span) => {
+          const liveEntries = await listProjects().catch(() => []);
+          const target = routeSpanToProject(span.service, liveEntries);
+          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+          if (!slot || slot.status !== "active") return;
+          await makeErrorSpanWriter(slot.paths.errorsPath)(span);
+        }
+      });
+      otlpAddress = await otlpApp.listen({ port: otlpPort, host });
+      console.log(`neatd: OTLP listening on ${otlpAddress}/v1/traces`);
+    } catch (err) {
+      for (const slot of slots.values()) {
+        try {
+          slot.stopPersist();
+        } catch {
+        }
+      }
+      if (restApp) await restApp.close().catch(() => {
+      });
+      if (otlpApp) await otlpApp.close().catch(() => {
+      });
+      await import_node_fs19.promises.unlink(pidPath).catch(() => {
+      });
+      throw new Error(
+        `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
+      );
+    }
+  }
   let reloading = null;
   const reload = async () => {
     if (reloading) return reloading;
@@ -5022,6 +5154,10 @@ async function startDaemon(opts = {}) {
     if (stopped) return;
     stopped = true;
     process.off("SIGHUP", sighupHandler);
+    if (otlpApp) await otlpApp.close().catch(() => {
+    });
+    if (restApp) await restApp.close().catch(() => {
+    });
     for (const slot of slots.values()) {
       try {
         slot.stopPersist();
@@ -5031,7 +5167,7 @@ async function startDaemon(opts = {}) {
     await import_node_fs19.promises.unlink(pidPath).catch(() => {
     });
   };
-  return { slots, reload, stop, pidPath };
+  return { slots, reload, stop, pidPath, restAddress, otlpAddress };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {