context-compress 2026.3.20 → 2026.3.21

package/dist/server.bundle.mjs

@@ -21216,6 +21216,54 @@ import { execFileSync, spawn } from "node:child_process";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
+
+// src/utils.ts
+function detectInjectionPatterns(content) {
+  const warnings = [];
+  const patterns = [
+    { re: /ignore\s+(all\s+)?previous\s+instructions/i, label: "instruction override" },
+    { re: /you\s+are\s+now\s+/i, label: "role reassignment" },
+    {
+      re: /(?:^|\n)\s*system\s*:\s*(?:you are|you're|as an? )/im,
+      label: "system prompt injection"
+    },
+    { re: /\[INST\]|\[\/INST\]|<\|im_start\|>|<\|im_end\|>/i, label: "chat template injection" },
+    { re: /\n\n(?:Human|Assistant):/m, label: "chat delimiter injection" },
+    { re: /reveal\s+(your|the)\s+(system|secret|confidential)/i, label: "data exfiltration" },
+    { re: /act\s+as\s+(if\s+you\s+are|a)\s+/i, label: "role manipulation" }
+  ];
+  for (const { re, label } of patterns) {
+    if (re.test(content)) {
+      warnings.push(label);
+    }
+  }
+  return warnings;
+}
+async function limitConcurrency(tasks, limit) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function runNext() {
+    while (nextIndex < tasks.length) {
+      const index = nextIndex++;
+      try {
+        const value = await tasks[index]();
+        results[index] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => runNext());
+  await Promise.all(workers);
+  return results;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
 var SAFE_ENV_KEYS = [
   "PATH",
@@ -21380,20 +21428,26 @@ function smartTruncate(output, maxBytes) {
 `;
   return headLines.join("\n") + separator + tailLines.join("\n");
 }
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
 var SubprocessExecutor = class {
   runtimes;
   config;
   env;
+  activeProcesses = /* @__PURE__ */ new Set();
   constructor(runtimes, config3) {
     this.runtimes = runtimes;
     this.config = config3;
     this.env = buildEnv(config3);
   }
+  /** Kill all active child processes and their process trees. */
+  shutdown() {
+    for (const proc of this.activeProcesses) {
+      try {
+        if (proc.pid) killProcessTree(proc.pid);
+      } catch {
+      }
+    }
+    this.activeProcesses.clear();
+  }
   /**
    * Execute code in a subprocess.
    */
@@ -21495,6 +21549,7 @@ var SubprocessExecutor = class {
         shell: useShell,
         detached: process.platform !== "win32"
       });
+      this.activeProcesses.add(proc);
       proc.stdout?.on("data", (chunk) => {
         totalBytes += chunk.length;
         if (totalBytes > hardCap) {
@@ -21515,6 +21570,7 @@ var SubprocessExecutor = class {
       });
       proc.on("error", (err) => {
         debug("Process error:", err.message);
+        this.activeProcesses.delete(proc);
         if (!resolved) {
           resolved = true;
           resolve2({
@@ -21527,6 +21583,7 @@ var SubprocessExecutor = class {
         }
       });
       proc.on("close", (code) => {
+        this.activeProcesses.delete(proc);
         if (resolved) return;
         resolved = true;
         let stdout = Buffer.concat(stdoutChunks).toString("utf-8");
@@ -21540,8 +21597,10 @@ var SubprocessExecutor = class {
           stdout += `
 [output capped at ${formatBytes(hardCap)} \u2014 process killed]`;
         }
-        stdout = deduplicateLines(stdout);
-        stdout = groupErrorLines(stdout);
+        if (stdout.length > 1e4) {
+          stdout = deduplicateLines(stdout);
+          stdout = groupErrorLines(stdout);
+        }
         const truncated = Buffer.byteLength(stdout) > maxOutput;
         if (truncated) {
           stdout = smartTruncate(stdout, maxOutput);
@@ -21612,24 +21671,24 @@ async function resolveAndValidate(url) {
   let resolvedIp = null;
   let v4Error = false;
   let v6Error = false;
-  try {
-    const { address } = await dns.promises.lookup(hostname2, { family: 4 });
-    if (isPrivateHost(address)) {
-      throw new Error(`Blocked: ${hostname2} resolved to private IP ${address}`);
-    }
-    resolvedIp = address;
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith("Blocked:")) throw err;
+  const [v4Result, v6Result] = await Promise.allSettled([
+    dns.promises.lookup(hostname2, { family: 4 }),
+    dns.promises.lookup(hostname2, { family: 6 })
+  ]);
+  if (v4Result.status === "fulfilled") {
+    if (isPrivateHost(v4Result.value.address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IP ${v4Result.value.address}`);
+    }
+    resolvedIp = v4Result.value.address;
+  } else {
     v4Error = true;
   }
-  try {
-    const { address } = await dns.promises.lookup(hostname2, { family: 6 });
-    if (isPrivateHost(address)) {
-      throw new Error(`Blocked: ${hostname2} resolved to private IPv6 ${address}`);
+  if (v6Result.status === "fulfilled") {
+    if (isPrivateHost(v6Result.value.address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IPv6 ${v6Result.value.address}`);
     }
-    if (!resolvedIp) resolvedIp = address;
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith("Blocked:")) throw err;
+    if (!resolvedIp) resolvedIp = v6Result.value.address;
+  } else {
     v6Error = true;
   }
   if (v4Error && v6Error) {
@@ -22216,17 +22275,20 @@ function sanitizeQuery(raw) {
   const words = q.split(/\s+/).filter((w) => w.length >= 2).map((w) => `"${w}"`);
   return words.length > 0 ? words.join(" OR ") : "";
 }
-function levenshtein(a, b) {
+function levenshtein(a, b, maxDist) {
   if (a.length === 0) return b.length;
   if (b.length === 0) return a.length;
   let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
   let curr = new Array(b.length + 1);
   for (let i = 1; i <= a.length; i++) {
     curr[0] = i;
+    let rowMin = curr[0];
     for (let j = 1; j <= b.length; j++) {
       const cost = a[i - 1] === b[j - 1] ? 0 : 1;
       curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      if (curr[j] < rowMin) rowMin = curr[j];
     }
+    if (maxDist !== void 0 && rowMin > maxDist) return maxDist + 1;
     [prev, curr] = [curr, prev];
   }
   return prev[b.length];
@@ -22422,7 +22484,7 @@ var ContentStore = class {
       let bestWord = word;
       let bestDist = maxDist + 1;
       for (const { word: candidate } of candidates) {
-        const dist = levenshtein(word.toLowerCase(), candidate.toLowerCase());
+        const dist = levenshtein(word.toLowerCase(), candidate.toLowerCase(), maxDist);
         if (dist < bestDist && dist <= maxDist) {
           bestDist = dist;
           bestWord = candidate;
@@ -22439,7 +22501,8 @@ var ContentStore = class {
   updateVocabulary(content) {
     const currentCount = this.vocabCountStmt.get().cnt;
     if (currentCount >= MAX_VOCABULARY) return;
-    const words = content.split(WORD_SPLIT_RE).filter((w) => w.length >= 3 && !STOPWORDS.has(w.toLowerCase()));
+    const sample = content.length > 51200 ? content.slice(0, 51200) : content;
+    const words = sample.split(WORD_SPLIT_RE).filter((w) => w.length >= 3 && !STOPWORDS.has(w.toLowerCase()));
     const unique = new Set(words.map((w) => w.toLowerCase()));
     const insert = this.vocabInsertStmt;
     let added = 0;
@@ -22677,45 +22740,6 @@ function compactLabel(normal, level) {
   }
   return normal;
 }
-async function limitConcurrency(tasks, limit) {
-  const results = new Array(tasks.length);
-  let nextIndex = 0;
-  async function runNext() {
-    while (nextIndex < tasks.length) {
-      const index = nextIndex++;
-      try {
-        const value = await tasks[index]();
-        results[index] = { status: "fulfilled", value };
-      } catch (reason) {
-        results[index] = { status: "rejected", reason };
-      }
-    }
-  }
-  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => runNext());
-  await Promise.all(workers);
-  return results;
-}
-function detectInjectionPatterns(content) {
-  const warnings = [];
-  const patterns = [
-    { re: /ignore\s+(all\s+)?previous\s+instructions/i, label: "instruction override" },
-    { re: /you\s+are\s+now\s+/i, label: "role reassignment" },
-    {
-      re: /(?:^|\n)\s*system\s*:\s*(?:you are|you're|as an? )/im,
-      label: "system prompt injection"
-    },
-    { re: /\[INST\]|\[\/INST\]|<\|im_start\|>|<\|im_end\|>/i, label: "chat template injection" },
-    { re: /\n\n(?:Human|Assistant):/m, label: "chat delimiter injection" },
-    { re: /reveal\s+(your|the)\s+(system|secret|confidential)/i, label: "data exfiltration" },
-    { re: /act\s+as\s+(if\s+you\s+are|a)\s+/i, label: "role manipulation" }
-  ];
-  for (const { re, label } of patterns) {
-    if (re.test(content)) {
-      warnings.push(label);
-    }
-  }
-  return warnings;
-}
 async function createServer(config3) {
   const version2 = getVersion();
   debug("Version:", version2);
@@ -22734,6 +22758,20 @@ async function createServer(config3) {
     dbFallback = true;
   }
   const tracker = new SessionTracker();
+  let activeExecutions = 0;
+  const MAX_CONCURRENT_EXECUTIONS = 8;
+  const EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
+  async function withExecutionLimit(fn) {
+    if (activeExecutions >= MAX_CONCURRENT_EXECUTIONS) {
+      throw new Error(EXECUTION_LIMIT_ERROR);
+    }
+    activeExecutions++;
+    try {
+      return await fn();
+    } finally {
+      activeExecutions--;
+    }
+  }
   function applyIntentFilter(output, intent, sourceLabel) {
     if (Buffer.byteLength(output) <= config3.intentSearchThreshold) return output;
     const indexed = store.index(output, sourceLabel);
@@ -22758,6 +22796,10 @@ Searchable terms: ${terms.join(", ")}
     return compactLabel(filtered, config3.compressionLevel);
   }
   const shutdown = () => {
+    try {
+      executor.shutdown();
+    } catch {
+    }
     try {
       store.close();
     } catch {
@@ -22766,6 +22808,16 @@ Searchable terms: ${terms.join(", ")}
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   process.on("beforeExit", shutdown);
+  process.on("uncaughtException", (err) => {
+    debug("Uncaught exception:", err);
+    shutdown();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (err) => {
+    debug("Unhandled rejection:", err);
+    shutdown();
+    process.exit(1);
+  });
   const searchCalls = [];
   const server2 = new McpServer({
     name: "context-compress",
@@ -22787,7 +22839,24 @@ PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, py
       timeout: external_exports.number().default(3e4).describe("Max execution time in ms")
     },
     async ({ language, code, intent, timeout }) => {
-      const result = await executor.execute({ language, code, timeout });
+      const codeBytes = Buffer.byteLength(code);
+      if (codeBytes > 1024e3) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`
+            }
+          ]
+        };
+      }
+      let result;
+      try {
+        result = await withExecutionLimit(() => executor.execute({ language, code, timeout }));
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: msg }] };
+      }
       if (result.networkBytes) {
         tracker.trackSandboxed(result.networkBytes);
       }
@@ -22819,6 +22888,17 @@ ${result.stderr}`;
       timeout: external_exports.number().default(3e4).describe("Max execution time in ms")
     },
     async ({ path: filePath, language, code, intent, timeout }) => {
+      const codeBytes = Buffer.byteLength(code);
+      if (codeBytes > 1024e3) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`
+            }
+          ]
+        };
+      }
       const absPath = resolve(projectDir, filePath);
       if (!isWithinProject(absPath)) {
         return {
@@ -22830,12 +22910,20 @@ ${result.stderr}`;
           ]
         };
       }
-      const result = await executor.executeFile({
-        language,
-        code,
-        filePath: absPath,
-        timeout
-      });
+      let result;
+      try {
+        result = await withExecutionLimit(
+          () => executor.executeFile({
+            language,
+            code,
+            filePath: absPath,
+            timeout
+          })
+        );
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: msg }] };
+      }
       let output = result.stdout;
       if (result.stderr && result.exitCode !== 0) {
         output += `
@@ -23020,11 +23108,19 @@ ${hit.snippet}
       }
       const label = source ?? url;
       const fetchCode = buildFetchCode(url, resolvedIp);
-      const result = await executor.execute({
-        language: "javascript",
-        code: fetchCode,
-        timeout: 3e4
-      });
+      let result;
+      try {
+        result = await withExecutionLimit(
+          () => executor.execute({
+            language: "javascript",
+            code: fetchCode,
+            timeout: 3e4
+          })
+        );
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: msg }] };
+      }
       if (result.exitCode !== 0 || !result.stdout.trim()) {
         const errMsg = `Failed to fetch ${url}: ${result.stderr || "empty response"}`;
         tracker.trackCall("fetch_and_index", Buffer.byteLength(errMsg));
@@ -23076,11 +23172,13 @@ Searchable terms: ${terms.join(", ")}`;
     async ({ commands, queries, timeout }) => {
       const commandResults = await limitConcurrency(
         commands.map((cmd) => async () => {
-          const result = await executor.execute({
-            language: "shell",
-            code: cmd.command,
-            timeout
-          });
+          const result = await withExecutionLimit(
+            () => executor.execute({
+              language: "shell",
+              code: cmd.command,
+              timeout
+            })
+          );
           return { label: cmd.label, result };
         }),
         4
@@ -23262,7 +23360,14 @@ const resp = await fetch(url, { redirect: 'error' });`;
   }
   return `${fetchSetup}
 if (!resp.ok) { console.error("HTTP " + resp.status); process.exit(1); }
+const cl = resp.headers.get('content-length');
+if (cl && parseInt(cl, 10) > 10 * 1024 * 1024) {
+    console.error("Response too large: " + cl + " bytes"); process.exit(1);
+}
 const html = await resp.text();
+if (html.length > 10 * 1024 * 1024) {
+    console.error("Response body too large: " + html.length + " chars"); process.exit(1);
+}
 
 // Strip unwanted tags
 let md = html