@wrongstack/tools 0.320.1 → 1.0.0

package/dist/codebase-index/project-server.js

@@ -10,7 +10,7 @@ import {
   projectIndexServerBuildId,
   projectIndexServerEndpoint,
   projectIndexServerMetadataPath
-} from "../chunk-PV6HIZQD.js";
+} from "../chunk-GDDXX27P.js";
 import {
   fileGraphService,
   incomingCallsService,
@@ -22,7 +22,7 @@ import {
   searchService,
   statsService,
   symbolGraphService
-} from "../chunk-J43O3BOX.js";
+} from "../chunk-N3K2SFEI.js";
 import "../chunk-NU2IZ72J.js";
 import "../chunk-VVZPQPTY.js";
 import "../chunk-6IEBD27U.js";
@@ -30,22 +30,147 @@ import "../chunk-UCYQTZ7F.js";
 import {
   isIndexablePath
 } from "../chunk-YOHO4DVT.js";
-import "../chunk-DTQ75VBC.js";
+import "../chunk-2CTZW6JQ.js";
 import "../chunk-KE7A76VC.js";
 
 // src/codebase-index/project-server.ts
 import { randomBytes } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as net from "node:net";
+import * as path3 from "node:path";
+import { startSharedHeapWatchdog, useDaemonPerfDefaults } from "@wrongstack/core/utils";
+import { bindProjectEndpoint } from "@wrongstack/persistence";
+
+// src/codebase-index/project-server-framing.ts
+var MAX_CLIENT_WRITE_BUFFER_BYTES = 8 * 1024 * 1024;
+function sendServerMessage(state, message) {
+  if (state.socket.destroyed) return;
+  if (state.socket.writableLength > MAX_CLIENT_WRITE_BUFFER_BYTES) {
+    state.socket.destroy(new Error("Index client fell too far behind on reads"));
+    return;
+  }
+  state.socket.write(
+    state.binary ? encodeBinaryFrame(message) : encodeProjectServerMessage(message)
+  );
+}
+function consumeClientChunk(state, chunk, onMessage) {
+  const buffer = state.buffer.length === 0 ? chunk : Buffer.concat([state.buffer, chunk]);
+  let scan = 0;
+  while (true) {
+    if (buffer.length - scan === 0) break;
+    if (isBinaryFrame(buffer[scan])) {
+      if (buffer.length - scan < 5) break;
+      const frameLen = buffer.readUInt32BE(scan + 1);
+      if (frameLen > MAX_INBOUND_BINARY_FRAME_BYTES) {
+        state.buffer = Buffer.alloc(0);
+        state.socket.destroy(new Error("codebase-index client binary frame exceeds the IPC limit"));
+        return;
+      }
+      if (buffer.length - scan < 5 + frameLen) break;
+      const payload = buffer.subarray(scan + 5, scan + 5 + frameLen);
+      let message2;
+      try {
+        message2 = decodeBinaryFrame(payload);
+      } catch {
+        state.buffer = Buffer.alloc(0);
+        state.socket.destroy(new Error("invalid codebase-index client binary frame"));
+        return;
+      }
+      scan += 5 + frameLen;
+      state.binary = true;
+      state.lastSeenAt = Date.now();
+      onMessage(state, message2);
+      continue;
+    }
+    const newline = buffer.indexOf(10, scan);
+    if (newline < 0) {
+      if (buffer.length - scan > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
+        state.buffer = Buffer.alloc(0);
+        state.socket.destroy(new Error("codebase-index client message exceeds the IPC limit"));
+        return;
+      }
+      break;
+    }
+    if (newline - scan > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
+      state.buffer = Buffer.alloc(0);
+      state.socket.destroy(new Error("codebase-index client message exceeds the IPC limit"));
+      return;
+    }
+    const line = buffer.subarray(scan, newline).toString("utf8");
+    scan = newline + 1;
+    if (!line) continue;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      state.buffer = Buffer.alloc(0);
+      state.socket.destroy(new Error("invalid codebase-index client message"));
+      return;
+    }
+    state.lastSeenAt = Date.now();
+    onMessage(state, message);
+  }
+  state.buffer = scan === 0 ? buffer : Buffer.from(buffer.subarray(scan));
+}
+
+// src/codebase-index/project-server-lifecycle.ts
+import * as fs from "node:fs";
 import * as path from "node:path";
+import process2 from "node:process";
 import { restrictFilePermissions } from "@wrongstack/core/security";
-import {
-  DEFAULT_WALK_IGNORE_SET,
-  startSharedHeapWatchdog,
-  useDaemonPerfDefaults,
-  watchProjectTree
-} from "@wrongstack/core/utils";
-import { atomicWrite, bindProjectEndpoint } from "@wrongstack/persistence";
+import { atomicWrite } from "@wrongstack/persistence";
+function removeMetadataIfOwned(metadataPath2, pid) {
+  try {
+    const current = JSON.parse(fs.readFileSync(metadataPath2, "utf8"));
+    if (current.pid === pid) fs.rmSync(metadataPath2, { force: true });
+  } catch {
+  }
+}
+async function writeProjectServerMetadata(metadataPath2, metadata) {
+  fs.mkdirSync(path.dirname(metadataPath2), { recursive: true });
+  await atomicWrite(metadataPath2, `${JSON.stringify(metadata, null, 2)}
+`, { mode: 384 });
+  await restrictFilePermissions(metadataPath2, {
+    label: "codebase-index-metadata",
+    warn: (message) => process2.stderr.write(`${message}
+`)
+  });
+}
+var SIGNAL_GUARD = /* @__PURE__ */ Symbol.for(
+  "wrongstack.codebase-index.project-server.signalGuard"
+);
+function armCodebaseIndexSignalGuard(stop2) {
+  const signalGuardStore = globalThis;
+  let guard = signalGuardStore[SIGNAL_GUARD];
+  if (!guard) {
+    let current = async () => void 0;
+    let armed = false;
+    const handlers = /* @__PURE__ */ new Map();
+    const disarm = () => {
+      if (!armed) return;
+      armed = false;
+      for (const [signal, handler] of handlers) process2.removeListener(signal, handler);
+      handlers.clear();
+    };
+    guard = {
+      arm(next) {
+        current = next;
+        if (armed) return;
+        armed = true;
+        for (const signal of ["SIGINT", "SIGTERM"]) {
+          const handler = () => {
+            disarm();
+            void current(signal);
+          };
+          handlers.set(signal, handler);
+          process2.on(signal, handler);
+        }
+      }
+    };
+    signalGuardStore[SIGNAL_GUARD] = guard;
+  }
+  guard.arm(stop2);
+}
 
 // src/codebase-index/project-server-cache.ts
 var GenerationLruCache = class {
@@ -155,6 +280,262 @@ var ServerQueryCaches = class {
   }
 };
 
+// src/codebase-index/project-server-operations.ts
+function preservesQueryCaches(args) {
+  return !args.force && args.files !== void 0 && args.files.length > 0;
+}
+function isShareableFullIndex(args) {
+  return !args.force && (!args.files || args.files.length === 0) && (!args.langs || args.langs.length === 0) && (!args.ignore || args.ignore.length === 0);
+}
+function fixedArgs(ctx, args) {
+  return { ...args, projectRoot: ctx.projectRoot, indexDir: ctx.indexDir };
+}
+async function runFullIndex(ctx, state, id, args) {
+  const subscriber = { state, id };
+  let active = ctx.getActiveFullIndex();
+  if (!active) {
+    const controller = new AbortController();
+    const subscribers = /* @__PURE__ */ new Set([subscriber]);
+    const promise = ctx.withIndexWrite(
+      (reportProgress) => indexService(fixedArgs(ctx, args), {
+        signal: controller.signal,
+        onProgress: (current, total) => {
+          reportProgress(current, total);
+          for (const item of subscribers) {
+            if (!item.state.cancelled.has(item.id)) {
+              ctx.send(item.state, { type: "progress", id: item.id, current, total });
+            }
+          }
+        }
+      }),
+      // Shareable full index: whole-index scope, caches drop on completion.
+      { preserveCaches: false }
+    );
+    active = { promise, controller, subscribers };
+    ctx.setActiveFullIndex(active);
+    void promise.finally(() => {
+      if (ctx.getActiveFullIndex() === active) ctx.setActiveFullIndex(null);
+    }).catch(() => {
+    });
+  } else {
+    active.subscribers.add(subscriber);
+  }
+  const selected = active;
+  state.cancel.set(id, () => {
+    state.cancelled.add(id);
+    selected.subscribers.delete(subscriber);
+    if (selected.subscribers.size === 0) {
+      selected.controller.abort(new Error("Indexing cancelled"));
+    }
+  });
+  try {
+    return await selected.promise;
+  } finally {
+    selected.subscribers.delete(subscriber);
+  }
+}
+async function dispatchOperation(ctx, state, message) {
+  const { id, op } = message;
+  const indexActivity2 = ctx.getActivity();
+  switch (op) {
+    case "index": {
+      const args = message.args;
+      if (isShareableFullIndex(args)) return runFullIndex(ctx, state, id, args);
+      const controller = new AbortController();
+      state.cancel.set(id, () => {
+        state.cancelled.add(id);
+        controller.abort(new Error("Indexing cancelled"));
+      });
+      return ctx.withIndexWrite(
+        (reportProgress) => indexService(fixedArgs(ctx, args), {
+          signal: controller.signal,
+          onProgress: (current, total) => {
+            reportProgress(current, total);
+            if (!state.cancelled.has(id)) {
+              ctx.send(state, { type: "progress", id, current, total });
+            }
+          }
+        }),
+        { preserveCaches: preservesQueryCaches(args) }
+      );
+    }
+    case "search": {
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.searchCache,
+        JSON.stringify(message.args),
+        indexActivity2,
+        () => searchService(fixedArgs(ctx, message.args))
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    case "stats":
+      if (indexActivity2.indexing) {
+        throw indexRefreshInProgressError(indexActivity2.currentFile, indexActivity2.totalFiles);
+      }
+      return staleAwareRead(
+        ctx.queryCaches.statsCache,
+        "stats",
+        indexActivity2,
+        () => statsService(fixedArgs(ctx, message.args))
+      ).value;
+    case "packageGraph": {
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.packageGraphCache,
+        "package",
+        indexActivity2,
+        () => packageGraphService(fixedArgs(ctx, message.args))
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    case "fileGraph": {
+      const key = message.args.packageFilter;
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.fileGraphCache,
+        key,
+        indexActivity2,
+        () => fileGraphService(fixedArgs(ctx, message.args))
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    case "symbolGraph": {
+      const key = message.args.fileFilter;
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.symbolGraphCache,
+        key,
+        indexActivity2,
+        () => symbolGraphService(fixedArgs(ctx, message.args))
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    case "incomingCalls": {
+      const callArgs = fixedArgs(ctx, message.args);
+      const cacheKey = JSON.stringify([
+        callArgs.symbol,
+        callArgs.file ?? "",
+        callArgs.limit ?? 100,
+        callArgs.transitive ?? false
+      ]);
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.incomingCallsCache,
+        cacheKey,
+        indexActivity2,
+        () => incomingCallsService(callArgs)
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    case "outgoingCalls": {
+      const callArgs = fixedArgs(ctx, message.args);
+      const cacheKey = JSON.stringify([
+        callArgs.symbol,
+        callArgs.file ?? "",
+        callArgs.limit ?? 100,
+        callArgs.transitive ?? false
+      ]);
+      const { value, stale } = staleAwareRead(
+        ctx.queryCaches.outgoingCallsCache,
+        cacheKey,
+        indexActivity2,
+        () => outgoingCallsService(callArgs)
+      );
+      return stale ? { ...value, stale: true } : value;
+    }
+    default:
+      throw new Error(`unknown index operation: ${String(op)}`);
+  }
+}
+
+// src/codebase-index/project-server-watcher.ts
+import * as path2 from "node:path";
+import {
+  DEFAULT_WALK_IGNORE_SET,
+  watchProjectTree
+} from "@wrongstack/core/utils";
+var DEFAULT_EXTERNAL_DEBOUNCE_MS = 400;
+var DEFAULT_EXTERNAL_COALESCE_WINDOW_MS = 50;
+function isIgnoredRelativePath(relativePath) {
+  return relativePath.split(/[/\\]/u).some((segment) => DEFAULT_WALK_IGNORE_SET.has(segment));
+}
+var ProjectServerWatcherManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  externalWatcher;
+  externalDebounceMs = DEFAULT_EXTERNAL_DEBOUNCE_MS;
+  externalCoalesceWindowMs = DEFAULT_EXTERNAL_COALESCE_WINDOW_MS;
+  externalDebounceTimers = /* @__PURE__ */ new Map();
+  externalReadyFiles = /* @__PURE__ */ new Set();
+  externalReadyFlush;
+  get isWatching() {
+    return this.externalWatcher !== void 0;
+  }
+  get pendingFileCount() {
+    return this.externalDebounceTimers.size + this.externalReadyFiles.size;
+  }
+  enqueueExternalFile(file) {
+    const previous = this.externalDebounceTimers.get(file);
+    if (previous) clearTimeout(previous);
+    const timer = setTimeout(() => {
+      this.externalDebounceTimers.delete(file);
+      this.externalReadyFiles.add(file);
+      if (this.externalReadyFlush) clearTimeout(this.externalReadyFlush);
+      this.externalReadyFlush = setTimeout(() => {
+        this.externalReadyFlush = void 0;
+        const files = [...this.externalReadyFiles].sort();
+        this.externalReadyFiles.clear();
+        this.options.onFilesChanged(files);
+      }, this.externalCoalesceWindowMs);
+      this.externalReadyFlush.unref?.();
+    }, this.externalDebounceMs);
+    timer.unref?.();
+    this.externalDebounceTimers.set(file, timer);
+  }
+  ensureExternalWatcher() {
+    if (this.externalWatcher) return;
+    const projectRoot2 = this.options.projectRoot;
+    this.externalWatcher = watchProjectTree(
+      projectRoot2,
+      ({ filename }) => {
+        if (!filename || isIgnoredRelativePath(filename)) return;
+        const absolute = path2.resolve(projectRoot2, filename);
+        const relative2 = path2.relative(projectRoot2, absolute);
+        if (relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2) || !isIndexablePath(absolute)) {
+          return;
+        }
+        this.enqueueExternalFile(absolute);
+      },
+      {
+        onError: () => {
+        }
+      }
+    );
+  }
+  stop() {
+    try {
+      this.externalWatcher?.close();
+    } catch {
+    }
+    this.externalWatcher = void 0;
+    for (const timer of this.externalDebounceTimers.values()) clearTimeout(timer);
+    this.externalDebounceTimers.clear();
+    if (this.externalReadyFlush) clearTimeout(this.externalReadyFlush);
+    this.externalReadyFlush = void 0;
+    this.externalReadyFiles.clear();
+  }
+  reconcile(clients2) {
+    const owners = [...clients2].filter((client) => client.watchExternal);
+    if (owners.length === 0) {
+      this.externalDebounceMs = DEFAULT_EXTERNAL_DEBOUNCE_MS;
+      this.externalCoalesceWindowMs = DEFAULT_EXTERNAL_COALESCE_WINDOW_MS;
+      this.stop();
+      return;
+    }
+    this.externalDebounceMs = Math.min(...owners.map((client) => client.debounceMs));
+    this.externalCoalesceWindowMs = Math.min(...owners.map((client) => client.coalesceWindowMs));
+    this.ensureExternalWatcher();
+  }
+};
+
 // src/codebase-index/wal-maintenance.ts
 var DEFAULT_IDLE_MS = 3e4;
 var DEFAULT_OPTIMIZE_EVERY = 8;
@@ -235,8 +616,8 @@ function parseArgs(argv) {
   }
   if (!projectRoot2) throw new Error("codebase-index project server requires --project-root");
   return {
-    projectRoot: path.resolve(projectRoot2),
-    ...indexDir2 ? { indexDir: path.resolve(indexDir2) } : {}
+    projectRoot: path3.resolve(projectRoot2),
+    ...indexDir2 ? { indexDir: path3.resolve(indexDir2) } : {}
   };
 }
 useDaemonPerfDefaults();
@@ -245,16 +626,18 @@ var projectRoot = parsed.projectRoot;
 var indexDir = resolveIndexDir(projectRoot, parsed.indexDir);
 var endpoint = projectIndexServerEndpoint(projectRoot, indexDir);
 var metadataPath = projectIndexServerMetadataPath(projectRoot, indexDir);
-var idleMsRaw = Number(process.env["WRONGSTACK_INDEX_SERVER_IDLE_MS"]);
+var idleMsRaw = Number(process.env["WRONGSTACK_INDEX_SERVER_IDLE_MS"]?.replaceAll("_", ""));
 var idleMs = Number.isFinite(idleMsRaw) && idleMsRaw >= 100 ? idleMsRaw : DEFAULT_IDLE_MS2;
-var clientLeaseMsRaw = Number(process.env["WRONGSTACK_INDEX_SERVER_CLIENT_LEASE_MS"]);
+var clientLeaseMsRaw = Number(
+  process.env["WRONGSTACK_INDEX_SERVER_CLIENT_LEASE_MS"]?.replaceAll("_", "")
+);
 var clientLeaseMs = Number.isFinite(clientLeaseMsRaw) && clientLeaseMsRaw >= 100 ? clientLeaseMsRaw : DEFAULT_CLIENT_LEASE_MS;
 var clientLeaseSweepMs = Math.min(1e4, Math.max(100, Math.floor(clientLeaseMs / 3)));
 var startedAt = (/* @__PURE__ */ new Date()).toISOString();
 var authToken = randomBytes(16).toString("hex");
 var markMetadataWritten;
-var metadataWritten = new Promise((resolve2) => {
-  markMetadataWritten = resolve2;
+var metadataWritten = new Promise((resolve3) => {
+  markMetadataWritten = resolve3;
 });
 var serverInfo = {
   protocolVersion: PROJECT_INDEX_SERVER_PROTOCOL_VERSION,
@@ -269,7 +652,7 @@ var serverInfo = {
   // mirrors per-frame, so JSON-only clients keep working unchanged.
   binarySupported: true
 };
-process.title = `wrongstack-codebase-index:${path.basename(projectRoot)}`;
+process.title = `wrongstack-codebase-index:${path3.basename(projectRoot)}`;
 var clients = /* @__PURE__ */ new Set();
 var idleTimer;
 var stopping = false;
@@ -298,14 +681,6 @@ var stopMemoryWatchdog = startSharedHeapWatchdog({
   })
 });
 var lastProgressBroadcastAt = 0;
-var externalWatcher;
-var DEFAULT_EXTERNAL_DEBOUNCE_MS = 400;
-var DEFAULT_EXTERNAL_COALESCE_WINDOW_MS = 50;
-var externalDebounceMs = DEFAULT_EXTERNAL_DEBOUNCE_MS;
-var externalCoalesceWindowMs = DEFAULT_EXTERNAL_COALESCE_WINDOW_MS;
-var externalDebounceTimers = /* @__PURE__ */ new Map();
-var externalReadyFiles = /* @__PURE__ */ new Set();
-var externalReadyFlush;
 function clearQueryCaches() {
   queryCaches.clear();
 }
@@ -328,16 +703,8 @@ var walMaintenance = new WalMaintenance({
     }
   }
 });
-var MAX_CLIENT_WRITE_BUFFER_BYTES = 8 * 1024 * 1024;
 function send(state, message) {
-  if (state.socket.destroyed) return;
-  if (state.socket.writableLength > MAX_CLIENT_WRITE_BUFFER_BYTES) {
-    state.socket.destroy(new Error("Index client fell too far behind on reads"));
-    return;
-  }
-  state.socket.write(
-    state.binary ? encodeBinaryFrame(message) : encodeProjectServerMessage(message)
-  );
+  sendServerMessage(state, message);
 }
 function withWriteMutex(job) {
   queuedWrites++;
@@ -357,6 +724,25 @@ function withWriteMutex(job) {
   );
   return run;
 }
+var watcherManager = new ProjectServerWatcherManager({
+  projectRoot,
+  onFilesChanged: (files) => {
+    void withIndexWrite(
+      (onProgress) => indexService(
+        {
+          projectRoot,
+          indexDir,
+          files
+        },
+        { onProgress }
+      ),
+      // Watcher runs are targeted file lists — keep the caches so the next
+      // refresh's stale-serve window has previous-generation answers.
+      { preserveCaches: true }
+    ).catch(() => {
+    });
+  }
+});
 function serverHealth() {
   const memory = process.memoryUsage();
   const now = Date.now();
@@ -380,8 +766,8 @@ function serverHealth() {
     activeRequests,
     activeWrites,
     queuedWrites,
-    pendingExternalFiles: externalDebounceTimers.size + externalReadyFiles.size,
-    watchingExternal: externalWatcher !== void 0,
+    pendingExternalFiles: watcherManager.pendingFileCount,
+    watchingExternal: watcherManager.isWatching,
     watchingClients,
     clientLeaseTimeoutMs: clientLeaseMs,
     oldestClientIdleMs,
@@ -401,9 +787,6 @@ function reportIndexProgress(currentFile, totalFiles) {
     broadcastIndexActivity();
   }
 }
-function preservesQueryCaches(args) {
-  return !args.force && args.files !== void 0 && args.files.length > 0;
-}
 function withIndexWrite(job, options) {
   return withWriteMutex(async () => {
     indexActivity = {
@@ -443,162 +826,18 @@ function withIndexWrite(job, options) {
     }
   });
 }
-function fixedArgs(args) {
-  return { ...args, projectRoot, indexDir };
-}
-function isShareableFullIndex(args) {
-  return !args.force && (!args.files || args.files.length === 0) && (!args.langs || args.langs.length === 0) && (!args.ignore || args.ignore.length === 0);
-}
-async function runFullIndex(state, id, args) {
-  const subscriber = { state, id };
-  let active = activeFullIndex;
-  if (!active) {
-    const controller = new AbortController();
-    const subscribers = /* @__PURE__ */ new Set([subscriber]);
-    const promise = withIndexWrite(
-      (reportProgress) => indexService(fixedArgs(args), {
-        signal: controller.signal,
-        onProgress: (current, total) => {
-          reportProgress(current, total);
-          for (const item of subscribers) {
-            if (!item.state.cancelled.has(item.id)) {
-              send(item.state, { type: "progress", id: item.id, current, total });
-            }
-          }
-        }
-      }),
-      // Shareable full index: whole-index scope, caches drop on completion.
-      { preserveCaches: false }
-    );
-    active = { promise, controller, subscribers };
+var operationContext = {
+  projectRoot,
+  indexDir,
+  queryCaches,
+  getActivity: () => indexActivity,
+  withIndexWrite,
+  send,
+  getActiveFullIndex: () => activeFullIndex,
+  setActiveFullIndex: (active) => {
     activeFullIndex = active;
-    void promise.finally(() => {
-      if (activeFullIndex === active) activeFullIndex = null;
-    }).catch(() => {
-    });
-  } else {
-    active.subscribers.add(subscriber);
-  }
-  const selected = active;
-  state.cancel.set(id, () => {
-    state.cancelled.add(id);
-    selected.subscribers.delete(subscriber);
-    if (selected.subscribers.size === 0) {
-      selected.controller.abort(new Error("Indexing cancelled"));
-    }
-  });
-  try {
-    return await selected.promise;
-  } finally {
-    selected.subscribers.delete(subscriber);
   }
-}
-async function dispatchOperation(state, message) {
-  const { id, op } = message;
-  switch (op) {
-    case "index": {
-      const args = message.args;
-      if (isShareableFullIndex(args)) return runFullIndex(state, id, args);
-      const controller = new AbortController();
-      state.cancel.set(id, () => {
-        state.cancelled.add(id);
-        controller.abort(new Error("Indexing cancelled"));
-      });
-      return withIndexWrite(
-        (reportProgress) => indexService(fixedArgs(args), {
-          signal: controller.signal,
-          onProgress: (current, total) => {
-            reportProgress(current, total);
-            if (!state.cancelled.has(id)) send(state, { type: "progress", id, current, total });
-          }
-        }),
-        { preserveCaches: preservesQueryCaches(args) }
-      );
-    }
-    case "search": {
-      const { value, stale } = staleAwareRead(
-        queryCaches.searchCache,
-        JSON.stringify(message.args),
-        indexActivity,
-        () => searchService(fixedArgs(message.args))
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    case "stats":
-      if (indexActivity.indexing) {
-        throw indexRefreshInProgressError(indexActivity.currentFile, indexActivity.totalFiles);
-      }
-      return staleAwareRead(
-        queryCaches.statsCache,
-        "stats",
-        indexActivity,
-        () => statsService(fixedArgs(message.args))
-      ).value;
-    case "packageGraph": {
-      const { value, stale } = staleAwareRead(
-        queryCaches.packageGraphCache,
-        "package",
-        indexActivity,
-        () => packageGraphService(fixedArgs(message.args))
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    case "fileGraph": {
-      const key = message.args.packageFilter;
-      const { value, stale } = staleAwareRead(
-        queryCaches.fileGraphCache,
-        key,
-        indexActivity,
-        () => fileGraphService(fixedArgs(message.args))
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    case "symbolGraph": {
-      const key = message.args.fileFilter;
-      const { value, stale } = staleAwareRead(
-        queryCaches.symbolGraphCache,
-        key,
-        indexActivity,
-        () => symbolGraphService(fixedArgs(message.args))
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    case "incomingCalls": {
-      const callArgs = fixedArgs(message.args);
-      const cacheKey = JSON.stringify([
-        callArgs.symbol,
-        callArgs.file ?? "",
-        callArgs.limit ?? 100,
-        callArgs.transitive ?? false
-      ]);
-      const { value, stale } = staleAwareRead(
-        queryCaches.incomingCallsCache,
-        cacheKey,
-        indexActivity,
-        () => incomingCallsService(callArgs)
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    case "outgoingCalls": {
-      const callArgs = fixedArgs(message.args);
-      const cacheKey = JSON.stringify([
-        callArgs.symbol,
-        callArgs.file ?? "",
-        callArgs.limit ?? 100,
-        callArgs.transitive ?? false
-      ]);
-      const { value, stale } = staleAwareRead(
-        queryCaches.outgoingCallsCache,
-        cacheKey,
-        indexActivity,
-        () => outgoingCallsService(callArgs)
-      );
-      return stale ? { ...value, stale: true } : value;
-    }
-    default:
-      throw new Error(`unknown index operation: ${String(op)}`);
-  }
-}
+};
 async function handleMessage(state, message) {
   if (message.type === "cancel") {
     state.cancel.get(message.id)?.();
@@ -629,13 +868,13 @@ async function handleMessage(state, message) {
         0,
         message.coalesceWindowMs ?? DEFAULT_EXTERNAL_COALESCE_WINDOW_MS
       );
-      reconcileExternalWatcher();
+      watcherManager.reconcile(clients);
       send(state, {
         type: "response",
         id: message.id,
         ok: true,
         result: {
-          watching: externalWatcher !== void 0,
+          watching: watcherManager.isWatching,
           health: serverHealth()
         }
       });
@@ -644,7 +883,7 @@ async function handleMessage(state, message) {
       state.debounceMs = previousDebounceMs;
       state.coalesceWindowMs = previousCoalesceWindowMs;
       try {
-        reconcileExternalWatcher();
+        watcherManager.reconcile(clients);
       } catch {
       }
       send(state, {
@@ -669,7 +908,7 @@ async function handleMessage(state, message) {
   }
   activeRequests++;
   try {
-    const result = await dispatchOperation(state, message);
+    const result = await dispatchOperation(operationContext, state, message);
     if (!state.cancelled.has(message.id)) {
       send(state, { type: "response", id: message.id, ok: true, result });
     }
@@ -689,141 +928,8 @@ async function handleMessage(state, message) {
     state.cancelled.delete(message.id);
   }
 }
-function isIgnoredRelativePath(relativePath) {
-  return relativePath.split(/[/\\]/u).some((segment) => DEFAULT_WALK_IGNORE_SET.has(segment));
-}
-function enqueueExternalFile(file) {
-  const previous = externalDebounceTimers.get(file);
-  if (previous) clearTimeout(previous);
-  const timer = setTimeout(() => {
-    externalDebounceTimers.delete(file);
-    externalReadyFiles.add(file);
-    if (externalReadyFlush) clearTimeout(externalReadyFlush);
-    externalReadyFlush = setTimeout(() => {
-      externalReadyFlush = void 0;
-      const files = [...externalReadyFiles].sort();
-      externalReadyFiles.clear();
-      void withIndexWrite(
-        (onProgress) => indexService(
-          {
-            projectRoot,
-            indexDir,
-            files
-          },
-          { onProgress }
-        ),
-        // Watcher runs are targeted file lists — keep the caches so the next
-        // refresh's stale-serve window has previous-generation answers.
-        { preserveCaches: true }
-      ).catch(() => {
-      });
-    }, externalCoalesceWindowMs);
-    externalReadyFlush.unref?.();
-  }, externalDebounceMs);
-  timer.unref?.();
-  externalDebounceTimers.set(file, timer);
-}
-function ensureExternalWatcher() {
-  if (externalWatcher) return;
-  externalWatcher = watchProjectTree(
-    projectRoot,
-    ({ filename }) => {
-      if (!filename || isIgnoredRelativePath(filename)) return;
-      const absolute = path.resolve(projectRoot, filename);
-      const relative2 = path.relative(projectRoot, absolute);
-      if (relative2 === ".." || relative2.startsWith(`..${path.sep}`) || path.isAbsolute(relative2) || !isIndexablePath(absolute)) {
-        return;
-      }
-      enqueueExternalFile(absolute);
-    },
-    {
-      onError: () => {
-      }
-    }
-  );
-}
-function stopExternalWatcher() {
-  try {
-    externalWatcher?.close();
-  } catch {
-  }
-  externalWatcher = void 0;
-  for (const timer of externalDebounceTimers.values()) clearTimeout(timer);
-  externalDebounceTimers.clear();
-  if (externalReadyFlush) clearTimeout(externalReadyFlush);
-  externalReadyFlush = void 0;
-  externalReadyFiles.clear();
-}
-function reconcileExternalWatcher() {
-  const owners = [...clients].filter((client) => client.watchExternal);
-  if (owners.length === 0) {
-    externalDebounceMs = DEFAULT_EXTERNAL_DEBOUNCE_MS;
-    externalCoalesceWindowMs = DEFAULT_EXTERNAL_COALESCE_WINDOW_MS;
-    stopExternalWatcher();
-    return;
-  }
-  externalDebounceMs = Math.min(...owners.map((client) => client.debounceMs));
-  externalCoalesceWindowMs = Math.min(...owners.map((client) => client.coalesceWindowMs));
-  ensureExternalWatcher();
-}
 function consume(state, chunk) {
-  const buffer = state.buffer.length === 0 ? chunk : Buffer.concat([state.buffer, chunk]);
-  let scan = 0;
-  while (true) {
-    if (buffer.length - scan === 0) break;
-    if (isBinaryFrame(buffer[scan])) {
-      if (buffer.length - scan < 5) break;
-      const frameLen = buffer.readUInt32BE(scan + 1);
-      if (frameLen > MAX_INBOUND_BINARY_FRAME_BYTES) {
-        state.buffer = Buffer.alloc(0);
-        state.socket.destroy(new Error("codebase-index client binary frame exceeds the IPC limit"));
-        return;
-      }
-      if (buffer.length - scan < 5 + frameLen) break;
-      const payload = buffer.subarray(scan + 5, scan + 5 + frameLen);
-      let message2;
-      try {
-        message2 = decodeBinaryFrame(payload);
-      } catch {
-        state.buffer = Buffer.alloc(0);
-        state.socket.destroy(new Error("invalid codebase-index client binary frame"));
-        return;
-      }
-      scan += 5 + frameLen;
-      state.binary = true;
-      state.lastSeenAt = Date.now();
-      void handleMessage(state, message2);
-      continue;
-    }
-    const newline = buffer.indexOf(10, scan);
-    if (newline < 0) {
-      if (buffer.length - scan > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
-        state.buffer = Buffer.alloc(0);
-        state.socket.destroy(new Error("codebase-index client message exceeds the IPC limit"));
-        return;
-      }
-      break;
-    }
-    if (newline - scan > PROJECT_INDEX_SERVER_MAX_FRAME_CHARS) {
-      state.buffer = Buffer.alloc(0);
-      state.socket.destroy(new Error("codebase-index client message exceeds the IPC limit"));
-      return;
-    }
-    const line = buffer.subarray(scan, newline).toString("utf8");
-    scan = newline + 1;
-    if (!line) continue;
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
-      state.buffer = Buffer.alloc(0);
-      state.socket.destroy(new Error("invalid codebase-index client message"));
-      return;
-    }
-    state.lastSeenAt = Date.now();
-    void handleMessage(state, message);
-  }
-  state.buffer = scan === 0 ? buffer : Buffer.from(buffer.subarray(scan));
+  consumeClientChunk(state, chunk, handleMessage);
 }
 function scheduleIdleStop() {
   if (stopping || clients.size > 0) return;
@@ -831,24 +937,6 @@ function scheduleIdleStop() {
   idleTimer = setTimeout(() => void stop("idle-timeout"), idleMs);
   idleTimer.unref?.();
 }
-function removeMetadataIfOwned() {
-  try {
-    const current = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
-    if (current.pid === process.pid) fs.rmSync(metadataPath, { force: true });
-  } catch {
-  }
-}
-async function writeMetadata() {
-  fs.mkdirSync(path.dirname(metadataPath), { recursive: true });
-  const metadata = { ...serverInfo, authToken };
-  await atomicWrite(metadataPath, `${JSON.stringify(metadata, null, 2)}
-`, { mode: 384 });
-  await restrictFilePermissions(metadataPath, {
-    label: "codebase-index-metadata",
-    warn: (message) => process.stderr.write(`${message}
-`)
-  });
-}
 var server = net.createServer((socket) => {
   if (idleTimer) clearTimeout(idleTimer);
   idleTimer = void 0;
@@ -876,7 +964,7 @@ var server = net.createServer((socket) => {
     state.cancel.clear();
     clients.delete(state);
     try {
-      reconcileExternalWatcher();
+      watcherManager.reconcile(clients);
     } catch {
     }
     scheduleIdleStop();
@@ -904,21 +992,21 @@ async function stop(_reason) {
     state.socket.end();
   }
   activeFullIndex?.controller.abort(new Error("codebase-index server stopping"));
-  stopExternalWatcher();
+  watcherManager.stop();
   walMaintenance.dispose();
   indexStorePool.closeAll();
-  removeMetadataIfOwned();
-  await new Promise((resolve2) => {
-    server.close(() => resolve2());
+  removeMetadataIfOwned(metadataPath, process.pid);
+  await new Promise((resolve3) => {
+    server.close(() => resolve3());
     const timer = setTimeout(() => {
       for (const state of clients) state.socket.destroy();
-      resolve2();
+      resolve3();
     }, 500);
     timer.unref?.();
   });
   if (process.platform !== "win32") {
     try {
-      fs.rmSync(endpoint, { force: true });
+      fs2.rmSync(endpoint, { force: true });
     } catch {
     }
   }
@@ -946,41 +1034,10 @@ void (async () => {
 `);
     process.exitCode = 1;
   });
-  await writeMetadata();
+  const metadata = { ...serverInfo, authToken };
+  await writeProjectServerMetadata(metadataPath, metadata);
   markMetadataWritten?.();
   scheduleIdleStop();
 })();
-var SIGNAL_GUARD = /* @__PURE__ */ Symbol.for(
-  "wrongstack.codebase-index.project-server.signalGuard"
-);
-var signalGuardStore = globalThis;
-var signalGuard = signalGuardStore[SIGNAL_GUARD];
-if (!signalGuard) {
-  let current = async () => void 0;
-  let armed = false;
-  const handlers = /* @__PURE__ */ new Map();
-  const disarm = () => {
-    if (!armed) return;
-    armed = false;
-    for (const [signal, handler] of handlers) process.removeListener(signal, handler);
-    handlers.clear();
-  };
-  signalGuard = {
-    arm(next) {
-      current = next;
-      if (armed) return;
-      armed = true;
-      for (const signal of ["SIGINT", "SIGTERM"]) {
-        const handler = () => {
-          disarm();
-          void current(signal);
-        };
-        handlers.set(signal, handler);
-        process.on(signal, handler);
-      }
-    }
-  };
-  signalGuardStore[SIGNAL_GUARD] = signalGuard;
-}
-signalGuard.arm(stop);
+armCodebaseIndexSignalGuard(stop);
 //# sourceMappingURL=project-server.js.map