@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-HYX2TZ7O.js

@@ -0,0 +1,1272 @@
+import {
+  MAX_BINARY_FRAME_BYTES,
+  PROJECT_INDEX_SERVER_MAX_FRAME_CHARS,
+  PROJECT_INDEX_SERVER_PROTOCOL_VERSION,
+  decodeBinaryFrame,
+  encodeBinaryFrame,
+  encodeProjectServerMessage,
+  isBinaryFrame,
+  projectIndexServerBuildId,
+  projectIndexServerEndpoint,
+  projectIndexServerMetadataPath
+} from "./chunk-4UESMQDP.js";
+import {
+  CircuitOpenError,
+  IndexTimeoutError,
+  LockError,
+  fileGraphService,
+  incomingCallsService,
+  indexCircuitBreaker,
+  indexService,
+  indexStorePool,
+  outgoingCallsService,
+  packageGraphService,
+  searchService,
+  statsService,
+  symbolGraphService
+} from "./chunk-DA4KNE2H.js";
+import {
+  isIndexablePath
+} from "./chunk-TEBQ4VPZ.js";
+
+// src/codebase-index/project-server-client-state.ts
+import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { checkUnixSocketPath } from "@wrongstack/core/utils";
+var CONNECT_ATTEMPT_TIMEOUT_MS = 750;
+var SERVER_START_TIMEOUT_MS = 1e4;
+var SERVER_CONTROL_TIMEOUT_MS = 5e3;
+var SERVER_HEALTH_TIMEOUT_MS = 3e3;
+var SERVER_HEARTBEAT_INTERVAL_MS = 1e4;
+var StaleProjectIndexServerError = class extends Error {
+  constructor(message, pid) {
+    super(message);
+    this.pid = pid;
+  }
+  pid;
+  name = "StaleProjectIndexServerError";
+};
+var connectionStates = /* @__PURE__ */ new Map();
+var connectionStateListeners = /* @__PURE__ */ new Set();
+var latestConnectionState = {
+  status: "offline",
+  connected: false
+};
+function setLatestConnectionState(state) {
+  latestConnectionState = state;
+}
+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:" && fs.existsSync(fileURLToPath(url))) {
+        builtUrl = url;
+        break;
+      }
+    } catch {
+    }
+  }
+  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();
+  return availability.kind === "available" ? availability.url : null;
+}
+function projectIndexServerExpectedBuildId() {
+  const override = process.env["WRONGSTACK_INDEX_SERVER_BUILD_ID"]?.trim();
+  if (override) return override;
+  const url = resolveProjectServerUrl();
+  return url ? projectIndexServerBuildId(url) : null;
+}
+function isProjectIndexServerAvailable() {
+  return resolveProjectServerUrl() !== null;
+}
+function publishConnectionState(endpoint, state) {
+  connectionStates.set(endpoint, state);
+  latestConnectionState = state;
+  for (const listener of connectionStateListeners) listener(state);
+}
+function getProjectIndexServerConnectionState(projectRoot, indexDir) {
+  if (projectRoot) {
+    const endpoint = projectIndexServerEndpoint(projectRoot, indexDir);
+    const existing = connectionStates.get(endpoint);
+    if (existing) return existing;
+    if (!isProjectIndexServerAvailable()) {
+      return { status: "unavailable", connected: false };
+    }
+    return {
+      status: "offline",
+      connected: false,
+      projectRoot,
+      indexDir,
+      endpoint
+    };
+  }
+  if (latestConnectionState.endpoint) return latestConnectionState;
+  if (!isProjectIndexServerAvailable()) return { status: "unavailable", connected: false };
+  return latestConnectionState;
+}
+function onProjectIndexServerConnectionStateChange(listener) {
+  connectionStateListeners.add(listener);
+  return () => connectionStateListeners.delete(listener);
+}
+function remoteError(message, name) {
+  if (name === "LockError") return new LockError(message);
+  if (name === "IndexTimeoutError") return new IndexTimeoutError(message);
+  const error = new Error(message);
+  if (name && name !== "Error") error.name = name;
+  return error;
+}
+function isProjectIndexServerHealth(value) {
+  if (!value || typeof value !== "object") return false;
+  const health = value;
+  const memory = health.memory && typeof health.memory === "object" ? health.memory : void 0;
+  const activity = health.activity && typeof health.activity === "object" ? health.activity : void 0;
+  return typeof health.checkedAt === "number" && typeof health.uptimeMs === "number" && typeof memory?.rss === "number" && typeof memory.heapUsed === "number" && typeof memory.heapTotal === "number" && typeof memory.external === "number" && typeof health.clients === "number" && typeof health.activeRequests === "number" && typeof health.activeWrites === "number" && typeof health.queuedWrites === "number" && typeof health.pendingExternalFiles === "number" && typeof health.watchingExternal === "boolean" && typeof activity?.indexing === "boolean" && typeof activity.currentFile === "number" && typeof activity.totalFiles === "number" && typeof activity.generation === "number";
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+function cancellationError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Indexing cancelled");
+}
+
+// src/codebase-index/project-server-client.ts
+import { spawn } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as net from "node:net";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var ProjectServerConnection = class {
+  constructor(projectRoot, indexDir, endpoint) {
+    this.projectRoot = projectRoot;
+    this.indexDir = indexDir;
+    this.endpoint = endpoint;
+    this.transition("offline");
+  }
+  projectRoot;
+  indexDir;
+  endpoint;
+  socket = null;
+  /**
+   * Raw inbound bytes for the unified per-frame reader. Frames are sniffed
+   * individually — JSON text (newline-terminated) or binary (magic 0x57) —
+   * instead of latching a read mode, so a JSON broadcast between binary
+   * frames cannot desynchronize the reader.
+   */
+  readBuffer = Buffer.alloc(0);
+  /** P6: true once the server advertises binary support and client accepts. */
+  useBinary = false;
+  info = null;
+  activity = null;
+  health = null;
+  healthCheck = null;
+  connecting = null;
+  connectResolve = null;
+  connectReject = null;
+  nextId = 1;
+  /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+  authToken;
+  pending = /* @__PURE__ */ new Map();
+  transition(status, options = {}) {
+    const previous = connectionStates.get(this.endpoint);
+    const pid = options.pid ?? (status === "connected" ? this.info?.pid : void 0);
+    const lastError = options.error === void 0 ? status === "error" || status === "degraded" || status === "unresponsive" ? previous?.lastError : void 0 : options.error instanceof Error ? options.error.message : String(options.error);
+    publishConnectionState(this.endpoint, {
+      status,
+      connected: status === "connected" || status === "degraded" || status === "unresponsive",
+      projectRoot: this.projectRoot,
+      indexDir: this.indexDir,
+      endpoint: this.endpoint,
+      pid,
+      lastError,
+      ...this.activity ? { activity: this.activity } : {},
+      ...this.health ? { health: this.health } : {}
+    });
+  }
+  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;
+    const startedAt = Date.now();
+    this.healthCheck = this.request({ type: "ping" }, { timeoutMs }).then((server) => {
+      const now = Date.now();
+      this.health = {
+        status: "healthy",
+        checkedAt: now,
+        lastHealthyAt: now,
+        latencyMs: Math.max(0, now - startedAt),
+        missedHeartbeats: 0,
+        ...isProjectIndexServerHealth(server) ? { server } : {}
+      };
+      this.transition("connected", { pid: this.info?.pid });
+      return this.health;
+    }).catch((error) => {
+      if (!this.isConnected()) throw error;
+      if ((this.health?.lastHealthyAt ?? 0) > startedAt) return this.health;
+      const missedHeartbeats = (this.health?.missedHeartbeats ?? 0) + 1;
+      const status = missedHeartbeats >= 3 ? "unresponsive" : "degraded";
+      this.health = {
+        status,
+        checkedAt: Date.now(),
+        lastHealthyAt: this.health?.lastHealthyAt ?? null,
+        latencyMs: null,
+        missedHeartbeats,
+        ...this.health?.server ? { server: this.health.server } : {}
+      };
+      this.transition(status, { pid: this.info?.pid, error });
+      return this.health;
+    }).finally(() => {
+      this.healthCheck = null;
+    });
+    return this.healthCheck;
+  }
+  markResponsive() {
+    const now = Date.now();
+    this.health = {
+      status: "healthy",
+      checkedAt: now,
+      lastHealthyAt: now,
+      latencyMs: this.health?.latencyMs ?? null,
+      missedHeartbeats: 0,
+      ...this.health?.server ? { server: this.health.server } : {}
+    };
+  }
+  async call(op, args, options) {
+    if (options.signal?.aborted) throw cancellationError(options.signal);
+    await this.ensureConnected(true);
+    if (options.signal?.aborted) throw cancellationError(options.signal);
+    return this.request({ type: "request", op, args }, options);
+  }
+  async shutdownRemote(reason) {
+    try {
+      await this.ensureConnected(false);
+    } catch {
+      return { stopped: false, reason: "not-running" };
+    }
+    const pid = this.info?.pid;
+    try {
+      this.transition("stopping", { pid });
+      await this.request(
+        { type: "shutdown", reason },
+        { timeoutMs: SERVER_CONTROL_TIMEOUT_MS }
+      );
+      return { stopped: true, pid };
+    } catch (error) {
+      const forceKilled = this.forceKillKnownServer();
+      return {
+        stopped: forceKilled,
+        pid,
+        reason: forceKilled ? `force-killed after graceful shutdown failed: ${error instanceof Error ? error.message : String(error)}` : error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      this.close();
+    }
+  }
+  async configure(watchExternal, debounceMs, coalesceWindowMs) {
+    await this.ensureConnected(true);
+    const startedAt = Date.now();
+    const result = await this.request(
+      { type: "configure", watchExternal, debounceMs, coalesceWindowMs },
+      { timeoutMs: SERVER_CONTROL_TIMEOUT_MS }
+    );
+    if (isProjectIndexServerHealth(result.health)) {
+      const now = Date.now();
+      this.health = {
+        status: "healthy",
+        checkedAt: now,
+        lastHealthyAt: now,
+        latencyMs: Math.max(0, now - startedAt),
+        missedHeartbeats: 0,
+        server: result.health
+      };
+      this.transition("connected", { pid: this.info?.pid });
+    }
+  }
+  close() {
+    const socket = this.socket;
+    this.socket = null;
+    this.info = null;
+    this.activity = null;
+    this.health = null;
+    this.useBinary = false;
+    this.readBuffer = Buffer.alloc(0);
+    this.connectReject?.(new Error("codebase-index client disconnected"));
+    this.connectResolve = null;
+    this.connectReject = null;
+    if (socket && !socket.destroyed) socket.destroy();
+    this.rejectPending(new Error("codebase-index client disconnected"));
+    this.transition("offline");
+    maybeStopHeartbeatLoop();
+  }
+  /**
+   * WS-027: the per-process token, read from the daemon's owner-only metadata
+   * file — never from the `hello` frame, which the daemon sends to every
+   * socket that connects (the mistake WS-028 found in the SAGE daemon).
+   *
+   * Read lazily and re-read while unknown: the daemon starts listening before
+   * it writes metadata (endpoint ownership has to be won first), and a
+   * respawned daemon mints a new token, so a cached wrong one would be sticky.
+   */
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const raw = fs2.readFileSync(
+          projectIndexServerMetadataPath(this.projectRoot, this.indexDir),
+          "utf8"
+        );
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
+          this.authToken = parsed.authToken;
+        }
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
+  request(message, options) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed) {
+      return Promise.reject(new Error("codebase-index server connection is not available"));
+    }
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const entry = this.pending.get(id);
+        if (!entry) return;
+        this.pending.delete(id);
+        this.write({ type: "cancel", id });
+        const error = new IndexTimeoutError(
+          `Index ${message.type === "request" ? message.op : message.type} exceeded its ${options.timeoutMs}ms watchdog timeout`
+        );
+        this.cleanupPending(entry);
+        entry.reject(error);
+      }, options.timeoutMs);
+      timer.unref?.();
+      const signal = options.signal;
+      const onAbort = signal ? () => {
+        const entry = this.pending.get(id);
+        if (!entry) return;
+        this.pending.delete(id);
+        this.write({ type: "cancel", id });
+        this.cleanupPending(entry);
+        entry.reject(cancellationError(signal));
+      } : void 0;
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timer,
+        signal,
+        onAbort,
+        onProgress: options.onProgress
+      });
+      if (signal && onAbort) {
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+      }
+      this.write({ ...message, id, authToken: this.currentAuthToken() });
+    });
+  }
+  async ensureConnected(spawnIfMissing) {
+    if (this.socket && !this.socket.destroyed && this.info) return;
+    if (this.connecting) return this.connecting;
+    this.transition("connecting");
+    this.connecting = this.connectWithElection(spawnIfMissing).catch((error) => {
+      this.transition("error", { error });
+      throw error;
+    }).finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  async connectWithElection(spawnIfMissing) {
+    const deadline = Date.now() + (spawnIfMissing ? SERVER_START_TIMEOUT_MS : CONNECT_ATTEMPT_TIMEOUT_MS);
+    let spawned = false;
+    let staleAttempts = 0;
+    let lastError = new Error("codebase-index server unavailable");
+    while (Date.now() < deadline) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof StaleProjectIndexServerError) {
+          staleAttempts++;
+          if (!spawnIfMissing) break;
+          if (staleAttempts >= 3) this.forceKillServer(error.pid);
+          spawned = false;
+          await delay(100);
+          continue;
+        }
+      }
+      if (!spawnIfMissing) break;
+      if (!spawned) {
+        this.spawnDetachedServer();
+        spawned = true;
+      }
+      await delay(75);
+    }
+    throw lastError;
+  }
+  connectOnce() {
+    this.socket?.destroy();
+    this.socket = null;
+    this.authToken = void 0;
+    this.info = null;
+    this.activity = null;
+    this.health = null;
+    this.readBuffer = Buffer.alloc(0);
+    this.useBinary = false;
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection(this.endpoint);
+      this.socket = socket;
+      const timer = setTimeout(() => {
+        reject(new Error("codebase-index server handshake timed out"));
+        socket.destroy();
+      }, CONNECT_ATTEMPT_TIMEOUT_MS);
+      timer.unref?.();
+      const finishResolve = () => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        resolve();
+      };
+      const finishReject = (error) => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(error);
+      };
+      this.connectResolve = finishResolve;
+      this.connectReject = finishReject;
+      socket.on("data", (chunk) => this.onData(socket, chunk));
+      socket.on("error", (error) => {
+        if (!this.info) finishReject(error);
+      });
+      socket.on("close", () => this.onClose(socket));
+    });
+  }
+  /**
+   * Unified per-frame reader. Each frame is sniffed by its first byte:
+   * `0x57` ('W') → length-prefixed MessagePack binary, anything else →
+   * newline-delimited JSON text. Sniffing per frame (instead of latching a
+   * mode) is what makes mixed streams work: the server may interleave a JSON
+   * `index-state` broadcast between binary responses, and an old JSON-only
+   * server stays readable while `useBinary` is armed.
+   *
+   * Multibyte UTF-8 in JSON frames is safe: raw `0x0a` only occurs as the
+   * JSON delimiter (inside JSON strings `\n` is escaped), so a complete line
+   * is always complete UTF-8.
+   */
+  onData(socket, chunk) {
+    if (socket !== this.socket) return;
+    this.readBuffer = this.readBuffer.length === 0 ? chunk : Buffer.concat([this.readBuffer, chunk]);
+    while (true) {
+      if (this.readBuffer.length === 0) return;
+      if (this.useBinary && isBinaryFrame(this.readBuffer[0])) {
+        if (this.readBuffer.length < 5) return;
+        const frameLen = this.readBuffer.readUInt32BE(1);
+        if (frameLen > MAX_BINARY_FRAME_BYTES) {
+          socket.destroy();
+          this.transition("offline", { error: "binary frame length exceeds the IPC limit" });
+          return;
+        }
+        if (this.readBuffer.length < 5 + frameLen) return;
+        const payload = this.readBuffer.subarray(5, 5 + frameLen);
+        this.readBuffer = this.readBuffer.subarray(5 + frameLen);
+        let message2;
+        try {
+          message2 = decodeBinaryFrame(payload);
+        } catch {
+          socket.destroy(new Error("invalid binary codebase-index server response"));
+          return;
+        }
+        this.onMessage(message2);
+        continue;
+      }
+      const newline = this.readBuffer.indexOf(10);
+      if (newline < 0) {
+        if (this.readBuffer.length > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
+          socket.destroy(new Error("codebase-index server response exceeds the IPC limit"));
+        }
+        return;
+      }
+      if (newline > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
+        socket.destroy(new Error("codebase-index server response exceeds the IPC limit"));
+        return;
+      }
+      const line = this.readBuffer.subarray(0, newline).toString("utf8");
+      this.readBuffer = this.readBuffer.subarray(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        socket.destroy(new Error("invalid codebase-index server response"));
+        return;
+      }
+      this.onMessage(message);
+    }
+  }
+  onMessage(message) {
+    if (message.type === "hello") {
+      if (message.protocolVersion !== PROJECT_INDEX_SERVER_PROTOCOL_VERSION) {
+        this.rejectStaleServer(
+          message,
+          `codebase-index protocol mismatch: client=${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}, server=${message.protocolVersion}`
+        );
+        return;
+      }
+      const expectedBuildId = projectIndexServerExpectedBuildId();
+      if (expectedBuildId && message.buildId !== expectedBuildId) {
+        this.rejectStaleServer(
+          message,
+          `codebase-index build mismatch: client=${expectedBuildId}, server=${message.buildId ?? "legacy"}`
+        );
+        return;
+      }
+      this.info = message;
+      this.markResponsive();
+      if (message.binarySupported && binaryFramingEnabled()) this.useBinary = true;
+      this.transition("connected", { pid: message.pid });
+      ensureHeartbeatLoop();
+      this.connectResolve?.();
+      return;
+    }
+    if (message.type === "index-state") {
+      this.activity = message.state;
+      this.markResponsive();
+      this.transition("connected", { pid: this.info?.pid });
+      return;
+    }
+    const entry = this.pending.get(message.id);
+    if (!entry) return;
+    this.markResponsive();
+    const status = connectionStates.get(this.endpoint)?.status;
+    if (status === "degraded" || status === "unresponsive") {
+      this.transition("connected", { pid: this.info?.pid });
+    }
+    if (message.type === "progress") {
+      entry.onProgress?.(message.current, message.total);
+      return;
+    }
+    this.pending.delete(message.id);
+    this.cleanupPending(entry);
+    if (message.ok) entry.resolve(message.result);
+    else entry.reject(remoteError(message.error, message.errorName));
+  }
+  onClose(socket) {
+    if (socket !== this.socket) return;
+    const wasConnected = this.info !== null;
+    this.socket = null;
+    this.info = null;
+    this.activity = null;
+    this.health = null;
+    const error = new Error("codebase-index server connection closed");
+    this.connectReject?.(error);
+    this.connectResolve = null;
+    this.connectReject = null;
+    this.rejectPending(error);
+    if (wasConnected) this.transition("error", { error });
+    maybeStopHeartbeatLoop();
+  }
+  cleanupPending(entry) {
+    clearTimeout(entry.timer);
+    if (entry.signal && entry.onAbort) {
+      entry.signal.removeEventListener("abort", entry.onAbort);
+    }
+  }
+  rejectPending(error) {
+    const entries = [...this.pending.values()];
+    this.pending.clear();
+    for (const entry of entries) {
+      this.cleanupPending(entry);
+      entry.reject(error);
+    }
+  }
+  write(message) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed) return;
+    if (this.useBinary) {
+      socket.write(encodeBinaryFrame(message));
+    } else {
+      socket.write(encodeProjectServerMessage(message));
+    }
+  }
+  rejectStaleServer(message, reason) {
+    const socket = this.socket;
+    if (socket && !socket.destroyed) {
+      socket.write(
+        encodeProjectServerMessage({
+          type: "shutdown",
+          id: 0,
+          reason: "stale-build-replacement"
+        })
+      );
+      const timer = setTimeout(() => socket.destroy(), 25);
+      timer.unref?.();
+    }
+    this.connectReject?.(new StaleProjectIndexServerError(reason, message.pid));
+  }
+  spawnDetachedServer() {
+    const url = resolveProjectServerUrl();
+    if (!url) throw new Error("built codebase-index project server is unavailable");
+    if (process.platform !== "win32") {
+      try {
+        fs2.rmSync(this.endpoint, { force: true });
+      } catch {
+      }
+    }
+    const args = [fileURLToPath2(url), "--project-root", this.projectRoot];
+    if (this.indexDir) args.push("--index-dir", this.indexDir);
+    const child = spawn(process.execPath, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: process.env
+    });
+    child.unref();
+  }
+  forceKillKnownServer() {
+    const pid = this.info?.pid;
+    return pid ? this.forceKillServer(pid) : false;
+  }
+  forceKillServer(pid) {
+    if (pid === process.pid) return false;
+    try {
+      process.kill(pid);
+      const metadataPath = projectIndexServerMetadataPath(this.projectRoot, this.indexDir);
+      try {
+        const metadata = JSON.parse(fs2.readFileSync(metadataPath, "utf8"));
+        if (metadata.pid === pid) fs2.rmSync(metadataPath, { force: true });
+      } catch {
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var connections = /* @__PURE__ */ new Map();
+var MAX_CACHED_CONNECTIONS = 8;
+var heartbeatTimer;
+function binaryFramingEnabled() {
+  const flag = process.env["WRONGSTACK_INDEX_BINARY"];
+  return flag === "1" || flag === "true";
+}
+function forgetConnection(endpoint, connection) {
+  if (connections.get(endpoint) === connection) connections.delete(endpoint);
+  connection.close();
+  connectionStates.delete(endpoint);
+  if (latestConnectionState.endpoint !== endpoint) return;
+  setLatestConnectionState(
+    [...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(() => {
+    for (const connection of connections.values()) {
+      if (connection.isConnected()) void connection.checkHealth(false).catch(() => {
+      });
+    }
+  }, SERVER_HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref?.();
+}
+function maybeStopHeartbeatLoop() {
+  if (!heartbeatTimer) return;
+  if ([...connections.values()].some((connection) => connection.isConnected())) return;
+  clearInterval(heartbeatTimer);
+  heartbeatTimer = void 0;
+}
+function connectionFor(projectRoot, indexDir) {
+  const endpoint = projectIndexServerEndpoint(projectRoot, indexDir);
+  let connection = connections.get(endpoint);
+  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) {
+  return connectionFor(args.projectRoot, args.indexDir).call(op, args, options);
+}
+function ensureProjectIndexServer(options) {
+  return connectionFor(options.projectRoot, options.indexDir).configure(
+    options.watchExternal,
+    options.debounceMs,
+    options.coalesceWindowMs
+  );
+}
+function checkProjectIndexServerHealth(projectRoot, indexDir, options = {}) {
+  return connectionFor(projectRoot, indexDir).checkHealth(
+    false,
+    options.timeoutMs ?? SERVER_HEALTH_TIMEOUT_MS
+  );
+}
+async function shutdownProjectIndexServer(projectRoot, indexDir, reason) {
+  const endpoint = projectIndexServerEndpoint(projectRoot, indexDir);
+  const connection = connectionFor(projectRoot, indexDir);
+  try {
+    return await connection.shutdownRemote(reason);
+  } finally {
+    connection.close();
+    connections.delete(endpoint);
+    connectionStates.delete(endpoint);
+  }
+}
+function closeProjectIndexServerClients() {
+  for (const connection of connections.values()) connection.close();
+  connections.clear();
+  connectionStates.clear();
+  setLatestConnectionState({
+    status: isProjectIndexServerAvailable() ? "offline" : "unavailable",
+    connected: false
+  });
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  heartbeatTimer = void 0;
+}
+
+// src/codebase-index/background-indexer.ts
+import * as fs3 from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { Worker } from "node:worker_threads";
+var DEFAULT_FULL_INDEX_TIMEOUT_MS = 24e4;
+var DEFAULT_INCREMENTAL_TIMEOUT_MS = 6e4;
+var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+var _ready = false;
+var _indexing = false;
+var _currentFile = 0;
+var _totalFiles = 0;
+var _lastError = null;
+function isIndexReady() {
+  return _ready;
+}
+function isIndexing() {
+  return _indexing;
+}
+function getIndexState() {
+  const server = getProjectIndexServerConnectionState();
+  const remoteActivity = server.activity;
+  const remoteIndexing = remoteActivity?.indexing ?? false;
+  return {
+    ready: _ready || (remoteActivity?.generation ?? 0) > 0,
+    indexing: _indexing || remoteIndexing,
+    currentFile: remoteIndexing ? remoteActivity?.currentFile ?? 0 : _currentFile,
+    totalFiles: remoteIndexing ? remoteActivity?.totalFiles ?? 0 : _totalFiles,
+    lastError: remoteActivity?.lastError ?? _lastError,
+    server,
+    circuit: indexCircuitBreaker.snapshot()
+  };
+}
+var _listeners = [];
+function onIndexStateChange(listener) {
+  _listeners.push(listener);
+  return () => {
+    _listeners = _listeners.filter((l) => l !== listener);
+  };
+}
+function emitState() {
+  const state = getIndexState();
+  for (const l of _listeners) l(state);
+}
+onProjectIndexServerConnectionStateChange(() => emitState());
+function setIndexProgress(current, total) {
+  _currentFile = current;
+  _totalFiles = total;
+  emitState();
+}
+var worker = null;
+var workerUnavailable = false;
+var nextRpcId = 1;
+var pending = /* @__PURE__ */ new Map();
+function resolveWorkerUrl() {
+  if (process.env["WRONGSTACK_INDEX_INLINE"]) return null;
+  for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
+    try {
+      const url = new URL(rel, import.meta.url);
+      if (url.protocol === "file:" && fs3.existsSync(fileURLToPath3(url))) return url;
+    } catch {
+    }
+  }
+  return null;
+}
+function failAllPending(err) {
+  const entries = [...pending.values()];
+  pending.clear();
+  for (const p of entries) p.reject(err);
+}
+function ensureWorker() {
+  if (worker) return worker;
+  if (workerUnavailable) return null;
+  const url = resolveWorkerUrl();
+  if (!url) {
+    workerUnavailable = true;
+    return null;
+  }
+  try {
+    const w = new Worker(url, { name: "wstack-codebase-index" });
+    w.unref();
+    w.on("message", (msg) => {
+      if (msg.type === "progress") {
+        pending.get(msg.id)?.onProgress?.(msg.current, msg.total);
+        return;
+      }
+      const entry = pending.get(msg.id);
+      if (!entry) return;
+      pending.delete(msg.id);
+      if (msg.ok) entry.resolve(msg.result);
+      else {
+        const error = msg.errorName === "LockError" ? new LockError(msg.error) : new Error(msg.error);
+        if (msg.errorName && msg.errorName !== "Error") {
+          error.name = msg.errorName;
+        }
+        entry.reject(error);
+      }
+    });
+    w.on("error", (err) => {
+      if (worker !== w) return;
+      worker = null;
+      failAllPending(err);
+    });
+    w.on("exit", () => {
+      if (worker !== w) return;
+      worker = null;
+      failAllPending(new Error("codebase-index worker exited"));
+    });
+    worker = w;
+    return w;
+  } catch {
+    workerUnavailable = true;
+    return null;
+  }
+}
+function terminateWorker(reason) {
+  const w = worker;
+  worker = null;
+  failAllPending(reason);
+  if (w) void w.terminate().catch(() => {
+  });
+}
+async function shutdownCodebaseIndexHost() {
+  cancelPendingReindexes();
+  closeProjectIndexServerClients();
+  indexStorePool.closeAll();
+  const w = worker;
+  worker = null;
+  failAllPending(new Error("codebase-index host shut down"));
+  workerUnavailable = false;
+  if (w) {
+    try {
+      await 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(args.projectRoot, args.indexDir);
+  if (availability.kind === "available") {
+    return callProjectIndexServer(op, args, opts);
+  }
+  if (availability.kind === "missing-build") {
+    return Promise.reject(
+      new Error(
+        "Built codebase-index project server is unavailable. Build @wrongstack/tools, or set WRONGSTACK_INDEX_INLINE=1 to explicitly accept a process-local index."
+      )
+    );
+  }
+  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) {
+    return Promise.reject(
+      opts.signal.reason instanceof Error ? opts.signal.reason : new Error("Indexing cancelled")
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const id = nextRpcId++;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      const err = new IndexTimeoutError(
+        `Index ${op} exceeded its ${opts.timeoutMs}ms watchdog timeout`
+      );
+      terminateWorker(err);
+      reject(err);
+    }, opts.timeoutMs);
+    timer.unref?.();
+    const onAbort = () => {
+      w.postMessage({ type: "cancel", id });
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+    };
+    pending.set(id, {
+      resolve: (v) => {
+        cleanup();
+        resolve(v);
+      },
+      reject: (e) => {
+        cleanup();
+        reject(e);
+      },
+      onProgress: opts.onProgress
+    });
+    w.postMessage({ type: "request", id, op, args });
+  });
+}
+async function callInline(op, args, opts) {
+  if (op !== "index" && _indexing) {
+    const error = new Error(
+      "Codebase index refresh in progress; retry after the completed generation is published."
+    );
+    error.name = "IndexRefreshInProgressError";
+    throw error;
+  }
+  const ac = new AbortController();
+  const onOuterAbort = () => ac.abort(opts.signal?.reason ?? new Error("Indexing cancelled"));
+  if (opts.signal?.aborted) onOuterAbort();
+  else opts.signal?.addEventListener("abort", onOuterAbort, { once: true });
+  let timer;
+  const watchdog = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const err = new IndexTimeoutError(
+        `Index ${op} exceeded its ${opts.timeoutMs}ms watchdog timeout`
+      );
+      ac.abort(err);
+      reject(err);
+    }, opts.timeoutMs);
+    timer.unref?.();
+  });
+  const job = async () => {
+    switch (op) {
+      case "index":
+        return await indexService(args, {
+          signal: ac.signal,
+          onProgress: opts.onProgress
+        });
+      case "search":
+        return searchService(args);
+      case "stats":
+        return statsService(args);
+      case "packageGraph":
+        return packageGraphService(args);
+      case "fileGraph":
+        return fileGraphService(args);
+      case "symbolGraph":
+        return symbolGraphService(args);
+      case "incomingCalls":
+        return incomingCallsService(args);
+      case "outgoingCalls":
+        return outgoingCallsService(args);
+      default:
+        throw new Error(`unknown index op: ${String(op)}`);
+    }
+  };
+  try {
+    return await Promise.race([job(), watchdog]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", onOuterAbort);
+  }
+}
+var chain = Promise.resolve();
+function withMutex(job) {
+  const run = chain.then(job, job);
+  chain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+function circuitOpenError() {
+  const c = indexCircuitBreaker.snapshot();
+  return new CircuitOpenError(
+    "Codebase indexing is temporarily paused after repeated failures" + (c.lastFailure ? ` (last: ${c.lastFailure})` : "") + (c.cooldownRemainingMs > 0 ? `; auto-retry in ${Math.ceil(c.cooldownRemainingMs / 1e3)}s` : "") + ". Use /codebase-reindex to retry now."
+  );
+}
+var DEFAULT_DEBOUNCE_MS = 400;
+var DEFAULT_COALESCE_WINDOW_MS = 50;
+var debounceTimers = /* @__PURE__ */ new Map();
+var readyReindexBatches = /* @__PURE__ */ new Map();
+function debounceKey(projectRoot, indexDir, file) {
+  return JSON.stringify([projectRoot, indexDir ?? "", file]);
+}
+function reindexBatchKey(projectRoot, indexDir) {
+  return JSON.stringify([projectRoot, indexDir ?? ""]);
+}
+function flushReadyReindexBatch(key) {
+  const batch = readyReindexBatches.get(key);
+  if (!batch) return;
+  readyReindexBatches.delete(key);
+  if (!indexCircuitBreaker.allowRequest()) {
+    const error = circuitOpenError();
+    for (const onError of batch.onErrors) onError(error);
+    return;
+  }
+  void withMutex(
+    () => callIndexOp(
+      "index",
+      {
+        projectRoot: batch.projectRoot,
+        files: [...batch.files].sort(),
+        indexDir: batch.indexDir
+      },
+      { timeoutMs: batch.timeoutMs }
+    )
+  ).then(
+    () => indexCircuitBreaker.recordSuccess(),
+    (err) => {
+      indexCircuitBreaker.recordFailure(err);
+      for (const onError of batch.onErrors) onError(err);
+    }
+  );
+}
+function addReadyReindex(opts) {
+  const key = reindexBatchKey(opts.projectRoot, opts.indexDir);
+  const windowMs = opts.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS;
+  const existing = readyReindexBatches.get(key);
+  if (existing) {
+    existing.files.add(opts.file);
+    existing.timeoutMs = Math.max(existing.timeoutMs, opts.timeoutMs);
+    if (opts.onError) existing.onErrors.add(opts.onError);
+    if (windowMs > 0 && existing.flush) {
+      clearTimeout(existing.flush);
+      existing.flush = setTimeout(() => flushReadyReindexBatch(key), windowMs);
+      existing.flush.unref?.();
+    }
+    return;
+  }
+  const batch = {
+    projectRoot: opts.projectRoot,
+    indexDir: opts.indexDir,
+    files: /* @__PURE__ */ new Set([opts.file]),
+    timeoutMs: opts.timeoutMs,
+    onErrors: new Set(opts.onError ? [opts.onError] : [])
+  };
+  batch.flush = setTimeout(() => flushReadyReindexBatch(key), Math.max(0, windowMs));
+  batch.flush.unref?.();
+  readyReindexBatches.set(key, batch);
+}
+function isIndexableFile(filePath) {
+  return isIndexablePath(filePath);
+}
+function isRecoverableConstraintError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("unique constraint") || msg.includes("constraint failed");
+  }
+  return false;
+}
+async function runStartupIndex(opts) {
+  if (!indexCircuitBreaker.allowRequest()) throw circuitOpenError();
+  _indexing = true;
+  emitState();
+  try {
+    const result = await withMutex(() => {
+      _currentFile = 0;
+      _totalFiles = 0;
+      _lastError = null;
+      return callIndexOp(
+        "index",
+        {
+          projectRoot: opts.projectRoot,
+          indexDir: opts.indexDir,
+          force: opts.force,
+          langs: opts.langs
+        },
+        {
+          timeoutMs: opts.timeoutMs ?? DEFAULT_FULL_INDEX_TIMEOUT_MS,
+          signal: opts.signal,
+          onProgress: setIndexProgress
+        }
+      );
+    });
+    _ready = true;
+    indexCircuitBreaker.recordSuccess();
+    return result;
+  } catch (err) {
+    _lastError = err instanceof Error ? err.message : String(err);
+    const originalError = _lastError;
+    if (isRecoverableConstraintError(err) && !opts.force) {
+      _lastError = null;
+      const rebuildResult = await runStartupIndex({
+        ...opts,
+        force: true
+      });
+      _ready = true;
+      return {
+        ...rebuildResult,
+        autoRecovered: { failure: originalError, rebuiltWithForce: true }
+      };
+    }
+    _ready = true;
+    if (!opts.signal?.aborted) indexCircuitBreaker.recordFailure(err);
+    throw err;
+  } finally {
+    _indexing = false;
+    emitState();
+  }
+}
+function enqueueReindex(opts) {
+  const files = opts.files.filter(isIndexableFile);
+  if (files.length === 0) return;
+  const ms = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  for (const file of files) {
+    const key = debounceKey(opts.projectRoot, opts.indexDir, file);
+    const existing = debounceTimers.get(key);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      debounceTimers.delete(key);
+      addReadyReindex({
+        projectRoot: opts.projectRoot,
+        file,
+        indexDir: opts.indexDir,
+        timeoutMs: opts.timeoutMs ?? DEFAULT_INCREMENTAL_TIMEOUT_MS,
+        onError: opts.onError,
+        coalesceWindowMs: opts.coalesceWindowMs
+      });
+    }, ms);
+    timer.unref?.();
+    debounceTimers.set(key, timer);
+  }
+}
+function cancelPendingReindexes() {
+  for (const t of debounceTimers.values()) clearTimeout(t);
+  debounceTimers.clear();
+  for (const batch of readyReindexBatches.values()) {
+    if (batch.flush) clearTimeout(batch.flush);
+  }
+  readyReindexBatches.clear();
+}
+async function searchCodebaseIndex(args, opts = {}) {
+  return callIndexOp("search", args, {
+    timeoutMs: opts.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    signal: opts.signal
+  });
+}
+async function codebaseIndexStats(args, opts = {}) {
+  return callIndexOp("stats", args, {
+    timeoutMs: opts.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    signal: opts.signal
+  });
+}
+async function packageGraphService2(args) {
+  return callIndexOp("packageGraph", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+async function fileGraphService2(args) {
+  return callIndexOp("fileGraph", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+async function symbolGraphService2(args) {
+  return callIndexOp("symbolGraph", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+async function incomingCallsService2(args) {
+  return callIndexOp("incomingCalls", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+async function outgoingCallsService2(args) {
+  return callIndexOp("outgoingCalls", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+function shutdownCodebaseIndexServer(projectRoot, indexDir, reason) {
+  return shutdownProjectIndexServer(projectRoot, indexDir, reason);
+}
+function checkCodebaseIndexServerHealth(projectRoot, indexDir, options = {}) {
+  return checkProjectIndexServerHealth(projectRoot, indexDir, options);
+}
+function ensureCodebaseIndexServer(options) {
+  const availability = resolveProjectIndexDaemonAvailability(options.projectRoot, options.indexDir);
+  if (availability.kind !== "available") {
+    if (availability.kind === "endpoint-invalid") warnEndpointInvalidOnce(availability);
+    return Promise.resolve();
+  }
+  return ensureProjectIndexServer({
+    projectRoot: options.projectRoot,
+    indexDir: options.indexDir,
+    watchExternal: options.watchExternal ?? false,
+    debounceMs: options.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+    coalesceWindowMs: options.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS
+  });
+}
+
+export {
+  resolveProjectIndexDaemonAvailability,
+  isIndexReady,
+  isIndexing,
+  getIndexState,
+  onIndexStateChange,
+  shutdownCodebaseIndexHost,
+  isIndexableFile,
+  runStartupIndex,
+  enqueueReindex,
+  cancelPendingReindexes,
+  searchCodebaseIndex,
+  codebaseIndexStats,
+  packageGraphService2 as packageGraphService,
+  fileGraphService2 as fileGraphService,
+  symbolGraphService2 as symbolGraphService,
+  incomingCallsService2 as incomingCallsService,
+  outgoingCallsService2 as outgoingCallsService,
+  shutdownCodebaseIndexServer,
+  checkCodebaseIndexServerHealth,
+  ensureCodebaseIndexServer
+};
+//# sourceMappingURL=chunk-HYX2TZ7O.js.map