@neat.is/mcp 0.9.1-dev.20260819 → 0.9.2-dev.20260821

package/dist/index.cjs

@@ -42,10 +42,12 @@ function readDaemonRecord(path) {
   }
   return `http://localhost:${rest}`;
 }
-function resolveBaseUrl(env = process.env, cwd = process.cwd()) {
+function resolveBaseUrlWithSource(env = process.env, cwd = process.cwd()) {
   const override = env.NEAT_CORE_URL ?? env.NEAT_API_URL;
-  if (override) return override;
-  return resolveFromDaemonRecord(cwd) ?? DEFAULT_BASE_URL;
+  if (override) return { url: override, source: "env" };
+  const fromRecord = resolveFromDaemonRecord(cwd);
+  if (fromRecord !== void 0) return { url: fromRecord, source: "daemon-record" };
+  return { url: DEFAULT_BASE_URL, source: "default" };
 }
 
 // src/client.ts
@@ -72,10 +74,10 @@ async function fetchWithTimeout(url, init, timeoutMs, method, path) {
     throw err;
   }
 }
-function createHttpClient(baseUrl2, bearerToken, timeoutMs) {
+function createHttpClient(baseUrl2, bearerToken2, timeoutMs) {
   const root = baseUrl2.replace(/\/$/, "");
   const deadline = resolveTimeoutMs(timeoutMs);
-  const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
+  const authHeader = bearerToken2 && bearerToken2.length > 0 ? { authorization: `Bearer ${bearerToken2}` } : {};
   return {
     async get(path) {
       const res = await fetchWithTimeout(
@@ -149,6 +151,61 @@ var RequestTimeoutError = class extends Error {
   }
 };
 
+// src/endpoint-check.ts
+var PROBE_TIMEOUT_MS = 2500;
+async function checkEndpointIsNeat(baseUrl2, opts = {}) {
+  const root = baseUrl2.replace(/\/$/, "");
+  const doFetch = opts.fetchImpl ?? fetch;
+  const headers = opts.bearerToken && opts.bearerToken.length > 0 ? { authorization: `Bearer ${opts.bearerToken}` } : {};
+  let res;
+  try {
+    res = await doFetch(`${root}/health`, {
+      headers,
+      signal: AbortSignal.timeout(opts.timeoutMs ?? PROBE_TIMEOUT_MS)
+    });
+  } catch (err) {
+    return { kind: "unreachable", detail: errMessage(err) };
+  }
+  if (res.status === 401 || res.status === 403 || res.status >= 500) {
+    return { kind: "unreachable", detail: `HTTP ${res.status}` };
+  }
+  const contentType = res.headers.get("content-type") ?? "unknown";
+  const body = await res.text().catch(() => "");
+  if (isNeatHealth(body)) return { kind: "neat" };
+  return { kind: "foreign", status: res.status, contentType };
+}
+function isNeatHealth(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return false;
+  }
+  if (parsed === null || typeof parsed !== "object") return false;
+  const rec = parsed;
+  return rec.ok === true && typeof rec.uptimeMs === "number";
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function describeForeignEndpoint(url, source, check) {
+  const how = {
+    env: "from NEAT_CORE_URL / NEAT_API_URL",
+    "daemon-record": "from a neat-out/daemon.json record found while walking up from the working directory",
+    default: "from the default http://localhost:8080 \u2014 no NEAT_CORE_URL was set and no neat-out/daemon.json was found walking up from the working directory"
+  };
+  const fix = {
+    env: "Check that NEAT_CORE_URL points at a running NEAT daemon.",
+    "daemon-record": "The REST port recorded in that daemon.json is now answered by something else \u2014 the record is stale. Restart the project daemon, or set NEAT_CORE_URL to its address.",
+    default: "Another service \u2014 not NEAT \u2014 is answering on :8080. Run the MCP server from inside a NEAT project so it can discover neat-out/daemon.json, or set NEAT_CORE_URL to your daemon's address."
+  };
+  return [
+    `NEAT MCP server: resolved the daemon at ${url} (${how[source]}), but it does not look like NEAT \u2014 a probe of ${url}/health returned HTTP ${check.status} (${check.contentType}), not NEAT's health JSON.`,
+    fix[source],
+    "If this really is your NEAT daemon (for example behind a proxy that rewrites /health), set NEAT_SKIP_ENDPOINT_CHECK=1 to bypass this check."
+  ].join("\n\n");
+}
+
 // src/resources.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var NODE_RESOURCE_MIME = "application/json";
@@ -1067,9 +1124,11 @@ async function neatRollbackExtension(client2, input) {
 }
 
 // src/index.ts
-var baseUrl = resolveBaseUrl();
+var resolved = resolveBaseUrlWithSource();
+var baseUrl = resolved.url;
 var authToken = process.env.NEAT_AUTH_TOKEN;
-var client = createHttpClient(baseUrl, authToken && authToken.length > 0 ? authToken : void 0);
+var bearerToken = authToken && authToken.length > 0 ? authToken : void 0;
+var client = createHttpClient(baseUrl, bearerToken);
 var defaultProject = process.env.NEAT_DEFAULT_PROJECT;
 var projectFor = (input) => input.project ?? defaultProject;
 var projectField = import_zod.z.string().optional().describe(
@@ -1282,7 +1341,17 @@ var resourceRegistration = registerResources(server, client, {
   ...incidentsPollMs !== void 0 ? { incidentsPollMs } : {},
   ...defaultProject ? { project: defaultProject } : {}
 });
+async function guardEndpoint() {
+  const skip = process.env.NEAT_SKIP_ENDPOINT_CHECK;
+  if (skip === "1" || skip === "true") return;
+  const check = await checkEndpointIsNeat(baseUrl, { bearerToken });
+  if (check.kind === "foreign") {
+    console.error(describeForeignEndpoint(baseUrl, resolved.source, check));
+    process.exit(1);
+  }
+}
 async function main() {
+  await guardEndpoint();
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
 }