@wrongstack/tools 0.296.3 → 0.297.0

package/dist/read.js

@@ -4535,6 +4535,7 @@ import { spawn as spawn4 } from "node:child_process";
 import * as fs10 from "node:fs";
 import * as net from "node:net";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { checkUnixSocketPath } from "@wrongstack/core/utils";
 
 // src/codebase-index/project-server-endpoint.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -4542,8 +4543,10 @@ import * as fs9 from "node:fs";
 import * as os3 from "node:os";
 import * as path13 from "node:path";
 import { fileURLToPath } from "node:url";
+import { assertUnixSocketPathWithinLimit } from "@wrongstack/core/utils";
 var PROJECT_INDEX_SERVER_PROTOCOL_VERSION = 1;
 var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
+var PROJECT_INDEX_SERVER_SOCKET_DIR = `wsci-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}`;
 var buildIdCache;
 function projectIndexServerBuildId(entrypoint) {
   const file = entrypoint instanceof URL || entrypoint.startsWith("file:") ? fileURLToPath(entrypoint) : path13.resolve(entrypoint);
@@ -4572,11 +4575,7 @@ function projectIndexServerEndpoint(projectRoot, indexDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-codebase-index-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path13.join(
-    os3.tmpdir(),
-    `wrongstack-codebase-index-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}`,
-    `${key}.sock`
-  );
+  return path13.join(os3.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
 }
 function projectIndexServerMetadataPath(projectRoot, indexDir) {
   return path13.join(
@@ -4612,20 +4611,35 @@ var latestConnectionState = {
   status: "offline",
   connected: false
 };
-function resolveProjectIndexDaemonAvailability() {
+function resolveProjectIndexDaemonAvailability(projectRoot, indexDir) {
   if (process.env["WRONGSTACK_INDEX_INLINE"] || process.env["WRONGSTACK_INDEX_SERVER"] === "0") {
     return { kind: "inline-requested" };
   }
+  let builtUrl = null;
   for (const rel of ["./project-server.js", "./codebase-index/project-server.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
       if (url.protocol === "file:" && fs10.existsSync(fileURLToPath2(url))) {
-        return { kind: "available", url };
+        builtUrl = url;
+        break;
       }
     } catch {
     }
   }
-  return { kind: "missing-build" };
+  if (builtUrl === null) return { kind: "missing-build" };
+  if (projectRoot !== void 0) {
+    const endpoint = projectIndexServerEndpoint(projectRoot, indexDir);
+    const check = checkUnixSocketPath(endpoint);
+    if (!check.ok) {
+      return {
+        kind: "endpoint-invalid",
+        endpoint,
+        byteLength: check.byteLength,
+        maxBytes: check.maxBytes
+      };
+    }
+  }
+  return { kind: "available", url: builtUrl };
 }
 function resolveProjectServerUrl() {
   const availability = resolveProjectIndexDaemonAvailability();
@@ -4732,6 +4746,10 @@ var ProjectServerConnection = class {
   isConnected() {
     return this.socket !== null && !this.socket.destroyed && this.info !== null;
   }
+  /** Safe LRU candidate: no request, connect, or health probe is in flight. */
+  isEvictable() {
+    return this.pending.size === 0 && this.connecting === null && this.healthCheck === null;
+  }
   async checkHealth(spawnIfMissing = false, timeoutMs = SERVER_HEALTH_TIMEOUT_MS) {
     await this.ensureConnected(spawnIfMissing);
     if (this.healthCheck) return this.healthCheck;
@@ -5130,7 +5148,26 @@ var ProjectServerConnection = class {
   }
 };
 var connections = /* @__PURE__ */ new Map();
+var MAX_CACHED_CONNECTIONS = 8;
 var heartbeatTimer;
+function forgetConnection(endpoint, connection) {
+  if (connections.get(endpoint) === connection) connections.delete(endpoint);
+  connection.close();
+  connectionStates.delete(endpoint);
+  if (latestConnectionState.endpoint !== endpoint) return;
+  latestConnectionState = [...connectionStates.values()].at(-1) ?? {
+    status: isProjectIndexServerAvailable() ? "offline" : "unavailable",
+    connected: false
+  };
+}
+function trimConnectionCache(protectedConnection) {
+  if (connections.size <= MAX_CACHED_CONNECTIONS) return;
+  for (const [endpoint, connection] of connections) {
+    if (connections.size <= MAX_CACHED_CONNECTIONS) break;
+    if (connection === protectedConnection || !connection.isEvictable()) continue;
+    forgetConnection(endpoint, connection);
+  }
+}
 function ensureHeartbeatLoop() {
   if (heartbeatTimer) return;
   heartbeatTimer = setInterval(() => {
@@ -5153,7 +5190,11 @@ function connectionFor(projectRoot, indexDir) {
   if (!connection) {
     connection = new ProjectServerConnection(projectRoot, indexDir, endpoint);
     connections.set(endpoint, connection);
+  } else {
+    connections.delete(endpoint);
+    connections.set(endpoint, connection);
   }
+  trimConnectionCache(connection);
   return connection;
 }
 function callProjectIndexServer(op, args, options) {
@@ -5259,8 +5300,17 @@ function terminateWorker(reason) {
   if (w) void w.terminate().catch(() => {
   });
 }
+var warnedInvalidEndpoints = /* @__PURE__ */ new Set();
+function warnEndpointInvalidOnce(availability) {
+  if (warnedInvalidEndpoints.has(availability.endpoint)) return;
+  warnedInvalidEndpoints.add(availability.endpoint);
+  process.stderr.write(
+    `codebase-index: socket path is ${availability.byteLength} bytes, over this platform's ${availability.maxBytes}-byte sun_path limit (${availability.endpoint}). Subsequent calls will reject until TMPDIR is shortened to restore the shared daemon.
+`
+  );
+}
 function callIndexOp(op, args, opts) {
-  const availability = resolveProjectIndexDaemonAvailability();
+  const availability = resolveProjectIndexDaemonAvailability(args.projectRoot, args.indexDir);
   if (availability.kind === "available") {
     return callProjectIndexServer(op, args, opts);
   }
@@ -5271,6 +5321,14 @@ function callIndexOp(op, args, opts) {
       )
     );
   }
+  if (availability.kind === "endpoint-invalid") {
+    warnEndpointInvalidOnce(availability);
+    return Promise.reject(
+      new Error(
+        `codebase-index: socket path is ${availability.byteLength} bytes, over this platform's ${availability.maxBytes}-byte sun_path limit (${availability.endpoint}). Set a shorter TMPDIR to relocate the shared daemon, or set WRONGSTACK_INDEX_INLINE=1 to explicitly opt into a process-local index.`
+      )
+    );
+  }
   const w = ensureWorker();
   if (!w) return callInline(op, args, opts);
   if (opts.signal?.aborted) {