@neat.is/core 0.4.17 → 0.4.18

package/dist/neatd.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(
@@ -592,14 +594,15 @@ var init_otel = __esm({
 
 // src/neatd.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_path44 = __toESM(require("path"), 1);
-var import_node_module = require("module");
+var import_node_module2 = require("module");
 
 // src/daemon.ts
 init_cjs_shims();
 var import_node_fs25 = require("fs");
 var import_node_path42 = __toESM(require("path"), 1);
+var import_node_module = require("module");
 
 // src/graph.ts
 init_cjs_shims();
@@ -6850,6 +6853,59 @@ function unroutedErrorsPath(neatHome3) {
 }
 
 // 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 req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req2("../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();
@@ -6966,6 +7022,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;
@@ -6976,13 +7049,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}
 `);
@@ -7071,21 +7155,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 entry2 of pruned) {
-        console.log(
-          `neatd: pruned project "${entry2.name}" \u2014 registered path ${entry2.path} is gone`
-        );
-        slots.delete(entry2.name);
-        bootstrapStatus.delete(entry2.name);
-        bootstrapStartedAt.delete(entry2.name);
+    if (!singleProject) {
+      try {
+        const pruned = await pruneRegistry();
+        for (const entry2 of pruned) {
+          console.log(
+            `neatd: pruned project "${entry2.name}" \u2014 registered path ${entry2.path} is gone`
+          );
+          slots.delete(entry2.name);
+          bootstrapStatus.delete(entry2.name);
+          bootstrapStartedAt.delete(entry2.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 entry2 of projects) {
@@ -7110,7 +7210,7 @@ async function startDaemon(opts = {}) {
     }
     await Promise.allSettled(pending);
   }
-  const initialEntries = await listProjects().catch(() => []);
+  const initialEntries = await enumerateProjects().catch(() => []);
   for (const entry2 of initialEntries) {
     bootstrapStatus.set(entry2.name, "bootstrapping");
     bootstrapStartedAt.set(entry2.name, Date.now());
@@ -7120,6 +7220,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));
@@ -7144,6 +7245,20 @@ async function startDaemon(opts = {}) {
           }
         }
       });
+      if (singleProject) {
+        restApp.addHook("onSend", async (req2, _reply, payload) => {
+          if (req2.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) {
@@ -7159,6 +7274,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);
@@ -7261,6 +7395,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}`);
@@ -7300,7 +7470,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) => {
@@ -7343,6 +7513,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(() => {
     });
   };
@@ -7354,7 +7527,8 @@ async function startDaemon(opts = {}) {
     restAddress,
     otlpAddress,
     bootstrap: tracker,
-    initialBootstrap
+    initialBootstrap,
+    daemonRecord
   };
 }
 
@@ -7364,9 +7538,40 @@ init_auth();
 // src/web-spawn.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
+var import_node_fs26 = require("fs");
 var import_node_net = __toESM(require("net"), 1);
 var import_node_path43 = __toESM(require("path"), 1);
 var DEFAULT_WEB_PORT = 6328;
+var DEFAULT_REST_PORT = 8080;
+function asValidPort(value) {
+  const n = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isInteger(n) && n > 0 && n <= 65535 ? n : null;
+}
+function projectRoot() {
+  const fromEnv = process.env.NEAT_SCAN_PATH;
+  return import_node_path43.default.resolve(fromEnv && fromEnv.length > 0 ? fromEnv : process.cwd());
+}
+async function readDaemonPorts(root) {
+  try {
+    const raw = await import_node_fs26.promises.readFile(import_node_path43.default.join(root, "neat-out", "daemon.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const ports = parsed?.ports ?? {};
+    return { web: asValidPort(ports.web), rest: asValidPort(ports.rest) };
+  } catch {
+    return { web: null, rest: null };
+  }
+}
+function resolveWebPorts(args) {
+  const { daemonWeb, daemonRest, webPortEnv, apiUrlEnv, restPortArg } = args;
+  const portFromEnv = webPortEnv && webPortEnv.length > 0 ? Number.parseInt(webPortEnv, 10) : null;
+  if (portFromEnv !== null && (!Number.isFinite(portFromEnv) || portFromEnv <= 0 || portFromEnv > 65535)) {
+    throw new Error(`neatd: invalid NEAT_WEB_PORT="${webPortEnv}"`);
+  }
+  const webPort = daemonWeb ?? portFromEnv ?? DEFAULT_WEB_PORT;
+  const restPort = daemonRest ?? asValidPort(restPortArg) ?? DEFAULT_REST_PORT;
+  const apiUrl = apiUrlEnv ?? `http://localhost:${restPort}`;
+  return { webPort, apiUrl };
+}
 async function assertPortFree(port) {
   await new Promise((resolve, reject) => {
     const tester = import_node_net.default.createServer();
@@ -7398,42 +7603,98 @@ function resolveWebPackageDir() {
 function resolveStandaloneServerEntry(webDir) {
   return import_node_path43.default.join(webDir, ".next/standalone/packages/web/server.js");
 }
-async function spawnWebUI(restPort) {
-  const portRaw = process.env.NEAT_WEB_PORT;
-  const port = portRaw && portRaw.length > 0 ? Number.parseInt(portRaw, 10) : DEFAULT_WEB_PORT;
-  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
-    throw new Error(`neatd: invalid NEAT_WEB_PORT="${portRaw}"`);
-  }
+async function pickInternalPort() {
+  return new Promise((resolve, reject) => {
+    const srv = import_node_net.default.createServer();
+    srv.once("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (addr && typeof addr === "object") {
+        const port = addr.port;
+        srv.close(() => resolve(port));
+      } else {
+        srv.close(() => reject(new Error("neatd: could not pick an internal web port")));
+      }
+    });
+  });
+}
+async function spawnWebUI(restPort, opts = {}) {
+  const root = projectRoot();
+  const fromDaemon = await readDaemonPorts(root);
+  const { webPort: port, apiUrl } = resolveWebPorts({
+    daemonWeb: fromDaemon.web,
+    daemonRest: fromDaemon.rest,
+    webPortEnv: process.env.NEAT_WEB_PORT,
+    apiUrlEnv: process.env.NEAT_API_URL,
+    restPortArg: restPort
+  });
   await assertPortFree(port);
-  const cwd = resolveWebPackageDir();
-  const serverEntry = resolveStandaloneServerEntry(cwd);
-  try {
-    require.resolve(serverEntry);
-  } catch {
-    throw new Error(
-      `neatd: web UI standalone build missing at ${serverEntry}. The published @neat.is/web tarball should include it; if you're running from a monorepo checkout, run \`npm run build --workspace @neat.is/web\` first, or set NEAT_WEB_DISABLED=1 to skip the web UI.`
-    );
+  const serverEntry = opts.serverEntry ?? resolveStandaloneServerEntry(resolveWebPackageDir());
+  if (!opts.skipBuildCheck) {
+    try {
+      require.resolve(serverEntry);
+    } catch {
+      throw new Error(
+        `neatd: web UI standalone build missing at ${serverEntry}. The published @neat.is/web tarball should include it; if you're running from a monorepo checkout, run \`npm run build --workspace @neat.is/web\` first, or set NEAT_WEB_DISABLED=1 to skip the web UI.`
+      );
+    }
   }
-  const env = {
-    ...process.env,
-    PORT: String(port),
-    HOSTNAME: process.env.HOSTNAME ?? "0.0.0.0",
-    NEAT_API_URL: process.env.NEAT_API_URL ?? `http://localhost:${restPort}`
-  };
-  const child = (0, import_node_child_process2.spawn)(process.execPath, [serverEntry], {
-    cwd: import_node_path43.default.dirname(serverEntry),
-    env,
-    stdio: ["ignore", "inherit", "inherit"],
-    detached: false
+  let child = null;
+  let internalPort = 0;
+  let starting = null;
+  let stopped = false;
+  function ensureStarted() {
+    if (starting) return starting;
+    starting = (async () => {
+      internalPort = await pickInternalPort();
+      const env = {
+        ...process.env,
+        PORT: String(internalPort),
+        HOSTNAME: "127.0.0.1",
+        NEAT_API_URL: apiUrl
+      };
+      child = (0, import_node_child_process2.spawn)(process.execPath, [serverEntry], {
+        cwd: import_node_path43.default.dirname(serverEntry),
+        env,
+        stdio: ["ignore", "inherit", "inherit"],
+        detached: false
+      });
+      child.on("error", (err) => {
+        console.error(`neatd: web UI spawn error \u2014 ${err.message}`);
+      });
+      await waitForListening(internalPort);
+      console.log(`neatd: web UI ready on http://localhost:${port}`);
+    })();
+    return starting;
+  }
+  const front = import_node_net.default.createServer((socket) => {
+    socket.on("error", () => socket.destroy());
+    ensureStarted().then(() => {
+      if (stopped) {
+        socket.destroy();
+        return;
+      }
+      const upstream = import_node_net.default.connect(internalPort, "127.0.0.1");
+      upstream.on("error", () => socket.destroy());
+      socket.pipe(upstream);
+      upstream.pipe(socket);
+      socket.on("close", () => upstream.destroy());
+      upstream.on("close", () => socket.destroy());
+    }).catch((err) => {
+      console.error(`neatd: web UI failed to start \u2014 ${err.message}`);
+      socket.destroy();
+    });
   });
-  child.on("error", (err) => {
-    console.error(`neatd: web UI spawn error \u2014 ${err.message}`);
+  await new Promise((resolve, reject) => {
+    front.once("error", reject);
+    front.listen(port, "127.0.0.1", () => resolve());
   });
-  console.log(`neatd: web UI listening on http://localhost:${port}`);
-  let stopped = false;
+  console.log(`neatd: web UI listening on http://localhost:${port} (starts on first open)`);
   async function stop() {
-    if (stopped || !child.pid) return;
+    if (stopped) return;
     stopped = true;
+    await new Promise((resolve) => front.close(() => resolve()));
+    if (!child || !child.pid) return;
     try {
       child.kill("SIGTERM");
     } catch {
@@ -7441,18 +7702,46 @@ async function spawnWebUI(restPort) {
     await new Promise((resolve) => {
       const t = setTimeout(() => {
         try {
-          child.kill("SIGKILL");
+          child?.kill("SIGKILL");
         } catch {
         }
         resolve();
       }, 3e3);
-      child.once("exit", () => {
+      child?.once("exit", () => {
         clearTimeout(t);
         resolve();
       });
     });
   }
-  return { child, port, stop };
+  return {
+    get child() {
+      return child;
+    },
+    port,
+    started: () => child !== null,
+    stop
+  };
+}
+async function waitForListening(port, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const ok = await new Promise((resolve) => {
+      const s = import_node_net.default.connect(port, "127.0.0.1");
+      s.once("connect", () => {
+        s.destroy();
+        resolve(true);
+      });
+      s.once("error", () => {
+        s.destroy();
+        resolve(false);
+      });
+    });
+    if (ok) return;
+    if (Date.now() > deadline) {
+      throw new Error(`neatd: web UI did not start listening on :${port} within ${timeoutMs}ms`);
+    }
+    await new Promise((r) => setTimeout(r, 150));
+  }
 }
 
 // src/version-skew.ts
@@ -7525,7 +7814,7 @@ function localVersion() {
     return process.env.NEAT_LOCAL_VERSION;
   }
   try {
-    const req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const req2 = (0, import_node_module2.createRequire)(importMetaUrl);
     const pkg = req2("../package.json");
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
@@ -7541,7 +7830,7 @@ function neatHome2() {
 }
 async function readPid() {
   try {
-    const raw = await import_node_fs26.promises.readFile(import_node_path44.default.join(neatHome2(), "neatd.pid"), "utf8");
+    const raw = await import_node_fs27.promises.readFile(import_node_path44.default.join(neatHome2(), "neatd.pid"), "utf8");
     const n = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(n) ? n : null;
   } catch {
@@ -7555,10 +7844,19 @@ function restPortFromEnv() {
   const raw = process.env.PORT;
   return raw && raw.length > 0 ? Number.parseInt(raw, 10) : 8080;
 }
+function webPortFromEnv() {
+  const raw = process.env.NEAT_WEB_PORT;
+  if (!raw || raw.length === 0) return void 0;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
 async function cmdStart() {
+  const project = process.env.NEAT_PROJECT;
+  const projectPath = process.env.NEAT_PROJECT_PATH;
+  const startOpts = project && project.length > 0 ? { project, projectPath, webPort: webPortFromEnv() } : {};
   let handle;
   try {
-    handle = await startDaemon();
+    handle = await startDaemon(startOpts);
   } catch (err) {
     if (err instanceof BindAuthorityError) {
       console.error(`neatd: ${err.message}`);