@esankhan3/code-search-mcp 1.0.5 → 1.1.0

package/dist/core/config.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { homedir, tmpdir } from "node:os";
+import { Logger } from "../observability/logger.js";
 function defaultDataDir() {
-  return process.env.CODE_SEARCH_DATA_DIR ?? join(homedir(), ".code-search", "index");
+  return process.env.CODE_SEARCH_DATA_DIR ?? join(process.env.ANVIL_HOME || join(homedir(), ".anvil"), "knowledge-base");
 }
 const DEFAULTS = {
   server: {
@@ -59,7 +60,6 @@ const DEFAULTS = {
     recordQueries: false
   },
   daemon: {
-    autoSpawn: false,
     disabled: false
   }
 };
@@ -159,14 +159,16 @@ function parseHeaders(s) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-function parseReindexMs(raw) {
-  if (!raw || raw === "0" || raw === "none") return 0;
-  const m = raw.match(/^(\d+)(m|h)$/);
-  if (!m) {
-    const n = parseInt(raw, 10);
-    return Number.isFinite(n) ? n : 0;
+function parseReindexInterval(raw) {
+  if (raw === void 0 || raw === null || raw === "" || raw === 0 || raw === "0" || raw === "none") return 0;
+  const s = String(raw).trim();
+  const unit = s.match(/^(\d+)(m|h)$/);
+  if (unit) return parseInt(unit[1], 10) * (unit[2] === "h" ? 36e5 : 6e4);
+  if (/^\d+$/.test(s)) {
+    const ms = parseInt(s, 10);
+    return ms >= 6e4 ? ms : null;
   }
-  return m[2] === "h" ? parseInt(m[1], 10) * 60 * 6e4 : parseInt(m[1], 10) * 6e4;
+  return null;
 }
 function envStorageBackends(env) {
   const blobBackend = env("STORAGE_BLOB_BACKEND");
@@ -220,7 +222,7 @@ function envLayer() {
     server: {
       transport,
       port: port ? parseInt(port, 10) : void 0,
-      host: env("HOST") ?? (authMode === "none" || !authMode ? void 0 : "0.0.0.0")
+      host: env("HOST")
     },
     auth: {
       mode: authMode,
@@ -253,7 +255,8 @@ function envLayer() {
     },
     indexing: {
       autoIndex: env("AUTO_INDEX") !== void 0 ? env("AUTO_INDEX") !== "false" && env("AUTO_INDEX") !== "0" : void 0,
-      reindexIntervalMs: env("REINDEX_INTERVAL") !== void 0 ? parseReindexMs(env("REINDEX_INTERVAL")) : void 0,
+      // Raw string; normalised (and validated) by the resolver for every layer.
+      reindexIntervalMs: env("REINDEX_INTERVAL"),
       chunking: {
         maxTokens: chunkMaxTokens ? parseInt(chunkMaxTokens, 10) : void 0
       },
@@ -278,7 +281,6 @@ function envLayer() {
       recordQueries: env("TELEMETRY_RECORD_QUERIES") === "1" || env("TELEMETRY_RECORD_QUERIES") === "true" ? true : void 0
     },
     daemon: {
-      autoSpawn: env("DAEMON_AUTO_SPAWN") === "1" || env("DAEMON_AUTO_SPAWN") === "true" ? true : void 0,
       disabled: env("DAEMON_DISABLED") === "1" || env("DAEMON_DISABLED") === "true" ? true : void 0
     }
   };
@@ -296,30 +298,64 @@ const RESERVED_FLAGS = /* @__PURE__ */ new Set([
   "--force",
   "--workspace",
   "--no-daemon",
-  "--auto-spawn-daemon",
-  "--config",
   "--format",
   "--top-k",
   "--mode",
-  "--repo",
-  "--language"
+  "--repo"
 ]);
+const ROOT_ALIASES = {
+  "--port": ["server", "port"],
+  "--host": ["server", "host"],
+  "--transport": ["server", "transport"],
+  "--auth": ["auth", "mode"]
+};
+const OPTIONAL_LEAVES = [
+  "auth.jwtSecret",
+  "embedding.model",
+  "embedding.apiKey",
+  "embedding.baseUrl",
+  "embedding.ollamaHost",
+  "reranker.model",
+  "reranker.apiKey",
+  "reranker.baseUrl",
+  "reranker.timeoutMs",
+  "llm.apiKey",
+  "llm.baseUrl",
+  "github.token",
+  "telemetry.otelEndpoint"
+];
+const OPEN_SUBTREES = ["storage.backends.", "telemetry.otelHeaders."];
+function leafPaths(obj, prefix, out) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (isPlainObject(v)) leafPaths(v, `${prefix}${k}.`, out);
+    else out.add(`${prefix}${k}`);
+  }
+  return out;
+}
+const KNOWN_LEAVES = leafPaths(DEFAULTS, "", new Set(OPTIONAL_LEAVES));
+function isKnownPath(path) {
+  return KNOWN_LEAVES.has(path) || OPEN_SUBTREES.some((p) => path.startsWith(p));
+}
 function parseCliFlags(argv) {
   const patch = {};
   const rest = [];
+  const unknown = [];
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith("--") || RESERVED_FLAGS.has(arg)) {
       rest.push(arg);
       continue;
     }
-    let key = arg.slice(2);
+    let path = ROOT_ALIASES[arg];
     let negate = false;
-    if (key.startsWith("no-")) {
-      negate = true;
-      key = key.slice(3);
+    if (!path) {
+      let key = arg.slice(2);
+      if (key.startsWith("no-")) {
+        negate = true;
+        key = key.slice(3);
+      }
+      path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
     }
-    const path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
     let val;
     if (negate) {
       val = false;
@@ -328,9 +364,13 @@ function parseCliFlags(argv) {
     } else {
       val = true;
     }
+    if (!isKnownPath(path.join("."))) {
+      unknown.push(arg);
+      continue;
+    }
     setDeep(patch, path, val);
   }
-  return { patch, rest };
+  return { patch, rest, unknown };
 }
 function setDeep(obj, path, value) {
   let cur = obj;
@@ -347,10 +387,33 @@ function resolveCodeSearchConfig(opts = {}) {
   const yaml2 = opts.workspaceDir ? loadYamlFile(join(opts.workspaceDir, ".code-search.yaml")) ?? {} : {};
   const env = envLayer();
   const cli = opts.cli ?? {};
-  const cfg = deepMerge(DEFAULTS, yaml1, yaml2, env, cli);
+  const layers = [yaml1, yaml2, env, cli];
+  const cfg = deepMerge(
+    structuredClone(DEFAULTS),
+    ...layers
+  );
+  if (cfg.auth.mode !== "none" && !layers.some((l) => l.server?.host !== void 0)) {
+    cfg.server.host = "0.0.0.0";
+  }
+  const rawInterval = cfg.indexing.reindexIntervalMs;
+  const intervalMs = parseReindexInterval(rawInterval);
+  if (intervalMs === null) {
+    warnOnce(cfg, `[code-search] invalid reindex interval ${JSON.stringify(String(rawInterval))} (use 30m, 1h, \u2026 \u2014 at least one minute \u2014 or 0); auto-reindex disabled`);
+  }
+  cfg.indexing.reindexIntervalMs = intervalMs ?? 0;
+  cfg.storage.dataDir = resolve(cfg.storage.dataDir);
   bridgeLegacyEnvVars(cfg);
   return cfg;
 }
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(cfg, msg) {
+  if (warned.has(msg)) return;
+  warned.add(msg);
+  new Logger({ structured: cfg.telemetry.structuredLogs }).warn(msg);
+}
+function exportDataDir(cfg) {
+  process.env.CODE_SEARCH_DATA_DIR = cfg.storage.dataDir;
+}
 function bridgeLegacyEnvVars(cfg) {
   process.env.ANVIL_LLM_MODE ??= process.env.CODE_SEARCH_LLM_MODE ?? cfg.llm.mode;
   process.env.ANVIL_LLM_PROVIDER ??= process.env.CODE_SEARCH_LLM_PROVIDER ?? cfg.llm.provider;
@@ -362,7 +425,7 @@ function bridgeLegacyEnvVars(cfg) {
 function toKnowledgeConfig(c) {
   return {
     embedding: { ...c.embedding },
-    chunking: { ...c.indexing.chunking },
+    chunking: { ...c.indexing.chunking, ignorePatterns: c.indexing.ignorePatterns },
     retrieval: {
       maxChunks: c.retrieval.maxChunks,
       maxTokens: c.retrieval.maxTokens,
@@ -373,23 +436,29 @@ function toKnowledgeConfig(c) {
     ...c.storage.backends ? { storage: c.storage.backends } : {}
   };
 }
-const SECRET_KEYS = /* @__PURE__ */ new Set([
-  "apiKey",
-  "jwtSecret",
-  "token",
-  "githubToken"
-]);
+const SECRET_KEY = /pass(word)?|secret|token|authorization|api[-_]?keys?|credential/i;
+const URI_USERINFO = /([a-z][a-z0-9+.-]*:\/\/)([^/\s@]+)@/gi;
+function redactString(v) {
+  return `***redacted (${v.length} chars)`;
+}
 function redactSecrets(value, parentKey = "") {
+  if (typeof value === "string") {
+    return value.replace(URI_USERINFO, (_m, scheme, info) => {
+      const colon = info.indexOf(":");
+      return `${scheme}${colon >= 0 ? info.slice(0, colon + 1) : ""}***@`;
+    });
+  }
   if (Array.isArray(value)) {
     return value.map((v) => redactSecrets(v, parentKey));
   }
   if (isPlainObject(value)) {
     const out = {};
     for (const [k, v] of Object.entries(value)) {
-      if (SECRET_KEYS.has(k) && typeof v === "string" && v.length > 0) {
-        out[k] = `***redacted (${v.length} chars)`;
-      } else if (k === "apiKeys" && Array.isArray(v)) {
-        out[k] = v.map((s) => `***redacted (${s.length} chars)`);
+      const secret = SECRET_KEY.test(k) || parentKey === "otelHeaders";
+      if (secret && typeof v === "string" && v.length > 0) {
+        out[k] = redactString(v);
+      } else if (secret && Array.isArray(v)) {
+        out[k] = v.map((s) => typeof s === "string" ? redactString(s) : redactSecrets(s, k));
       } else {
         out[k] = redactSecrets(v, k);
       }
@@ -403,7 +472,9 @@ function printConfig(c) {
 }
 export {
   DEFAULTS,
+  exportDataDir,
   parseCliFlags,
+  parseReindexInterval,
   printConfig,
   redactSecrets,
   resolveCodeSearchConfig,

package/dist/core/env-config.js

@@ -1,13 +1,12 @@
 import { execSync as _execSync } from "node:child_process";
 import {
   resolveCodeSearchConfig,
-  parseCliFlags,
   toKnowledgeConfig
 } from "./config.js";
 import { normalizeRerankerConfig } from "@esankhan3/anvil-knowledge-core";
 let _config = null;
 function resolveLlmMode(explicit, apiKey, claudeBin) {
-  if (explicit && explicit !== "none") {
+  if (explicit === "cli" || explicit === "api" || explicit === "none") {
     if (explicit === "api" && !apiKey) {
       console.error(
         `[code-search-mcp] WARNING: LLM_MODE=api but no API key found. Set CODE_SEARCH_LLM_API_KEY or ANTHROPIC_API_KEY. Falling back to LLM_MODE=none.`
@@ -32,10 +31,9 @@ function resolvedKnowledgeConfig() {
 }
 function loadServerConfig(opts) {
   if (_config) return _config;
-  const cli = opts?.argv ? parseCliFlags(opts.argv).patch : void 0;
-  const c = resolveCodeSearchConfig({ cli, workspaceDir: opts?.workspaceDir });
+  const c = resolveCodeSearchConfig({ cli: opts?.cli, workspaceDir: opts?.workspaceDir });
   const rerankerStruct = normalizeRerankerConfig(c.reranker);
-  const llmMode = resolveLlmMode(c.llm.mode, c.llm.apiKey, c.llm.claudeBin);
+  const llmMode = resolveLlmMode(process.env.ANVIL_LLM_MODE ?? c.llm.mode, c.llm.apiKey, c.llm.claudeBin);
   _config = {
     port: c.server.port,
     host: c.server.host,

package/dist/core/project-name.js

@@ -0,0 +1,12 @@
+const RESERVED = /* @__PURE__ */ new Set(["daemon", "projects"]);
+function validateProjectName(name) {
+  if (!name || name === "." || name === ".." || /[/\\\0]/.test(name) || RESERVED.has(name)) {
+    throw new Error(
+      `Invalid project name ${JSON.stringify(name)}: a project name must be a single path segment (no "/" or "\\", not "." or "..") and not one of the reserved names: ${[...RESERVED].join(", ")}.`
+    );
+  }
+  return name;
+}
+export {
+  validateProjectName
+};

package/dist/core/version.js

@@ -0,0 +1,5 @@
+import { readFileSync } from "node:fs";
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8")).version;
+export {
+  PACKAGE_VERSION
+};

package/dist/daemon/index.js

@@ -1,63 +1,83 @@
 #!/usr/bin/env node
-import { writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { resolveCodeSearchConfig, parseCliFlags, toKnowledgeConfig } from "../core/config.js";
+import { writeFileSync, existsSync, readFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { resolveCodeSearchConfig, parseCliFlags, toKnowledgeConfig, exportDataDir } from "../core/config.js";
+import { validateProjectName } from "../core/project-name.js";
 import { InProcessBackend } from "../backends/in-process.js";
-import { daemonSocketPath } from "../backends/index.js";
+import { DaemonBackend, daemonSocketPath } from "../backends/index.js";
+import { configureLogger, getComponentLogger } from "../observability/logger.js";
 import { RpcServer } from "./rpc-server.js";
 import { Watcher } from "./watcher.js";
+const log = getComponentLogger("code-search-daemon");
+function usageError(msg) {
+  process.stderr.write(`code-search-daemon: ${msg}
+`);
+  process.exit(2);
+}
 async function main() {
-  const argv = process.argv.slice(2);
-  const { patch, rest } = parseCliFlags(argv);
-  let workspaceDir = null;
+  const { patch, rest, unknown } = parseCliFlags(process.argv.slice(2));
+  if (unknown.length) usageError(`unknown flag(s): ${unknown.join(", ")}`);
+  let workspaceArg = null;
   for (let i = 0; i < rest.length; i++) {
-    if (rest[i] === "--workspace" && rest[i + 1]) workspaceDir = rest[++i];
-  }
-  if (!workspaceDir) {
-    process.stderr.write("code-search-daemon: missing --workspace <path>\n");
-    process.exit(2);
-  }
-  if (!existsSync(workspaceDir)) {
-    process.stderr.write(`code-search-daemon: workspace does not exist: ${workspaceDir}
-`);
-    process.exit(2);
+    if (rest[i] === "--workspace" && rest[i + 1]) workspaceArg = rest[++i];
+    else usageError(`unexpected argument: ${rest[i]} (usage: code-search-daemon --workspace <path> [--<config.path> <value>])`);
   }
+  if (!workspaceArg) usageError("missing --workspace <path>");
+  const workspaceDir = resolve(workspaceArg);
+  if (!existsSync(workspaceDir)) usageError(`workspace does not exist: ${workspaceDir}`);
   const cfg = resolveCodeSearchConfig({ cli: patch, workspaceDir });
-  const project = workspaceDir.split("/").filter(Boolean).pop() || "project";
+  configureLogger({ structured: cfg.telemetry.structuredLogs });
+  exportDataDir(cfg);
+  let project;
+  try {
+    project = validateProjectName(basename(workspaceDir));
+  } catch (err) {
+    usageError(err.message);
+  }
   const knowledge = toKnowledgeConfig(cfg);
+  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  const pidFile = join(cfg.storage.dataDir, "daemon", `${project}.pid`);
+  if (existsSync(socketPath)) {
+    const live = await new DaemonBackend({ project, workspaceDir, knowledge, preferDaemon: true, socketPath }).ping();
+    if (live) {
+      const pid = existsSync(pidFile) ? readFileSync(pidFile, "utf-8").trim() : "unknown";
+      log.error(`a daemon for project "${project}" is already running (pid ${pid}, socket ${socketPath}) \u2014 not starting another`);
+      process.exit(1);
+    }
+    if (process.platform !== "win32") {
+      try {
+        unlinkSync(socketPath);
+      } catch {
+      }
+    }
+  }
   const backend = new InProcessBackend({
     project,
     workspaceDir,
     knowledge,
     preferDaemon: false
   });
-  process.stderr.write(`[code-search-daemon] starting for project="${project}", workspace=${workspaceDir}
-`);
-  process.stderr.write("[code-search-daemon] building initial index...\n");
-  await backend.forceIndex();
-  process.stderr.write("[code-search-daemon] initial index ready.\n");
-  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
-  const pidFile = join(cfg.storage.dataDir, "daemon", `${project}.pid`);
+  let tail = Promise.resolve();
   let queueDepth = 0;
-  let indexing = false;
-  const triggerReindex = async () => {
-    if (indexing) {
-      queueDepth++;
-      return;
-    }
-    indexing = true;
-    try {
-      while (queueDepth >= 0) {
-        await backend.forceIndex();
-        if (queueDepth === 0) break;
+  let watcherRunPending = false;
+  const enqueue = (reason, run) => {
+    queueDepth++;
+    const job = tail.then(async () => {
+      log.info(`reindex started (${reason})`);
+      try {
+        const out = await run();
+        log.info(`reindex finished (${reason})`);
+        return out;
+      } catch (err) {
+        log.error(`reindex failed (${reason}): ${err instanceof Error ? err.message : err}`);
+        throw err;
+      } finally {
         queueDepth--;
       }
-    } catch (err) {
-      process.stderr.write(`[code-search-daemon] reindex failed: ${err instanceof Error ? err.message : err}
-`);
-    } finally {
-      indexing = false;
-    }
+    });
+    tail = job.catch(() => {
+    });
+    return job;
   };
   const watcher = new Watcher({
     workspaceDir,
@@ -65,16 +85,18 @@ async function main() {
     debounceMs: cfg.indexing.debounceMs
   });
   watcher.on("error", (err) => {
-    process.stderr.write(`[code-search-daemon] watcher error: ${err instanceof Error ? err.message : err}
-`);
+    log.error(`watcher error: ${err instanceof Error ? err.message : err}`);
   });
   watcher.onBatch((batch) => {
-    process.stderr.write(`[code-search-daemon] reindex queued (${batch.changed.size} changed, ${batch.removed.size} removed)
-`);
-    queueDepth++;
-    void triggerReindex();
+    log.info(`reindex queued (${batch.changed.size} changed, ${batch.removed.size} removed)`);
+    if (watcherRunPending) return;
+    watcherRunPending = true;
+    enqueue("watcher", () => {
+      watcherRunPending = false;
+      return backend.forceIndex();
+    }).catch(() => {
+    });
   });
-  watcher.start();
   const startedAt = Date.now();
   const rpc = new RpcServer({
     socketPath,
@@ -84,36 +106,55 @@ async function main() {
         const s = await backend.status();
         return { ...s, watching: true, queueDepth };
       },
-      "index.force": async (p) => {
-        await backend.forceIndex({ force: p?.force });
-        return backend.status();
-      },
+      "index.force": (p) => enqueue("rpc", () => backend.forceIndex({ force: p?.force })),
       "index.invalidate": async (p) => {
-        await backend.invalidate(p.paths ?? []);
+        await backend.invalidate(p?.paths ?? []);
         return { ok: true };
       },
       "health": () => ({ ok: true, uptime: Math.floor((Date.now() - startedAt) / 1e3) })
     }
   });
-  await rpc.start();
-  process.stderr.write(`[code-search-daemon] RPC listening on ${socketPath}
-`);
   try {
+    await rpc.start();
+  } catch (err) {
+    log.error(`cannot listen on ${socketPath}: ${err instanceof Error ? err.message : err} (another daemon for "${project}" starting?)`);
+    process.exit(1);
+  }
+  log.info(`RPC listening on ${socketPath}`);
+  try {
+    mkdirSync(dirname(pidFile), { recursive: true });
     writeFileSync(pidFile, String(process.pid), "utf-8");
   } catch {
   }
-  const shutdown = async (signal) => {
-    process.stderr.write(`[code-search-daemon] ${signal} \u2014 draining...
-`);
+  let stopping = false;
+  const stop = async (code) => {
+    if (stopping) return;
+    stopping = true;
     watcher.stop();
     await rpc.stop();
-    process.exit(0);
+    try {
+      if (readFileSync(pidFile, "utf-8").trim() === String(process.pid)) unlinkSync(pidFile);
+    } catch {
+    }
+    process.exit(code);
   };
-  process.on("SIGINT", () => void shutdown("SIGINT"));
-  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, () => {
+      log.info(`${sig} \u2014 draining...`);
+      void stop(0);
+    });
+  }
+  log.info(`starting for project="${project}", workspace=${workspaceDir}`);
+  log.info("building initial index...");
+  try {
+    await enqueue("initial", () => backend.forceIndex());
+  } catch {
+    await stop(1);
+  }
+  log.info("initial index ready.");
+  watcher.start();
 }
 main().catch((err) => {
-  process.stderr.write(`code-search-daemon fatal: ${err instanceof Error ? err.stack : err}
-`);
+  log.error(`fatal: ${err instanceof Error ? err.stack : err}`);
   process.exit(1);
 });

package/dist/daemon/rpc-server.js

@@ -1,5 +1,5 @@
 import { createServer } from "node:net";
-import { existsSync, unlinkSync, mkdirSync } from "node:fs";
+import { mkdirSync, statSync } from "node:fs";
 import { dirname } from "node:path";
 import { EventEmitter } from "node:events";
 class RpcServer extends EventEmitter {
@@ -7,18 +7,16 @@ class RpcServer extends EventEmitter {
   handlers;
   server = null;
   clients = /* @__PURE__ */ new Set();
+  /** Inode of the socket file this server created — stop() unlinks only that. */
+  socketIno = null;
   constructor(opts) {
     super();
     this.socketPath = opts.socketPath;
     this.handlers = opts.handlers;
   }
+  /** Listen on the socket. An existing socket file is NOT removed — the
+   *  caller decides whether it is stale; listening then fails EADDRINUSE. */
   async start() {
-    if (process.platform !== "win32" && existsSync(this.socketPath)) {
-      try {
-        unlinkSync(this.socketPath);
-      } catch {
-      }
-    }
     mkdirSync(dirname(this.socketPath), { recursive: true });
     await new Promise((resolveP, rejectP) => {
       this.server = createServer((sock) => this.handleClient(sock));
@@ -27,6 +25,12 @@ class RpcServer extends EventEmitter {
         rejectP(err);
       });
       this.server.listen(this.socketPath, () => {
+        if (process.platform !== "win32") {
+          try {
+            this.socketIno = statSync(this.socketPath).ino;
+          } catch {
+          }
+        }
         this.emit("listening", this.socketPath);
         resolveP();
       });
@@ -41,14 +45,20 @@ class RpcServer extends EventEmitter {
     }
     this.clients.clear();
     if (this.server) {
-      await new Promise((r) => this.server.close(() => r()));
+      if (process.platform === "win32" || this.ownsSocketFile()) {
+        await new Promise((r) => this.server.close(() => r()));
+      } else {
+        this.server.unref();
+      }
       this.server = null;
     }
-    if (process.platform !== "win32" && existsSync(this.socketPath)) {
-      try {
-        unlinkSync(this.socketPath);
-      } catch {
-      }
+    this.socketIno = null;
+  }
+  ownsSocketFile() {
+    try {
+      return this.socketIno !== null && statSync(this.socketPath).ino === this.socketIno;
+    } catch {
+      return false;
     }
   }
   handleClient(sock) {
@@ -77,17 +87,27 @@ class RpcServer extends EventEmitter {
       sock.write(this.errorEnvelope(null, -32700, err instanceof Error ? err.message : String(err)));
       return;
     }
-    const handler = this.handlers[req.method];
-    if (!handler) {
-      sock.write(this.errorEnvelope(req.id ?? null, -32601, `Method not found: ${req.method}`));
+    if (Array.isArray(req)) {
+      sock.write(this.errorEnvelope(null, -32600, "Batch requests are not supported"));
+      return;
+    }
+    if (typeof req !== "object" || req === null || typeof req.method !== "string") {
+      sock.write(this.errorEnvelope(null, -32600, "Invalid request"));
+      return;
+    }
+    const isNotification = !Object.prototype.hasOwnProperty.call(req, "id");
+    const id = req.id ?? null;
+    const handler = Object.prototype.hasOwnProperty.call(this.handlers, req.method) ? this.handlers[req.method] : void 0;
+    if (typeof handler !== "function") {
+      if (!isNotification) sock.write(this.errorEnvelope(id, -32601, `Method not found: ${req.method}`));
       return;
     }
     try {
       const result = await handler(req.params);
-      sock.write(JSON.stringify({ jsonrpc: "2.0", id: req.id ?? null, result }) + "\n");
+      if (!isNotification) sock.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      sock.write(this.errorEnvelope(req.id ?? null, -32e3, msg));
+      if (!isNotification) sock.write(this.errorEnvelope(id, -32e3, msg));
     }
   }
   errorEnvelope(id, code, message) {