ctxloom-pro 1.0.29 → 1.0.31

package/apps/dashboard/package.json

@@ -33,6 +33,7 @@
     "@types/supertest": "^6.0.0",
     "@vitejs/plugin-react": "^4.3.0",
     "autoprefixer": "^10.4.0",
+    "clsx": "^2.1.1",
     "d3": "^7.9.0",
     "jsdom": "^24.0.0",
     "postcss": "^8.4.0",

package/bin/ctxloom.cjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
+'use strict';
+
+/**
+ * ctxloom — CJS bootstrap that bumps the file-descriptor soft limit
+ * before loading the ESM entry point.
+ *
+ * Why this exists
+ * ───────────────
+ * Node.js does not expose `setrlimit(2)` natively, so we cannot raise
+ * RLIMIT_NOFILE from inside the JS runtime. macOS's launchctl default
+ * is `maxfiles = 256` (soft) / `unlimited` (hard), and every child
+ * process spawned by Claude.app / VS Code inherits that 256 soft cap.
+ *
+ * During a long-lived MCP session the cap is exhausted within ~20 tool
+ * calls — LanceDB keeps SSTable file handles open across queries, the
+ * ONNX runtime holds the model.onnx mmap, tree-sitter holds each WASM
+ * grammar, and the ~80 source files indexed at boot each leave a
+ * residual handle. The result is an EMFILE cascade that breaks every
+ * subsequent tool, including plain `fs.readFile`.
+ *
+ * Strategy
+ * ────────
+ * Re-exec ourselves through `/bin/sh -c "ulimit -n 65536; exec node …"`,
+ * gated by an env var to prevent an exec loop. On the second pass the
+ * raised limit is in place and we dynamic-import the real ESM entry.
+ *
+ * Windows is unaffected (the FD limit is much higher there, and `sh`
+ * is unavailable), so we skip the bump and load directly.
+ *
+ * Safe to call when the limit is already higher than our target — the
+ * second `ulimit` invocation is a no-op when the value is already at
+ * or above 65536.
+ */
+
+const path = require('node:path');
+
+const FD_LIMIT_TARGET = 65536;
+const SENTINEL_ENV = 'CTXLOOM_FD_BUMPED';
+const ENTRY = path.join(__dirname, '..', 'dist', 'index.js');
+
+function shellQuote(arg) {
+  // POSIX-safe single-quote escape: a' becomes 'a'\'''.
+  return `'${String(arg).replace(/'/g, "'\\''")}'`;
+}
+
+function shouldBump() {
+  if (process.env[SENTINEL_ENV] === '1') return false;
+  if (process.platform === 'win32') return false;
+  // Allow opt-out for unusual environments (e.g. setuid wrappers, CI
+  // runners that already manage rlimit themselves).
+  if (process.env['CTXLOOM_SKIP_FD_BUMP'] === '1') return false;
+  return true;
+}
+
+if (shouldBump()) {
+  const { spawnSync } = require('node:child_process');
+  const quotedExec = shellQuote(process.execPath);
+  // process.argv[0] is the node path; argv[1] is THIS script; argv[2…] are
+  // the user's args. We want to re-exec node against the same script with
+  // the same user args, so we keep argv[1…] intact.
+  const quotedArgs = process.argv.slice(1).map(shellQuote).join(' ');
+  const cmd =
+    `ulimit -n ${FD_LIMIT_TARGET} 2>/dev/null; ` +
+    `${SENTINEL_ENV}=1 exec ${quotedExec} ${quotedArgs}`;
+  const result = spawnSync('/bin/sh', ['-c', cmd], { stdio: 'inherit' });
+  // spawnSync sets `status` on normal exit and `signal` on signal exit.
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    // Fallback in case the signal is non-terminating in this context.
+    process.exit(1);
+  }
+  process.exit(result.status == null ? 1 : result.status);
+}
+
+// On the second pass (or on Windows) load the real ESM entry.
+import(ENTRY).catch((err) => {
+  // Surface errors clearly — without this the user sees an unhandled
+  // promise rejection with no stack trace pointing back to the wrapper.
+  process.stderr.write(
+    `ctxloom: failed to load entry ${ENTRY}\n${err && err.stack ? err.stack : err}\n`,
+  );
+  process.exit(1);
+});

package/dist/index.js

@@ -160,6 +160,22 @@ async function startServer(opts = {}) {
   await server.connect(transport);
   logger.info("MCP Server started on Stdio transport");
   logger.info("Project root", { root: PROJECT_ROOT });
+  try {
+    const { execSync: execSync2 } = await import("child_process");
+    const nofileSoft = Number(execSync2("ulimit -n", { shell: "/bin/sh" }).toString().trim());
+    if (Number.isFinite(nofileSoft)) {
+      const FD_WARN_THRESHOLD = 4096;
+      if (nofileSoft < FD_WARN_THRESHOLD) {
+        logger.warn(
+          "Low file-descriptor soft limit \u2014 EMFILE likely after ~20 tool calls. Run via `bin/ctxloom.cjs` (default bin) which bumps to 65536, or set `ulimit -n 65536` in your shell before launching.",
+          { nofileSoft, threshold: FD_WARN_THRESHOLD }
+        );
+      } else {
+        logger.info("FD soft limit", { nofileSoft });
+      }
+    }
+  } catch {
+  }
   Promise.all([ctx.getGraph(), generateEmbedding("warmup")]).then(async ([graph]) => {
     logger.info("Ready", { edges: graph.edgeCount() });
     if (withGit2) {
@@ -616,7 +632,7 @@ try {
 } catch {
 }
 var args = process.argv.slice(2);
-var ctxloomVersion = "1.0.29".length > 0 ? "1.0.29" : "dev";
+var ctxloomVersion = "1.0.31".length > 0 ? "1.0.31" : "dev";
 if (args.includes("--version") || args.includes("-v")) {
   process.stdout.write(`ctxloom ${ctxloomVersion}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxloom-pro",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "ctxloom — The Universal Code Context Engine. A local-first MCP server providing intelligent code context via hybrid Vector + AST + Graph search with Skeletonization (92% token reduction).",
   "type": "module",
   "main": "dist/index.js",
@@ -16,9 +16,10 @@
     "access": "public"
   },
   "bin": {
-    "ctxloom": "dist/index.js"
+    "ctxloom": "bin/ctxloom.cjs"
   },
   "files": [
+    "bin/ctxloom.cjs",
     "dist/**/*",
     "!dist/**/*.map",
     "apps/dashboard/dist/**/*",