@winspan/claude-forge 8.41.0 → 8.50.6

package/dist/engine/dsl/compiler.js

@@ -1,702 +0,0 @@
-/**
- * Convention DSL Expression Compiler
- *
- * Compiles chain-call expressions to TypeScript closures.
- *
- * Supported syntax:
- * - Comparison: ==, !=, >, <, >=, <=
- * - Logical: &&, ||, !
- * - Chain calls: obj.method(args)
- * - Property access: obj.prop
- * - Arrow functions: (x => x.prop)
- * - Regex: /pattern/flags
- * - Null coalescing: ??
- * - Template strings: {{expr}} (in messages)
- */
-import { enhanceContext } from './runtime.js';
-// -- Token Types --
-var TokenType;
-(function (TokenType) {
-    TokenType[TokenType["Number"] = 0] = "Number";
-    TokenType[TokenType["String"] = 1] = "String";
-    TokenType[TokenType["Boolean"] = 2] = "Boolean";
-    TokenType[TokenType["Null"] = 3] = "Null";
-    TokenType[TokenType["Regex"] = 4] = "Regex";
-    TokenType[TokenType["Identifier"] = 5] = "Identifier";
-    TokenType[TokenType["Dot"] = 6] = "Dot";
-    TokenType[TokenType["LeftParen"] = 7] = "LeftParen";
-    TokenType[TokenType["RightParen"] = 8] = "RightParen";
-    TokenType[TokenType["LeftBracket"] = 9] = "LeftBracket";
-    TokenType[TokenType["RightBracket"] = 10] = "RightBracket";
-    TokenType[TokenType["Comma"] = 11] = "Comma";
-    TokenType[TokenType["Arrow"] = 12] = "Arrow";
-    TokenType[TokenType["Coalesce"] = 13] = "Coalesce";
-    TokenType[TokenType["Eq"] = 14] = "Eq";
-    TokenType[TokenType["Neq"] = 15] = "Neq";
-    TokenType[TokenType["Gt"] = 16] = "Gt";
-    TokenType[TokenType["Gte"] = 17] = "Gte";
-    TokenType[TokenType["Lt"] = 18] = "Lt";
-    TokenType[TokenType["Lte"] = 19] = "Lte";
-    TokenType[TokenType["And"] = 20] = "And";
-    TokenType[TokenType["Or"] = 21] = "Or";
-    TokenType[TokenType["Not"] = 22] = "Not";
-    TokenType[TokenType["Plus"] = 23] = "Plus";
-    TokenType[TokenType["Minus"] = 24] = "Minus";
-    TokenType[TokenType["Star"] = 25] = "Star";
-    TokenType[TokenType["Slash"] = 26] = "Slash";
-    TokenType[TokenType["Percent"] = 27] = "Percent";
-    TokenType[TokenType["EOF"] = 28] = "EOF";
-})(TokenType || (TokenType = {}));
-// -- Lexer --
-class Lexer {
-    source;
-    pos = 0;
-    tokens = [];
-    constructor(source) {
-        this.source = source;
-    }
-    tokenize() {
-        while (this.pos < this.source.length) {
-            this.skipWhitespace();
-            if (this.pos >= this.source.length)
-                break;
-            const ch = this.source[this.pos];
-            if (ch === '/' && this.isRegexStart()) {
-                this.readRegex();
-            }
-            else if (ch === '"' || ch === "'") {
-                this.readString(ch);
-            }
-            else if (this.isDigit(ch)) {
-                this.readNumber();
-            }
-            else if (this.isIdentStart(ch)) {
-                this.readIdentifier();
-            }
-            else {
-                this.readOperator();
-            }
-        }
-        this.tokens.push({ type: TokenType.EOF, value: '', pos: this.pos });
-        return this.tokens;
-    }
-    skipWhitespace() {
-        while (this.pos < this.source.length && /\s/.test(this.source[this.pos])) {
-            this.pos++;
-        }
-    }
-    isDigit(ch) {
-        return ch >= '0' && ch <= '9';
-    }
-    isIdentStart(ch) {
-        return /[a-zA-Z_$]/.test(ch);
-    }
-    isIdentPart(ch) {
-        return /[a-zA-Z0-9_$]/.test(ch);
-    }
-    isRegexStart() {
-        const prev = this.tokens[this.tokens.length - 1];
-        if (!prev)
-            return true;
-        return [
-            TokenType.And, TokenType.Or, TokenType.Not,
-            TokenType.Eq, TokenType.Neq, TokenType.Gt, TokenType.Gte,
-            TokenType.Lt, TokenType.Lte, TokenType.LeftParen,
-            TokenType.Comma, TokenType.Coalesce, TokenType.Arrow,
-        ].includes(prev.type);
-    }
-    readRegex() {
-        const start = this.pos;
-        this.pos++; // skip /
-        let escaped = false;
-        let inCharClass = false;
-        while (this.pos < this.source.length) {
-            const ch = this.source[this.pos];
-            if (escaped) {
-                escaped = false;
-            }
-            else if (ch === '\\') {
-                escaped = true;
-            }
-            else if (ch === '[') {
-                inCharClass = true;
-            }
-            else if (ch === ']') {
-                inCharClass = false;
-            }
-            else if (ch === '/' && !inCharClass) {
-                this.pos++;
-                // read flags
-                while (this.pos < this.source.length && /[gimsuy]/.test(this.source[this.pos])) {
-                    this.pos++;
-                }
-                this.tokens.push({
-                    type: TokenType.Regex,
-                    value: this.source.slice(start, this.pos),
-                    pos: start,
-                });
-                return;
-            }
-            this.pos++;
-        }
-        throw new CompileError(`Unterminated regex at position ${start}`, start);
-    }
-    readString(quote) {
-        const start = this.pos;
-        this.pos++; // skip opening quote
-        let value = '';
-        let escaped = false;
-        while (this.pos < this.source.length) {
-            const ch = this.source[this.pos];
-            if (escaped) {
-                value += ch === 'n' ? '\n' : ch === 't' ? '\t' : ch;
-                escaped = false;
-            }
-            else if (ch === '\\') {
-                escaped = true;
-            }
-            else if (ch === quote) {
-                this.pos++;
-                this.tokens.push({ type: TokenType.String, value, pos: start });
-                return;
-            }
-            else {
-                value += ch;
-            }
-            this.pos++;
-        }
-        throw new CompileError(`Unterminated string at position ${start}`, start);
-    }
-    readNumber() {
-        const start = this.pos;
-        while (this.pos < this.source.length && (this.isDigit(this.source[this.pos]) || this.source[this.pos] === '.')) {
-            this.pos++;
-        }
-        this.tokens.push({ type: TokenType.Number, value: this.source.slice(start, this.pos), pos: start });
-    }
-    readIdentifier() {
-        const start = this.pos;
-        while (this.pos < this.source.length && this.isIdentPart(this.source[this.pos])) {
-            this.pos++;
-        }
-        const value = this.source.slice(start, this.pos);
-        if (value === 'true' || value === 'false') {
-            this.tokens.push({ type: TokenType.Boolean, value, pos: start });
-        }
-        else if (value === 'null') {
-            this.tokens.push({ type: TokenType.Null, value, pos: start });
-        }
-        else {
-            this.tokens.push({ type: TokenType.Identifier, value, pos: start });
-        }
-    }
-    readOperator() {
-        const start = this.pos;
-        const ch = this.source[this.pos];
-        const next = this.source[this.pos + 1];
-        // Two-char operators
-        if (ch === '=' && next === '>') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Arrow, value: '=>', pos: start });
-            return;
-        }
-        if (ch === '=' && next === '=') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Eq, value: '==', pos: start });
-            return;
-        }
-        if (ch === '!' && next === '=') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Neq, value: '!=', pos: start });
-            return;
-        }
-        if (ch === '>' && next === '=') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Gte, value: '>=', pos: start });
-            return;
-        }
-        if (ch === '<' && next === '=') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Lte, value: '<=', pos: start });
-            return;
-        }
-        if (ch === '&' && next === '&') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.And, value: '&&', pos: start });
-            return;
-        }
-        if (ch === '|' && next === '|') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Or, value: '||', pos: start });
-            return;
-        }
-        if (ch === '?' && next === '?') {
-            this.pos += 2;
-            this.tokens.push({ type: TokenType.Coalesce, value: '??', pos: start });
-            return;
-        }
-        // Single-char operators
-        const singleOps = {
-            '.': TokenType.Dot,
-            '(': TokenType.LeftParen,
-            ')': TokenType.RightParen,
-            '[': TokenType.LeftBracket,
-            ']': TokenType.RightBracket,
-            ',': TokenType.Comma,
-            '>': TokenType.Gt,
-            '<': TokenType.Lt,
-            '!': TokenType.Not,
-            '+': TokenType.Plus,
-            '-': TokenType.Minus,
-            '*': TokenType.Star,
-            '/': TokenType.Slash,
-            '%': TokenType.Percent,
-        };
-        if (ch in singleOps) {
-            this.pos++;
-            this.tokens.push({ type: singleOps[ch], value: ch, pos: start });
-            return;
-        }
-        throw new CompileError(`Unexpected character '${ch}' at position ${start}`, start);
-    }
-}
-// -- Compile Error --
-export class CompileError extends Error {
-    pos;
-    constructor(message, pos) {
-        super(message);
-        this.pos = pos;
-        this.name = 'CompileError';
-    }
-}
-// -- Parser (Recursive Descent) --
-class Parser {
-    tokens;
-    pos = 0;
-    constructor(tokens) {
-        this.tokens = tokens;
-    }
-    parse() {
-        const node = this.parseExpression();
-        if (this.peek().type !== TokenType.EOF) {
-            throw new CompileError(`Unexpected token '${this.peek().value}' at position ${this.peek().pos}`, this.peek().pos);
-        }
-        return node;
-    }
-    peek() {
-        return this.tokens[this.pos];
-    }
-    advance() {
-        return this.tokens[this.pos++];
-    }
-    expect(type) {
-        const token = this.advance();
-        if (token.type !== type) {
-            throw new CompileError(`Expected ${TokenType[type]} but got '${token.value}' at position ${token.pos}`, token.pos);
-        }
-        return token;
-    }
-    // -- Precedence Climbing --
-    parseExpression() {
-        return this.parseOr();
-    }
-    parseOr() {
-        let left = this.parseAnd();
-        while (this.peek().type === TokenType.Or) {
-            this.advance();
-            const right = this.parseAnd();
-            left = { type: 'Binary', op: '||', left, right };
-        }
-        return left;
-    }
-    parseAnd() {
-        let left = this.parseCoalesce();
-        while (this.peek().type === TokenType.And) {
-            this.advance();
-            const right = this.parseCoalesce();
-            left = { type: 'Binary', op: '&&', left, right };
-        }
-        return left;
-    }
-    parseCoalesce() {
-        let left = this.parseComparison();
-        while (this.peek().type === TokenType.Coalesce) {
-            this.advance();
-            const right = this.parseComparison();
-            left = { type: 'Coalesce', left, right };
-        }
-        return left;
-    }
-    parseComparison() {
-        let left = this.parseAdditive();
-        const compOps = [TokenType.Eq, TokenType.Neq, TokenType.Gt, TokenType.Gte, TokenType.Lt, TokenType.Lte];
-        while (compOps.includes(this.peek().type)) {
-            const op = this.advance().value;
-            const right = this.parseAdditive();
-            left = { type: 'Binary', op, left, right };
-        }
-        return left;
-    }
-    parseAdditive() {
-        let left = this.parseMultiplicative();
-        while (this.peek().type === TokenType.Plus || this.peek().type === TokenType.Minus) {
-            const op = this.advance().value;
-            const right = this.parseMultiplicative();
-            left = { type: 'Binary', op, left, right };
-        }
-        return left;
-    }
-    parseMultiplicative() {
-        let left = this.parseUnary();
-        while (this.peek().type === TokenType.Star || this.peek().type === TokenType.Slash || this.peek().type === TokenType.Percent) {
-            const op = this.advance().value;
-            const right = this.parseUnary();
-            left = { type: 'Binary', op, left, right };
-        }
-        return left;
-    }
-    parseUnary() {
-        if (this.peek().type === TokenType.Not) {
-            this.advance();
-            const operand = this.parseUnary();
-            return { type: 'Unary', op: '!', operand };
-        }
-        if (this.peek().type === TokenType.Minus) {
-            this.advance();
-            const operand = this.parseUnary();
-            return { type: 'Unary', op: '-', operand };
-        }
-        return this.parsePostfix();
-    }
-    parsePostfix() {
-        let node = this.parsePrimary();
-        while (true) {
-            if (this.peek().type === TokenType.Dot) {
-                this.advance();
-                const prop = this.expect(TokenType.Identifier).value;
-                node = { type: 'Member', object: node, property: prop };
-            }
-            else if (this.peek().type === TokenType.LeftParen) {
-                this.advance();
-                const args = this.parseArgList();
-                this.expect(TokenType.RightParen);
-                node = { type: 'Call', callee: node, args };
-            }
-            else if (this.peek().type === TokenType.LeftBracket) {
-                this.advance();
-                const index = this.parseExpression();
-                this.expect(TokenType.RightBracket);
-                node = { type: 'Index', object: node, index };
-            }
-            else {
-                break;
-            }
-        }
-        return node;
-    }
-    parseArgList() {
-        const args = [];
-        if (this.peek().type === TokenType.RightParen)
-            return args;
-        args.push(this.parseArgOrArrow());
-        while (this.peek().type === TokenType.Comma) {
-            this.advance();
-            args.push(this.parseArgOrArrow());
-        }
-        return args;
-    }
-    parseArgOrArrow() {
-        // Check for arrow function: ident => expr
-        if (this.peek().type === TokenType.Identifier &&
-            this.tokens[this.pos + 1]?.type === TokenType.Arrow) {
-            const param = this.advance().value;
-            this.advance(); // skip =>
-            const body = this.parseExpression();
-            return { type: 'Arrow', param, body };
-        }
-        return this.parseExpression();
-    }
-    parsePrimary() {
-        const token = this.peek();
-        switch (token.type) {
-            case TokenType.Number:
-                this.advance();
-                return { type: 'Literal', value: parseFloat(token.value) };
-            case TokenType.String:
-                this.advance();
-                return { type: 'Literal', value: token.value };
-            case TokenType.Boolean:
-                this.advance();
-                return { type: 'Literal', value: token.value === 'true' };
-            case TokenType.Null:
-                this.advance();
-                return { type: 'Literal', value: null };
-            case TokenType.Regex: {
-                this.advance();
-                const match = token.value.match(/^\/(.+)\/([gimsuy]*)$/);
-                if (!match)
-                    throw new CompileError(`Invalid regex: ${token.value}`, token.pos);
-                return { type: 'Literal', value: new RegExp(match[1], match[2]) };
-            }
-            case TokenType.Identifier:
-                this.advance();
-                return { type: 'Identifier', name: token.value };
-            case TokenType.LeftParen: {
-                this.advance();
-                // Check for arrow: (ident) => expr
-                if (this.peek().type === TokenType.Identifier &&
-                    this.tokens[this.pos + 1]?.type === TokenType.RightParen &&
-                    this.tokens[this.pos + 2]?.type === TokenType.Arrow) {
-                    const param = this.advance().value;
-                    this.advance(); // )
-                    this.advance(); // =>
-                    const body = this.parseExpression();
-                    return { type: 'Arrow', param, body };
-                }
-                const expr = this.parseExpression();
-                this.expect(TokenType.RightParen);
-                return expr;
-            }
-            case TokenType.LeftBracket: {
-                this.advance();
-                const elements = [];
-                if (this.peek().type !== TokenType.RightBracket) {
-                    elements.push(this.parseExpression());
-                    while (this.peek().type === TokenType.Comma) {
-                        this.advance();
-                        elements.push(this.parseExpression());
-                    }
-                }
-                this.expect(TokenType.RightBracket);
-                return { type: 'Array', elements };
-            }
-            default:
-                throw new CompileError(`Unexpected token '${token.value}' at position ${token.pos}`, token.pos);
-        }
-    }
-}
-// -- Security: Forbidden Identifiers / Properties --
-//
-// The DSL compiles expressions into JS closures via `new Function`. Although
-// the lexer/parser is custom and relatively controlled, the rendered `message`
-// templates in rules go through the same compiler. A malicious YAML
-// (`~/.claude-forge/routing.yaml` or convention files) could try to escape the
-// sandbox through prototype chain / reflection tricks like
-// `ctx.constructor.constructor('return process')()`.
-//
-// We enforce two layers of defense:
-//   1. Compile-time codegen rejects known-dangerous identifiers and property names.
-//   2. Runtime Proxy re-checks property access on the ctx tree (covers dynamic
-//      indices and any static holes).
-const FORBIDDEN_IDENTIFIERS = new Set([
-    'constructor',
-    '__proto__',
-    'prototype',
-    '__defineGetter__',
-    '__defineSetter__',
-    '__lookupGetter__',
-    '__lookupSetter__',
-]);
-const FORBIDDEN_ROOT_NAMES = new Set([
-    'Function',
-    'eval',
-    'globalThis',
-    'global',
-    'process',
-    'require',
-    'import',
-    'module',
-    'Reflect',
-    'Proxy',
-]);
-function assertAllowedIdentifier(name) {
-    if (FORBIDDEN_ROOT_NAMES.has(name)) {
-        throw new CompileError(`Forbidden identifier '${name}' is not allowed in DSL expressions`, 0);
-    }
-}
-function assertAllowedProperty(name) {
-    if (FORBIDDEN_IDENTIFIERS.has(name)) {
-        throw new CompileError(`Forbidden property access '${name}' is not allowed in DSL expressions`, 0);
-    }
-}
-/**
- * Runtime safe-index helper. Codegen emits `__safe(obj, key)` instead of
- * `obj?.[key]` so that dynamic keys (which static analysis cannot see) are
- * checked at access time.
- *
- * Static member access (`obj.prop`) is already guarded in codegen because the
- * property name is a compile-time identifier. Only bracket indexing with a
- * runtime-computed key can slip past, so this is the single runtime gate.
- */
-function safeIndex(obj, key) {
-    if (obj == null)
-        return undefined;
-    // The DSL runtime may wrap string values in a Proxy over a boxed String, so
-    // `typeof key === 'string'` can be false even when the logical value is a
-    // string. Coerce through String() so both raw and wrapped keys are checked.
-    const keyStr = String(key);
-    if (FORBIDDEN_IDENTIFIERS.has(keyStr)) {
-        throw new Error(`Forbidden property access '${keyStr}' is not allowed in DSL expressions`);
-    }
-    return obj[keyStr];
-}
-// -- Code Generator --
-class CodeGenerator {
-    locals = new Set();
-    generate(node) {
-        return this.visit(node);
-    }
-    visit(node) {
-        switch (node.type) {
-            case 'Literal':
-                return this.visitLiteral(node);
-            case 'Identifier':
-                return this.visitIdentifier(node);
-            case 'Member':
-                return this.visitMember(node);
-            case 'Call':
-                return this.visitCall(node);
-            case 'Binary':
-                return this.visitBinary(node);
-            case 'Unary':
-                return this.visitUnary(node);
-            case 'Array':
-                return this.visitArray(node);
-            case 'Arrow':
-                return this.visitArrow(node);
-            case 'Coalesce':
-                return this.visitCoalesce(node);
-            case 'Index':
-                return this.visitIndex(node);
-            default:
-                throw new Error(`Unknown node type: ${node.type}`);
-        }
-    }
-    visitLiteral(node) {
-        if (node.value === null)
-            return 'null';
-        if (typeof node.value === 'boolean')
-            return String(node.value);
-        if (typeof node.value === 'number')
-            return String(node.value);
-        if (typeof node.value === 'string')
-            return JSON.stringify(node.value);
-        if (node.value instanceof RegExp)
-            return node.value.toString();
-        throw new Error(`Unknown literal type: ${typeof node.value}`);
-    }
-    visitIdentifier(node) {
-        if (this.locals.has(node.name)) {
-            return node.name;
-        }
-        // Reject global/reflective identifiers at compile time so convention YAML
-        // cannot reach `Function`, `process`, `require`, etc.
-        assertAllowedIdentifier(node.name);
-        // Also block property-like names that would be dangerous as direct ctx props
-        assertAllowedProperty(node.name);
-        return `ctx.${node.name}`;
-    }
-    visitMember(node) {
-        // Reject prototype-chain / reflection property names at compile time.
-        assertAllowedProperty(node.property);
-        const obj = this.visit(node.object);
-        return `${obj}?.${node.property}`;
-    }
-    visitCall(node) {
-        const callee = this.visit(node.callee);
-        const args = node.args.map((arg) => this.visit(arg)).join(', ');
-        return `${callee}?.(${args})`;
-    }
-    visitBinary(node) {
-        const left = this.visit(node.left);
-        const right = this.visit(node.right);
-        return `(${left} ${node.op} ${right})`;
-    }
-    visitUnary(node) {
-        const operand = this.visit(node.operand);
-        return `(${node.op}${operand})`;
-    }
-    visitArray(node) {
-        const elements = node.elements.map((el) => this.visit(el)).join(', ');
-        return `[${elements}]`;
-    }
-    visitArrow(node) {
-        this.locals.add(node.param);
-        const body = this.visit(node.body);
-        this.locals.delete(node.param);
-        return `((${node.param}) => ${body})`;
-    }
-    visitCoalesce(node) {
-        const left = this.visit(node.left);
-        const right = this.visit(node.right);
-        return `(${left} ?? ${right})`;
-    }
-    visitIndex(node) {
-        // Static protection: if index is a literal string matching a forbidden
-        // property, reject at compile time.
-        if (node.index.type === 'Literal' && typeof node.index.value === 'string') {
-            assertAllowedProperty(node.index.value);
-        }
-        const obj = this.visit(node.object);
-        const index = this.visit(node.index);
-        // Runtime protection: dynamic (non-literal) indices funnel through
-        // __safe() so a key like `vars.k === "constructor"` still throws.
-        return `__safe(${obj}, ${index})`;
-    }
-}
-// -- Compiler --
-export class ExpressionCompiler {
-    compile(expr) {
-        try {
-            const lexer = new Lexer(expr);
-            const tokens = lexer.tokenize();
-            const parser = new Parser(tokens);
-            const ast = parser.parse();
-            const codegen = new CodeGenerator();
-            const code = codegen.generate(ast);
-            const rawFn = new Function('ctx', '__safe', `return ${code};`);
-            return (ctx) => {
-                const enhanced = enhanceContext(ctx);
-                return rawFn(enhanced, safeIndex);
-            };
-        }
-        catch (error) {
-            if (error instanceof CompileError) {
-                throw error;
-            }
-            throw new CompileError(`Compilation failed: ${error}`, 0);
-        }
-    }
-    validate(expr) {
-        try {
-            this.compile(expr);
-            return { ok: true };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
-// -- Template Renderer --
-export class TemplateRenderer {
-    /**
-     * Render template strings with {{expr}} interpolation
-     */
-    render(template, ctx) {
-        const compiler = new ExpressionCompiler();
-        return template.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
-            try {
-                const fn = compiler.compile(expr.trim());
-                const result = fn(ctx);
-                return String(result ?? '');
-            }
-            catch {
-                return `{{${expr}}}`;
-            }
-        });
-    }
-}
-//# sourceMappingURL=compiler.js.map