@esankhan3/code-search-mcp 1.0.6 → 1.1.1

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) {

package/dist/index.js

@@ -1,51 +1,13 @@
 #!/usr/bin/env node
-import { resolve } from "node:path";
+import { resolve, basename, join } from "node:path";
 import { existsSync } from "node:fs";
-import { printConfig, resolveCodeSearchConfig, parseCliFlags } from "./core/config.js";
-const args = process.argv.slice(2);
-if (args.includes("--print-config")) {
-  const { patch } = parseCliFlags(args.filter((a) => a !== "--print-config"));
-  const cfg = resolveCodeSearchConfig({ cli: patch });
-  process.stdout.write(printConfig(cfg) + "\n");
-  process.exit(0);
-}
-let mode = "remote";
-let remoteUrl = null;
-let apiKey;
-let source = null;
-let projectName = null;
-let githubToken;
-let force = false;
-let port;
-let transport;
-let authMode;
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--remote" && args[i + 1]) {
-    mode = "remote";
-    remoteUrl = args[++i];
-  } else if (args[i] === "--local") {
-    mode = "local";
-    if (args[i + 1] && !args[i + 1].startsWith("--")) {
-      source = args[++i];
-    }
-  } else if (args[i] === "--serve") {
-    mode = "serve";
-  } else if (args[i] === "--api-key" && args[i + 1]) {
-    apiKey = args[++i];
-  } else if (args[i] === "--project" && args[i + 1]) {
-    projectName = args[++i];
-  } else if (args[i] === "--token" && args[i + 1]) {
-    githubToken = args[++i];
-  } else if (args[i] === "--force") {
-    force = true;
-  } else if (args[i] === "--port" && args[i + 1]) {
-    port = args[++i];
-  } else if (args[i] === "--transport" && args[i + 1]) {
-    transport = args[++i];
-  } else if (args[i] === "--auth" && args[i + 1]) {
-    authMode = args[++i];
-  } else if (args[i] === "--help" || args[i] === "-h") {
-    console.error(`
+import { homedir } from "node:os";
+import { printConfig, resolveCodeSearchConfig, parseCliFlags, exportDataDir } from "./core/config.js";
+import { loadServerConfig } from "./core/env-config.js";
+import { validateProjectName } from "./core/project-name.js";
+import { configureLogger, getComponentLogger } from "./observability/logger.js";
+const log = getComponentLogger("code-search-mcp");
+const HELP = `
 Code Search MCP \u2014 multi-repo code intelligence via MCP
 
 REMOTE MODE (default \u2014 connects to a deployed server):
@@ -70,7 +32,7 @@ REMOTE MODE (default \u2014 connects to a deployed server):
       }
     }
 
-LOCAL MODE (self-hosted \u2014 indexes repos locally):
+LOCAL MODE (self-hosted \u2014 indexes repos locally, serves over stdio):
   code-search-mcp --local /path/to/repos             Index local directory
   code-search-mcp --local github:org-name             Clone from GitHub org
   code-search-mcp --local --project my-project        Serve existing index
@@ -78,45 +40,111 @@ LOCAL MODE (self-hosted \u2014 indexes repos locally):
   Options:
     --project <name>        Project name (default: derived from source)
     --token <token>         GitHub token (or GITHUB_TOKEN env)
-    --force                 Force full re-index
+    --force                 Force a full re-index at startup
 
-SERVER MODE (deploy as HTTP service):
-  code-search-mcp --serve                             Start HTTP server
-  code-search-mcp --serve --port 3100 --auth api-key
+SERVER MODE (deploy as HTTP service \u2014 Streamable HTTP on /mcp):
+  code-search-mcp --serve [path]                      Start HTTP server (project "default")
+  code-search-mcp --serve /repos --port 3100 --auth api-key
+  (--local <path> --serve and --serve --local <path> are equivalent)
 
   Options:
-    --port <port>           HTTP port (default: 3100)
-    --auth <mode>           none | api-key | jwt
-    --transport <mode>      streamable-http | sse
+    --port <port>           HTTP port (default: 3100) = --server.port
+    --host <host>           Bind address = --server.host
+    --auth <mode>           none | api-key | jwt = --auth.mode
+    --project <name>        Project name (default: "default")
 
   Environment:
-    CODE_SEARCH_TRANSPORT           streamable-http | sse
     CODE_SEARCH_PORT                HTTP port (default: 3100)
     CODE_SEARCH_AUTH_MODE           none | api-key | jwt
     CODE_SEARCH_AUTH_API_KEYS       Comma-separated API keys
     CODE_SEARCH_EMBEDDING_PROVIDER  auto | codestral | openai | voyage | ollama | custom
     CODE_SEARCH_EMBEDDING_API_KEY   Unified embedding API key
     CODE_SEARCH_DATA_DIR            Data directory override
-`);
-    process.exit(0);
-  } else if (!args[i].startsWith("-")) {
-    const arg = args[i];
-    if (arg.startsWith("http://") || arg.startsWith("https://")) {
-      mode = "remote";
-      remoteUrl = arg;
-    } else {
-      mode = "local";
-      source = arg;
-    }
+
+CONFIG (every mode):
+  --<dotted.path> <value>   Any CodeSearchConfig leaf, e.g. --retrieval.max-chunks 12
+  --print-config            Print the resolved config (secrets redacted) and exit
+`;
+function usageError(msg) {
+  log.error(`${msg} \u2014 see --help`);
+  process.exit(2);
+}
+const { patch, rest, unknown } = parseCliFlags(process.argv.slice(2));
+if (unknown.length) usageError(`unknown flag(s): ${unknown.join(", ")}`);
+let printOnly = false;
+let serve = false;
+let local = false;
+let remoteUrl = null;
+let apiKey;
+let source = null;
+let projectName = null;
+let githubToken;
+let force = false;
+for (let i = 0; i < rest.length; i++) {
+  const arg = rest[i];
+  const value = () => {
+    const v = rest[i + 1];
+    if (v === void 0 || v.startsWith("--")) usageError(`${arg} needs a value`);
+    i++;
+    return v;
+  };
+  const optionalPath = () => rest[i + 1] !== void 0 && !rest[i + 1].startsWith("-") ? rest[++i] : null;
+  switch (arg) {
+    case "--print-config":
+      printOnly = true;
+      break;
+    case "--remote":
+      remoteUrl = value();
+      break;
+    case "--local":
+      local = true;
+      source = optionalPath() ?? source;
+      break;
+    case "--serve":
+      serve = true;
+      source = optionalPath() ?? source;
+      break;
+    case "--api-key":
+      apiKey = value();
+      break;
+    case "--project":
+      projectName = value();
+      break;
+    case "--token":
+      githubToken = value();
+      break;
+    case "--force":
+      force = true;
+      break;
+    case "--help":
+    case "-h":
+      process.stderr.write(HELP);
+      process.exit(0);
+    default:
+      if (arg.startsWith("-")) usageError(`unknown flag: ${arg}`);
+      if (/^https?:\/\//.test(arg)) remoteUrl = arg;
+      else source = arg;
   }
 }
+const mode = serve ? "serve" : remoteUrl ? "remote" : local || source ? "local" : "remote";
+const workspaceDir = source && !source.startsWith("github:") ? resolve(source) : process.cwd();
+const preview = resolveCodeSearchConfig({ cli: patch, workspaceDir });
+if (preview.server.transport === "sse") {
+  usageError("SSE transport is not supported \u2014 the server speaks Streamable HTTP on /mcp (drop --transport / CODE_SEARCH_TRANSPORT)");
+}
+if (mode === "serve") patch.server = { ...patch.server, transport: "streamable-http" };
+if (printOnly) {
+  process.stdout.write(printConfig(resolveCodeSearchConfig({ cli: patch, workspaceDir })) + "\n");
+  process.exit(0);
+}
+configureLogger({ structured: preview.telemetry.structuredLogs });
 (async () => {
   try {
     if (mode === "remote") {
       const serverUrl = remoteUrl ?? process.env.CODE_SEARCH_SERVER ?? process.env.CODE_SEARCH_REMOTE_URL;
       const key = apiKey ?? process.env.CODE_SEARCH_API_KEY ?? process.env.CODE_SEARCH_AUTH_API_KEY;
       if (!serverUrl) {
-        console.error(`[code-search-mcp] No remote server configured.
+        log.error(`No remote server configured.
 
 Set CODE_SEARCH_SERVER environment variable:
   export CODE_SEARCH_SERVER=https://your-server:3100
@@ -136,14 +164,8 @@ For help:
       await startRemoteProxy({ serverUrl, apiKey: key });
       return;
     }
-    if (mode === "serve") {
-      if (port) process.env.CODE_SEARCH_PORT = port;
-      if (authMode) process.env.CODE_SEARCH_AUTH_MODE = authMode;
-      process.env.CODE_SEARCH_TRANSPORT = transport === "sse" ? "sse" : "streamable-http";
-      const { startServer: startServer2 } = await import("./server.js");
-      await startServer2(projectName ?? "default", source ? resolve(source) : null);
-      return;
-    }
+    const config = loadServerConfig({ cli: patch, workspaceDir });
+    exportDataDir(config.__unified);
     let directoryPath = null;
     if (source?.startsWith("github:")) {
       const { cloneOrUpdateOrg } = await import("./sources/github-org.js");
@@ -151,34 +173,36 @@ For help:
       const slashIdx = spec.indexOf("/");
       const org = slashIdx > 0 ? spec.slice(0, slashIdx) : spec;
       const pattern = slashIdx > 0 ? spec.slice(slashIdx + 1) : void 0;
-      if (!projectName) projectName = org;
-      console.error(`[code-search-mcp] Cloning repos from github:${org}${pattern ? `/${pattern}` : ""}...`);
+      if (!projectName && mode === "local") projectName = org;
+      log.info(`Cloning repos from github:${org}${pattern ? `/${pattern}` : ""}...`);
       const repos = await cloneOrUpdateOrg(org, {
         pattern,
         token: githubToken,
-        onProgress: (m) => console.error(m)
+        onProgress: (m) => log.info(m)
       });
-      console.error(`[code-search-mcp] ${repos.length} repos ready`);
-      const { homedir } = await import("node:os");
-      const { join } = await import("node:path");
+      log.info(`${repos.length} repos ready`);
       directoryPath = join(homedir(), ".code-search", org);
     } else if (source) {
       directoryPath = resolve(source);
       if (!existsSync(directoryPath)) {
-        console.error(`[code-search-mcp] Directory not found: ${directoryPath}`);
+        log.error(`Directory not found: ${directoryPath}`);
         process.exit(1);
       }
-      if (!projectName) {
-        projectName = directoryPath.split("/").filter(Boolean).pop() || "project";
-      }
-    } else if (!projectName) {
+    } else if (local && !projectName) {
       directoryPath = process.cwd();
-      projectName = directoryPath.split("/").filter(Boolean).pop() || "project";
+    }
+    if (!projectName) {
+      projectName = mode === "serve" ? "default" : directoryPath && basename(directoryPath) || "project";
+    }
+    try {
+      validateProjectName(projectName);
+    } catch (err) {
+      usageError(err.message);
     }
     const { startServer } = await import("./server.js");
-    await startServer(projectName, directoryPath);
+    await startServer(projectName, directoryPath, { force });
   } catch (err) {
-    console.error(`[code-search-mcp] Fatal:`, err);
+    log.error(`Fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
     process.exit(1);
   }
 })();