open-managed-agents 0.1.0

package/dist/src/control-plane/sessions/pi/sandbox/cma-glob.js

@@ -0,0 +1,388 @@
+export const CMA_GLOB_READY_MARKER = "__OMA_GLOB_READY__";
+const MAX_PATTERN_BYTES = 1_024;
+const MAX_BRACE_DEPTH = 4;
+const MAX_ALTERNATIVES = 64;
+const MAX_CLASS_BYTES = 256;
+const MAX_COMPILED_STATES = 4_096;
+export class CmaGlobReadinessFilter {
+    expectedToken;
+    pending = Buffer.alloc(0);
+    ready = false;
+    constructor(expectedToken) {
+        this.expectedToken = expectedToken;
+    }
+    push(chunk) {
+        if (this.ready)
+            return chunk;
+        this.pending = Buffer.concat([this.pending, chunk]);
+        const delimiter = this.pending.indexOf(0);
+        if (delimiter < 0) {
+            if (this.pending.length > 256)
+                throw new Error("Glob readiness marker exceeds limit");
+            return undefined;
+        }
+        const marker = this.pending.subarray(0, delimiter).toString("utf8");
+        if (marker !== this.expectedToken)
+            throw new Error("Invalid glob readiness marker");
+        this.ready = true;
+        const remainder = this.pending.subarray(delimiter + 1);
+        this.pending = Buffer.alloc(0);
+        return remainder.length === 0 ? undefined : remainder;
+    }
+    assertReady() {
+        if (!this.ready)
+            throw new Error("Glob process did not publish readiness");
+    }
+}
+export class CmaGlobStreamCollector {
+    matcher;
+    opts;
+    matches = [];
+    pending = Buffer.alloc(0);
+    rawBytes = 0;
+    outputBytes = 0;
+    limitReached = false;
+    constructor(matcher, opts) {
+        this.matcher = matcher;
+        this.opts = opts;
+    }
+    push(chunk) {
+        if (this.limitReached)
+            return;
+        this.rawBytes += chunk.byteLength;
+        if (this.rawBytes > this.opts.maxRawBytes) {
+            throw new Error(`Glob enumeration exceeds ${this.opts.maxRawBytes} raw bytes`);
+        }
+        this.pending = Buffer.concat([this.pending, chunk]);
+        for (;;) {
+            const delimiter = this.pending.indexOf(0);
+            if (delimiter < 0)
+                return;
+            const record = this.pending.subarray(0, delimiter);
+            this.pending = this.pending.subarray(delimiter + 1);
+            this.accept(record);
+            if (this.limitReached)
+                return;
+        }
+    }
+    finish() {
+        if (!this.limitReached && this.pending.length !== 0) {
+            throw new Error("Glob enumeration returned an unterminated filename");
+        }
+    }
+    accept(record) {
+        if (record.includes(0))
+            throw new Error("Glob filename contains NUL");
+        let relativePath = record.toString("utf8");
+        if (relativePath.startsWith("./"))
+            relativePath = relativePath.slice(2);
+        if (relativePath.length === 0 || !this.matcher.matches(relativePath))
+            return;
+        const absolutePath = this.opts.join(this.opts.root, relativePath);
+        const outputPath = this.opts.formatForOutput?.(absolutePath, relativePath) ?? absolutePath;
+        const addedBytes = Buffer.byteLength(outputPath, "utf8") +
+            (this.matches.length === 0 ? 0 : 1);
+        if (this.outputBytes + addedBytes > this.opts.maxOutputBytes) {
+            throw new Error(`Glob output exceeds ${this.opts.maxOutputBytes} bytes`);
+        }
+        this.outputBytes += addedBytes;
+        this.matches.push(absolutePath);
+        if (this.matches.length >= this.opts.maxMatches) {
+            this.limitReached = true;
+            this.opts.onLimit();
+        }
+    }
+}
+export class CmaGlobPatternError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CmaGlobPatternError";
+    }
+}
+export function compileCmaGlob(pattern) {
+    if (Buffer.byteLength(pattern, "utf8") > MAX_PATTERN_BYTES) {
+        throw patternError(`pattern exceeds ${MAX_PATTERN_BYTES} bytes`);
+    }
+    assertBraceDepth(pattern);
+    const alternatives = expandBraces(pattern);
+    // CMA plain patterns match at any descendant basename. Encode that as one
+    // NFA prefix instead of rescanning every slash-delimited suffix.
+    const tokenSets = alternatives.map((alternative) => [
+        { type: "globstarPrefix" },
+        ...tokenize(alternative),
+    ]);
+    const compiledStates = tokenSets.reduce((total, tokens) => total + tokens.length + 1, 0);
+    if (compiledStates > MAX_COMPILED_STATES) {
+        throw patternError(`compiled states exceed ${MAX_COMPILED_STATES}`);
+    }
+    return {
+        matches(value) {
+            // Provider boundaries normalize platform separators. Backslash remains a
+            // valid POSIX filename character and must not be rewritten here.
+            return tokenSets.some((tokens) => matchTokens(tokens, value));
+        },
+    };
+}
+/** Translate CMA's implicit descendant-suffix matching to ripgrep's
+ * root-relative glob syntax. Both grammars share the validated wildcard,
+ * class, brace, and escape forms used by CMA; the anchoring rule differs. */
+export function cmaGlobToRipgrepGlob(pattern) {
+    compileCmaGlob(pattern);
+    return pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+}
+function expandBraces(pattern) {
+    let escaped = false;
+    let open = -1;
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "}")
+            throw patternError("unmatched closing brace");
+        if (char === "{") {
+            open = index;
+            break;
+        }
+    }
+    if (escaped)
+        throw patternError("trailing escape");
+    if (open < 0)
+        return [pattern];
+    const parts = [];
+    let nested = 0;
+    let partStart = open + 1;
+    let close = -1;
+    escaped = false;
+    for (let index = open + 1; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+        }
+        else if (char === "{") {
+            nested += 1;
+        }
+        else if (char === "}" && nested > 0) {
+            nested -= 1;
+        }
+        else if (char === "}" && nested === 0) {
+            parts.push(pattern.slice(partStart, index));
+            close = index;
+            break;
+        }
+        else if (char === "," && nested === 0) {
+            parts.push(pattern.slice(partStart, index));
+            partStart = index + 1;
+        }
+    }
+    if (close < 0)
+        throw patternError("unclosed brace");
+    if (parts.length < 2 || parts.some((part) => part.length === 0)) {
+        throw patternError("brace expression requires non-empty alternatives");
+    }
+    const prefix = pattern.slice(0, open);
+    const suffix = pattern.slice(close + 1);
+    const expanded = [];
+    for (const part of parts) {
+        for (const value of expandBraces(`${prefix}${part}${suffix}`)) {
+            expanded.push(value);
+            if (expanded.length > MAX_ALTERNATIVES) {
+                throw patternError(`expanded alternatives exceed ${MAX_ALTERNATIVES}`);
+            }
+        }
+    }
+    return expanded;
+}
+function assertBraceDepth(pattern) {
+    let depth = 0;
+    let escaped = false;
+    for (const char of pattern) {
+        if (escaped) {
+            escaped = false;
+        }
+        else if (char === "\\") {
+            escaped = true;
+        }
+        else if (char === "{") {
+            depth += 1;
+            if (depth > MAX_BRACE_DEPTH) {
+                throw patternError(`brace nesting exceeds ${MAX_BRACE_DEPTH}`);
+            }
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth < 0)
+                throw patternError("unmatched closing brace");
+        }
+    }
+    if (depth !== 0)
+        throw patternError("unclosed brace");
+}
+function tokenize(pattern) {
+    const tokens = [];
+    for (let index = 0; index < pattern.length;) {
+        const char = pattern[index];
+        if (char === "\\") {
+            const escaped = codePointAt(pattern, index + 1);
+            if (escaped === undefined)
+                throw patternError("trailing escape");
+            tokens.push({ type: "literal", value: escaped.value });
+            index = escaped.next;
+        }
+        else if (char === "*") {
+            if (pattern[index + 1] === "*" && pattern[index + 2] === "/") {
+                tokens.push({ type: "globstarPrefix" });
+                index += 3;
+            }
+            else if (pattern[index + 1] === "*") {
+                tokens.push({ type: "globstar" });
+                index += 2;
+            }
+            else {
+                tokens.push({ type: "star" });
+                index += 1;
+            }
+        }
+        else if (char === "?") {
+            tokens.push({ type: "any" });
+            index += 1;
+        }
+        else if (char === "[") {
+            const parsed = parseClass(pattern, index);
+            tokens.push(parsed.token);
+            index = parsed.end + 1;
+        }
+        else if (char === "]") {
+            throw patternError("unmatched closing bracket");
+        }
+        else {
+            const literal = codePointAt(pattern, index);
+            tokens.push({ type: "literal", value: literal.value });
+            index = literal.next;
+        }
+    }
+    return tokens;
+}
+function parseClass(pattern, start) {
+    let end = start + 1;
+    let escaped = false;
+    for (; end < pattern.length; end += 1) {
+        const char = pattern[end];
+        if (escaped)
+            escaped = false;
+        else if (char === "\\")
+            escaped = true;
+        else if (char === "]")
+            break;
+    }
+    if (end >= pattern.length)
+        throw patternError("unclosed character class");
+    const source = pattern.slice(start + 1, end);
+    if (Buffer.byteLength(source, "utf8") > MAX_CLASS_BYTES) {
+        throw patternError(`character class exceeds ${MAX_CLASS_BYTES} bytes`);
+    }
+    let offset = 0;
+    const negated = source[0] === "!" || source[0] === "^";
+    if (negated)
+        offset = 1;
+    const chars = [];
+    while (offset < source.length) {
+        let escaped = false;
+        if (source[offset] === "\\") {
+            escaped = true;
+            offset += 1;
+            if (offset >= source.length)
+                throw patternError("trailing escape in character class");
+        }
+        const item = codePointAt(source, offset);
+        chars.push({ codePoint: item.value.codePointAt(0), escaped });
+        offset = item.next;
+    }
+    if (chars.length === 0)
+        throw patternError("empty character class");
+    const ranges = [];
+    for (let index = 0; index < chars.length; index += 1) {
+        const separator = chars[index + 1];
+        if (index + 2 < chars.length && separator.codePoint === 45 && !separator.escaped) {
+            if (chars[index].codePoint > chars[index + 2].codePoint) {
+                throw patternError("descending character range");
+            }
+            ranges.push([chars[index].codePoint, chars[index + 2].codePoint]);
+            index += 2;
+        }
+        else {
+            ranges.push([chars[index].codePoint, chars[index].codePoint]);
+        }
+    }
+    return { token: { type: "class", negated, ranges }, end };
+}
+function matchTokens(tokens, value) {
+    const chars = Array.from(value);
+    let states = new Set([0]);
+    states = epsilonClosure(tokens, states);
+    for (const char of chars) {
+        const next = new Set();
+        for (const state of states) {
+            const token = tokens[state];
+            if (token === undefined)
+                continue;
+            if (token.type === "globstar")
+                next.add(state);
+            else if (token.type === "globstarPrefix") {
+                next.add(state);
+                if (char === "/")
+                    next.add(state + 1);
+            }
+            else if (token.type === "star" && char !== "/")
+                next.add(state);
+            else if (token.type === "any" && char !== "/")
+                next.add(state + 1);
+            else if (token.type === "literal" && char === token.value)
+                next.add(state + 1);
+            else if (token.type === "class" && char !== "/" && classMatches(token, char))
+                next.add(state + 1);
+        }
+        states = epsilonClosure(tokens, next);
+        if (states.size === 0)
+            return false;
+    }
+    return epsilonClosure(tokens, states).has(tokens.length);
+}
+function epsilonClosure(tokens, initial) {
+    const states = new Set(initial);
+    const pending = [...states];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        const token = tokens[state];
+        if ((token?.type === "star" || token?.type === "globstar" || token?.type === "globstarPrefix") &&
+            !states.has(state + 1)) {
+            states.add(state + 1);
+            pending.push(state + 1);
+        }
+    }
+    return states;
+}
+function classMatches(token, char) {
+    const codePoint = char.codePointAt(0);
+    const included = token.ranges.some(([start, end]) => codePoint >= start && codePoint <= end);
+    return token.negated ? !included : included;
+}
+function codePointAt(value, index) {
+    const codePoint = value.codePointAt(index);
+    if (codePoint === undefined)
+        return undefined;
+    const character = String.fromCodePoint(codePoint);
+    return { value: character, next: index + character.length };
+}
+function patternError(message) {
+    return new CmaGlobPatternError(`Invalid glob pattern: ${message}`);
+}

package/dist/src/control-plane/sessions/pi/sandbox/cma-grep.js

@@ -0,0 +1,124 @@
+import { posix } from "node:path";
+import { toPosix } from "./glob.js";
+export const CMA_GREP_READY_MARKER = "__OMA_GREP_READY__";
+export const CMA_GREP_MAX_PATTERN_BYTES = 4_096;
+export const CMA_GREP_MAX_PATH_BYTES = 4_096;
+export const CMA_GREP_MAX_MATCHES = 100;
+export const CMA_GREP_MAX_RAW_BYTES = 1024 * 1024;
+export const CMA_GREP_MAX_OUTPUT_BYTES = 64 * 1024;
+export const CMA_GREP_TIMEOUT_MS = 10_000;
+export class CmaGrepInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CmaGrepInputError";
+    }
+}
+export class CmaGrepStreamCollector {
+    opts;
+    matches = [];
+    pending = Buffer.alloc(0);
+    rawBytes = 0;
+    outputBytes = 0;
+    limitReached = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    push(chunk) {
+        if (this.limitReached)
+            return;
+        this.rawBytes += chunk.byteLength;
+        if (this.rawBytes > this.opts.maxRawBytes) {
+            throw new Error(`Grep output exceeds ${this.opts.maxRawBytes} raw bytes`);
+        }
+        this.pending = Buffer.concat([this.pending, chunk]);
+        for (;;) {
+            const delimiter = this.pending.indexOf(0);
+            if (delimiter < 0)
+                return;
+            const record = this.pending.subarray(0, delimiter);
+            this.pending = this.pending.subarray(delimiter + 1);
+            this.accept(record);
+            if (this.limitReached)
+                return;
+        }
+    }
+    finish() {
+        if (!this.limitReached && this.pending.length !== 0) {
+            throw new Error("Grep output returned an unterminated filename");
+        }
+    }
+    accept(record) {
+        if (record.includes(0))
+            throw new Error("Grep filename contains NUL");
+        let path = record.toString("utf8");
+        if (path.startsWith("./"))
+            path = path.slice(2);
+        if (path.length === 0)
+            return;
+        const absolutePath = posix.isAbsolute(path) ? path : this.opts.join(this.opts.root, path);
+        const relativePath = posix.isAbsolute(path)
+            ? relativeToSearchRoot(this.opts.root, absolutePath)
+            : path;
+        if (this.opts.matcher !== undefined && !this.opts.matcher.matches(relativePath))
+            return;
+        const outputPath = this.opts.formatForOutput?.(absolutePath, relativePath) ?? absolutePath;
+        const addedBytes = Buffer.byteLength(outputPath, "utf8") +
+            (this.matches.length === 0 ? 0 : 1);
+        if (this.outputBytes + addedBytes > this.opts.maxOutputBytes) {
+            throw new Error(`Grep output exceeds ${this.opts.maxOutputBytes} bytes`);
+        }
+        this.outputBytes += addedBytes;
+        this.matches.push(absolutePath);
+        if (this.matches.length >= this.opts.maxMatches) {
+            this.limitReached = true;
+            this.opts.onLimit();
+        }
+    }
+}
+function relativeToSearchRoot(root, absolutePath) {
+    const relativePath = posix.relative(root, absolutePath);
+    return relativePath === "" ? posix.basename(absolutePath) : relativePath;
+}
+export function assertCmaGrepPattern(pattern) {
+    if (typeof pattern !== "string" || pattern.length === 0) {
+        throw new CmaGrepInputError("grep pattern is required");
+    }
+    if (Buffer.byteLength(pattern, "utf8") > CMA_GREP_MAX_PATTERN_BYTES) {
+        throw new CmaGrepInputError(`grep pattern exceeds ${CMA_GREP_MAX_PATTERN_BYTES} bytes`);
+    }
+    return pattern;
+}
+export function assertCmaGrepPath(path) {
+    if (typeof path !== "string" || path.length === 0) {
+        throw new CmaGrepInputError("grep path is required");
+    }
+    if (!path.startsWith("/")) {
+        throw new CmaGrepInputError("grep path must be absolute");
+    }
+    if (Buffer.byteLength(path, "utf8") > CMA_GREP_MAX_PATH_BYTES) {
+        throw new CmaGrepInputError(`grep path exceeds ${CMA_GREP_MAX_PATH_BYTES} bytes`);
+    }
+    return path;
+}
+export function assertCmaGrepContext(context) {
+    if (context === undefined)
+        return 0;
+    if (typeof context !== "number" || !Number.isSafeInteger(context) || context < 0 || context > 100) {
+        throw new CmaGrepInputError("grep context must be an integer from 0 through 100");
+    }
+    return context;
+}
+export function assertCmaGrepHeadLimit(headLimit) {
+    if (headLimit === undefined)
+        return CMA_GREP_MAX_MATCHES;
+    if (typeof headLimit !== "number" || !Number.isSafeInteger(headLimit) || headLimit < 1 || headLimit > CMA_GREP_MAX_MATCHES) {
+        throw new CmaGrepInputError(`grep head_limit must be an integer from 1 through ${CMA_GREP_MAX_MATCHES}`);
+    }
+    return headLimit;
+}
+export function formatCmaGrepOutput(matches) {
+    return matches.length === 0 ? "No matches found" : matches.join("\n");
+}
+export function outputRelativeTo(base, absolutePath) {
+    return toPosix(posix.relative(base, absolutePath));
+}