@n0zer0d4y/vulcan-file-ops 1.2.14 → 1.3.0

package/dist/utils/regex-worker.js

@@ -0,0 +1,262 @@
+/**
+ * Time-bounded regular expression evaluation for grep_files (audit VFO-14).
+ *
+ * Patterns passed to grep_files come from the model and file contents may be
+ * attacker-authored. JavaScript's backtracking engine is exponential on
+ * patterns like `^(a+)+$`, and running such a match on the main event loop
+ * freezes the whole single-threaded server. All regex evaluation against file
+ * content therefore runs inside a `worker_threads` Worker with a hard time
+ * budget; when the budget is exceeded the worker is terminated and the grep
+ * call fails with a clear error.
+ *
+ * The worker is created from an inline plain-JavaScript source string with
+ * `{ eval: true }` instead of a separate file. A file path would have to be
+ * resolved through `import.meta.url` in the compiled ESM build and through a
+ * different mechanism under ts-jest; the eval form behaves identically in both.
+ */
+import { Worker } from "worker_threads";
+/** Default time budget for evaluating the pattern against a single file. */
+export const DEFAULT_GREP_REGEX_FILE_TIMEOUT_MS = 5_000;
+/** Default cumulative regex evaluation budget for one grep_files call. */
+export const DEFAULT_GREP_REGEX_TOTAL_TIMEOUT_MS = 30_000;
+/**
+ * Self-contained worker source. Plain JavaScript only; the sole dependency is
+ * `worker_threads`. It mirrors the matching logic grepFilesWithValidation used
+ * to run on the main thread so results stay identical:
+ *
+ * - single-line mode: test every line of the CRLF-normalized content with the
+ *   non-global regex (flags + nothing) and report matching line indices;
+ * - multiline mode: count matches of the global regex (flags + "g", no dotAll)
+ *   over the raw content, then, if requested and there was a match, report the
+ *   indices of normalized lines on which the dotAll regex (flags + "s") tests
+ *   true.
+ *
+ * `maxLineMatches` lets the caller stop line scanning once it has as many
+ * matching lines as it will consume (head_limit); null means "all".
+ */
+const WORKER_SOURCE = `
+"use strict";
+const { parentPort } = require("worker_threads");
+const cache = new Map();
+function getRegex(pattern, flags) {
+  const key = flags + "\\u0000" + pattern;
+  let re = cache.get(key);
+  if (re === undefined) {
+    re = new RegExp(pattern, flags);
+    cache.set(key, re);
+  }
+  return re;
+}
+function collectLines(content, re, maxLineMatches) {
+  const indices = [];
+  if (maxLineMatches !== null && maxLineMatches <= 0) return indices;
+  const lines = content.replace(/\\r\\n/g, "\\n").split("\\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) {
+      indices.push(i);
+      if (maxLineMatches !== null && indices.length >= maxLineMatches) break;
+    }
+  }
+  return indices;
+}
+parentPort.on("message", (msg) => {
+  const { id, content, pattern, flags, multiline, needLines, maxLineMatches } = msg;
+  try {
+    const limit = typeof maxLineMatches === "number" ? maxLineMatches : null;
+    if (multiline) {
+      const globalRe = getRegex(pattern, flags + "g");
+      const matches = content.match(globalRe);
+      const globalMatchCount = matches ? matches.length : 0;
+      let lineIndices = [];
+      if (matches && needLines) {
+        lineIndices = collectLines(content, getRegex(pattern, flags + "s"), limit);
+      }
+      parentPort.postMessage({ id, ok: true, hasGlobalMatch: matches !== null, globalMatchCount, lineIndices });
+    } else {
+      const lineIndices = collectLines(content, getRegex(pattern, flags), limit);
+      parentPort.postMessage({ id, ok: true, hasGlobalMatch: false, globalMatchCount: 0, lineIndices });
+    }
+  } catch (error) {
+    parentPort.postMessage({ id, ok: false, error: error && error.message ? String(error.message) : String(error) });
+  }
+});
+`;
+/**
+ * Base class for failures of the regex evaluation machinery (timeouts, worker
+ * crashes). grepFilesWithValidation rethrows these instead of treating them as
+ * "skip this file", so a timed-out search fails loudly rather than silently
+ * returning partial results.
+ */
+export class RegexEvaluationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RegexEvaluationError";
+    }
+}
+export class RegexTimeoutError extends RegexEvaluationError {
+    constructor(message) {
+        super(message);
+        this.name = "RegexTimeoutError";
+    }
+}
+/**
+ * One worker reused for every file of a single grep call. Requests are
+ * evaluated strictly one at a time. Always call dispose() when done.
+ */
+export class RegexEvaluationSession {
+    worker = null;
+    online = null;
+    pending = null;
+    nextId = 1;
+    spentMs = 0;
+    fileTimeoutMs;
+    totalTimeoutMs;
+    constructor(options = {}) {
+        this.fileTimeoutMs =
+            options.fileTimeoutMs ?? DEFAULT_GREP_REGEX_FILE_TIMEOUT_MS;
+        this.totalTimeoutMs =
+            options.totalTimeoutMs ?? DEFAULT_GREP_REGEX_TOTAL_TIMEOUT_MS;
+    }
+    startWorker() {
+        if (this.worker && this.online)
+            return this.online;
+        const worker = new Worker(WORKER_SOURCE, { eval: true });
+        this.worker = worker;
+        this.online = new Promise((resolve, reject) => {
+            const cleanup = () => {
+                worker.off("online", onOnline);
+                worker.off("error", onEarlyError);
+                worker.off("exit", onEarlyExit);
+            };
+            const onOnline = () => {
+                cleanup();
+                resolve();
+            };
+            const onEarlyError = (error) => {
+                cleanup();
+                reject(new RegexEvaluationError(`Regex worker failed to start: ${error.message}`));
+            };
+            const onEarlyExit = (code) => {
+                cleanup();
+                reject(new RegexEvaluationError(`Regex worker exited during start-up (code ${code})`));
+            };
+            worker.once("online", onOnline);
+            worker.once("error", onEarlyError);
+            worker.once("exit", onEarlyExit);
+        });
+        worker.on("message", (message) => {
+            const pending = this.pending;
+            if (!pending || !message || message.id !== pending.id)
+                return;
+            this.pending = null;
+            if (message.ok) {
+                pending.resolve({
+                    hasGlobalMatch: message.hasGlobalMatch,
+                    globalMatchCount: message.globalMatchCount,
+                    lineIndices: message.lineIndices,
+                });
+            }
+            else {
+                pending.reject(new RegexEvaluationError(`Regex evaluation failed: ${String(message.error)}`));
+            }
+        });
+        worker.on("error", (error) => {
+            this.failPending(new RegexEvaluationError(`Regex worker crashed: ${error.message}`));
+            this.discardWorker(worker);
+        });
+        worker.on("exit", (code) => {
+            this.failPending(new RegexEvaluationError(`Regex worker exited unexpectedly (code ${code})`));
+            this.discardWorker(worker);
+        });
+        return this.online;
+    }
+    failPending(error) {
+        const pending = this.pending;
+        if (pending) {
+            this.pending = null;
+            pending.reject(error);
+        }
+    }
+    discardWorker(worker) {
+        if (this.worker === worker) {
+            this.worker = null;
+            this.online = null;
+        }
+    }
+    /**
+     * Evaluate one file's content. `label` (usually the file path) is used in
+     * error messages only. Rejects with RegexTimeoutError when the per-file or
+     * cumulative budget is exhausted; the worker is terminated in that case.
+     */
+    async evaluate(request, label) {
+        const remainingTotal = this.totalTimeoutMs - this.spentMs;
+        if (remainingTotal <= 0) {
+            throw new RegexTimeoutError(this.totalTimeoutMessage(label));
+        }
+        const limitedByTotal = remainingTotal < this.fileTimeoutMs;
+        const timeoutMs = limitedByTotal ? remainingTotal : this.fileTimeoutMs;
+        // Worker start-up is not charged against the regex budget.
+        await this.startWorker();
+        const worker = this.worker;
+        if (!worker) {
+            throw new RegexEvaluationError("Regex worker is not available");
+        }
+        const id = this.nextId++;
+        const startedAt = performance.now();
+        let timer;
+        try {
+            return await new Promise((resolve, reject) => {
+                this.pending = { id, resolve, reject };
+                timer = setTimeout(() => {
+                    if (!this.pending || this.pending.id !== id)
+                        return;
+                    this.pending = null;
+                    this.discardWorker(worker);
+                    // Fire-and-forget: terminate() stops the thread even while it is
+                    // stuck inside a backtracking match.
+                    void worker.terminate().catch(() => { });
+                    reject(new RegexTimeoutError(limitedByTotal
+                        ? this.totalTimeoutMessage(label)
+                        : `Regex evaluation timed out after ${this.fileTimeoutMs}ms in ${label} ` +
+                            `(the pattern may cause catastrophic backtracking); simplify the pattern`));
+                }, timeoutMs);
+                const message = {
+                    id,
+                    content: request.content,
+                    pattern: request.pattern,
+                    flags: request.flags,
+                    multiline: request.multiline,
+                    needLines: request.needLines,
+                    maxLineMatches: request.maxLineMatches === undefined
+                        ? null
+                        : request.maxLineMatches,
+                };
+                worker.postMessage(message);
+            });
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            this.spentMs += performance.now() - startedAt;
+        }
+    }
+    totalTimeoutMessage(label) {
+        return (`Regex evaluation exceeded the total time budget of ${this.totalTimeoutMs}ms ` +
+            `for this search (stopped at ${label}); the pattern may cause catastrophic ` +
+            `backtracking - simplify the pattern or narrow the search path`);
+    }
+    /** Terminate the worker (if any). Safe to call multiple times. */
+    async dispose() {
+        const worker = this.worker;
+        this.worker = null;
+        this.online = null;
+        this.failPending(new RegexEvaluationError("Regex worker disposed"));
+        if (worker) {
+            worker.removeAllListeners("exit");
+            worker.removeAllListeners("error");
+            worker.on("error", () => { });
+            await worker.terminate().catch(() => { });
+        }
+    }
+}
+//# sourceMappingURL=regex-worker.js.map

package/dist/utils/shell-parser.js

@@ -0,0 +1,225 @@
+/**
+ * Conservative command-line parser for execute_shell.
+ *
+ * Commands run under `bash -c` (POSIX) or `powershell -Command` (Windows). The
+ * approval and path checks are only sound if this parser sees at least every
+ * command and every file operand the real shell will see. So it accepts a
+ * small grammar both shells agree on and rejects everything else instead of
+ * guessing:
+ *
+ * - simple commands joined by `;`, `&&`, `||` and `|`
+ * - single- and double-quoted strings (backslash is never an escape)
+ * - redirections, whose targets are reported so they can be path-validated
+ *
+ * Rejected: newlines and control characters, backticks, `\"` / `\'`, Unicode
+ * quotes, a lone `&`, `(`/`)`/`{`/`}` grouping and script blocks, heredocs,
+ * process substitution, and PowerShell's `--%` stop-parsing token.
+ */
+export class ShellSyntaxError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ShellSyntaxError";
+    }
+}
+// Tab is allowed; everything else below 0x20, DEL, NEL and the Unicode line
+// and paragraph separators can act as command separators.
+const CONTROL_CHARS = /[\x00-\x08\x0a-\x1f\x7f\u0085\u2028\u2029]/;
+// PowerShell treats these as quote characters; this parser does not.
+const UNICODE_QUOTES = /[\u2018\u2019\u201a\u201b\u201c\u201d\u201e\u201f]/;
+const NULL_DEVICES = new Set(["/dev/null", "$null", "nul"]);
+export function parseShellCommand(command) {
+    if (CONTROL_CHARS.test(command)) {
+        throw new ShellSyntaxError("newlines and control characters are not allowed in commands (chain commands with ';' instead; '&&' also works in bash)");
+    }
+    if (UNICODE_QUOTES.test(command)) {
+        throw new ShellSyntaxError("typographic (Unicode) quote characters are not allowed; use plain ' or \" quotes");
+    }
+    if (command.includes("`")) {
+        throw new ShellSyntaxError("backticks are not allowed (command substitution in bash, escape character in PowerShell)");
+    }
+    if (command.includes('\\"') || command.includes("\\'")) {
+        throw new ShellSyntaxError("backslash-escaped quotes are not allowed because bash and PowerShell interpret them differently");
+    }
+    if (/(^|\s)--%(\s|$)/.test(command)) {
+        throw new ShellSyntaxError("the PowerShell stop-parsing token '--%' is not allowed");
+    }
+    const segments = [];
+    let words = [];
+    let redirects = [];
+    let segmentStart = 0;
+    let i = 0;
+    const isWhitespace = (c) => c === " " || c === "\t";
+    const isOperatorChar = (c) => ";|&<>(){}".includes(c);
+    const endSegment = (end) => {
+        const raw = command.slice(segmentStart, end).trim();
+        if (words.length > 0 || redirects.length > 0) {
+            segments.push({ words, redirects, raw });
+        }
+        words = [];
+        redirects = [];
+    };
+    // Reads one word starting at i (quotes allowed); stops at whitespace or an
+    // operator character outside quotes.
+    const readWord = () => {
+        let value = "";
+        let quoted = false;
+        let singleQuoted = false;
+        let started = false;
+        while (i < command.length) {
+            const c = command[i];
+            if (isWhitespace(c) || isOperatorChar(c)) {
+                // `{}` as a standalone word (find -exec ... {} ;) is a literal.
+                if (c === "{" &&
+                    command[i + 1] === "}" &&
+                    !started &&
+                    (i + 2 >= command.length || isWhitespace(command[i + 2]))) {
+                    value += "{}";
+                    started = true;
+                    i += 2;
+                    continue;
+                }
+                // `${NAME}` parameter expansion stays part of the word.
+                if (c === "{" && value.endsWith("$")) {
+                    const close = command.indexOf("}", i);
+                    if (close === -1) {
+                        throw new ShellSyntaxError("unterminated ${...} expansion");
+                    }
+                    value += command.slice(i, close + 1);
+                    i = close + 1;
+                    continue;
+                }
+                break;
+            }
+            if (c === "'" || c === '"') {
+                const close = command.indexOf(c, i + 1);
+                if (close === -1) {
+                    throw new ShellSyntaxError(`unterminated ${c} quote`);
+                }
+                value += command.slice(i + 1, close);
+                quoted = true;
+                started = true;
+                if (c === "'") {
+                    singleQuoted = true;
+                }
+                i = close + 1;
+                continue;
+            }
+            value += c;
+            started = true;
+            i++;
+        }
+        return started ? { value, quoted, singleQuoted } : null;
+    };
+    const readRedirect = () => {
+        // A preceding unquoted all-digit word or `*` is the redirect's fd, not an argument.
+        const previous = words[words.length - 1];
+        const previousEnd = i > 0 ? command[i - 1] : " ";
+        if (previous &&
+            !previous.quoted &&
+            !isWhitespace(previousEnd) &&
+            /^(\d+|\*)$/.test(previous.value)) {
+            words.pop();
+        }
+        let operator = command[i];
+        i++;
+        if (operator === "<" && command[i] === "<") {
+            throw new ShellSyntaxError("heredocs and here-strings are not allowed");
+        }
+        if (operator === "<" && command[i] === ">") {
+            throw new ShellSyntaxError("'<>' redirection is not allowed");
+        }
+        if (operator === ">" && (command[i] === ">" || command[i] === "|")) {
+            operator += command[i];
+            i++;
+        }
+        // fd duplication: 2>&1, >&2, <&0, >&-
+        if (command[i] === "&") {
+            const fd = /^&(\d+|-)/.exec(command.slice(i));
+            if (fd) {
+                i += fd[0].length;
+                redirects.push({ operator: `${operator}${fd[0]}`, target: null });
+                return;
+            }
+            operator += "&";
+            i++;
+        }
+        while (i < command.length && isWhitespace(command[i])) {
+            i++;
+        }
+        const target = readWord();
+        if (!target || !target.value) {
+            throw new ShellSyntaxError(`redirection '${operator}' has no target`);
+        }
+        redirects.push({
+            operator,
+            target: NULL_DEVICES.has(target.value.toLowerCase()) ? null : target,
+        });
+    };
+    while (i < command.length) {
+        const c = command[i];
+        if (isWhitespace(c)) {
+            i++;
+            continue;
+        }
+        if (c === ";") {
+            endSegment(i);
+            i++;
+            segmentStart = i;
+            continue;
+        }
+        if (c === "|") {
+            endSegment(i);
+            i += command[i + 1] === "|" ? 2 : 1;
+            segmentStart = i;
+            continue;
+        }
+        if (c === "&") {
+            if (command[i + 1] === "&") {
+                endSegment(i);
+                i += 2;
+                segmentStart = i;
+                continue;
+            }
+            if (command[i + 1] === ">") {
+                // bash `&>file` / `&>>file`: both streams to a file.
+                i++;
+                readRedirect();
+                continue;
+            }
+            throw new ShellSyntaxError("a single '&' (background job / PowerShell call operator) is not allowed; use ';' to chain commands ('&&' also works in bash)");
+        }
+        if (c === ">" || c === "<") {
+            if (command[i + 1] === "(") {
+                throw new ShellSyntaxError("process substitution is not allowed");
+            }
+            readRedirect();
+            continue;
+        }
+        if ("(){}".includes(c)) {
+            const word = c === "{" ? readWord() : null;
+            if (word) {
+                words.push(word);
+                continue;
+            }
+            throw new ShellSyntaxError("grouping, subshells and script blocks ('(', ')', '{', '}') are not allowed outside quotes");
+        }
+        const word = readWord();
+        if (word) {
+            words.push(word);
+        }
+    }
+    endSegment(command.length);
+    return { segments };
+}
+/** First word of every segment, in order, without duplicates. */
+export function getRootCommands(parsed) {
+    const roots = [];
+    for (const segment of parsed.segments) {
+        const root = segment.words[0]?.value;
+        if (root && !roots.includes(root)) {
+            roots.push(root);
+        }
+    }
+    return roots;
+}
+//# sourceMappingURL=shell-parser.js.map