eslint-plugin-vercel-ai-security 1.5.2 → 1.5.3

package/src/rules/require-embedding-validation/index.js

@@ -1,119 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireEmbeddingValidation = void 0;
-const eslint_devkit_1 = require("@interlace/eslint-devkit");
-exports.requireEmbeddingValidation = (0, eslint_devkit_1.createRule)({
-    name: 'require-embedding-validation',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            url: 'https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-embedding-validation.md',
-            description: 'Require validation of embeddings before storage or similarity search',
-            cwe: 'CWE-20',
-            cvss: 5.5,
-        },
-        messages: {
-            unvalidatedEmbedding: (0, eslint_devkit_1.formatLLMMessage)({
-                icon: eslint_devkit_1.MessageIcons.WARNING,
-                issueName: 'Unvalidated Embedding',
-                cwe: 'CWE-20',
-                owasp: 'A03:2021',
-                cvss: 5.5,
-                description: 'Embedding from "{{source}}" used without validation. Malicious embeddings can poison vector stores.',
-                severity: 'MEDIUM',
-                compliance: ['SOC2'],
-                fix: 'Validate embeddings before use: const validated = validateEmbedding(embedding)',
-                documentationLink: 'https://owasp.org/www-project-top-10-for-large-language-model-applications/',
-            }),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    embeddingPatterns: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Patterns suggesting embedding operations',
-                    },
-                    validatorFunctions: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Functions that validate embeddings',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        {
-            embeddingPatterns: [
-                'embed', 'embedding', 'embeddings', 'vector', 'encode',
-                'createEmbedding', 'getEmbedding', 'generateEmbedding',
-            ],
-            validatorFunctions: [
-                'validate', 'verify', 'check', 'sanitize', 'normalize',
-                'validateEmbedding', 'verifyVector',
-            ],
-        },
-    ],
-    create(context) {
-        const [options = {}] = context.options;
-        const embeddingPatterns = options.embeddingPatterns ?? [
-            'embed', 'embedding', 'vector', 'encode',
-        ];
-        const validatorFunctions = options.validatorFunctions ?? [
-            'validate', 'verify', 'check', 'sanitize',
-        ];
-        const sourceCode = context.sourceCode;
-        const vectorStoreOps = ['upsert', 'insert', 'add', 'store', 'index', 'save'];
-        function isEmbeddingCall(node) {
-            const callee = sourceCode.getText(node.callee);
-            for (const pattern of embeddingPatterns) {
-                if (callee.toLowerCase().includes(pattern.toLowerCase())) {
-                    return callee;
-                }
-            }
-            return null;
-        }
-        function isValidated(node) {
-            const callee = sourceCode.getText(node.callee);
-            return validatorFunctions.some((fn) => callee.toLowerCase().includes(fn.toLowerCase()));
-        }
-        function isVectorStoreOp(node) {
-            const callee = sourceCode.getText(node.callee);
-            return vectorStoreOps.some(op => callee.toLowerCase().includes(op.toLowerCase()));
-        }
-        return {
-            CallExpression(node) {
-                if (!isVectorStoreOp(node))
-                    return;
-                for (const arg of node.arguments) {
-                    if (arg.type === 'ObjectExpression') {
-                        for (const prop of arg.properties) {
-                            if (prop.type !== 'Property')
-                                continue;
-                            const keyName = prop.key.type === 'Identifier' ? prop.key.name : null;
-                            if (keyName === 'embedding' || keyName === 'vector' || keyName === 'values') {
-                                let valueNode = prop.value;
-                                if (valueNode.type === 'AwaitExpression') {
-                                    valueNode = valueNode.argument;
-                                }
-                                if (valueNode.type === 'CallExpression') {
-                                    const embeddingSource = isEmbeddingCall(valueNode);
-                                    if (embeddingSource && !isValidated(valueNode)) {
-                                        context.report({
-                                            node: prop.value,
-                                            messageId: 'unvalidatedEmbedding',
-                                            data: { source: embeddingSource },
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-        };
-    },
-});
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.requireEmbeddingValidation=void 0;const eslint_devkit_1=require("@interlace/eslint-devkit");exports.requireEmbeddingValidation=(0,eslint_devkit_1.createRule)({name:"require-embedding-validation",meta:{type:"suggestion",docs:{url:"https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-embedding-validation.md",description:"Require validation of embeddings before storage or similarity search",cwe:"CWE-20",cvss:5.5},messages:{unvalidatedEmbedding:(0,eslint_devkit_1.formatLLMMessage)({icon:eslint_devkit_1.MessageIcons.WARNING,issueName:"Unvalidated Embedding",cwe:"CWE-20",owasp:"A03:2021",cvss:5.5,description:'Embedding from "{{source}}" used without validation. Malicious embeddings can poison vector stores.',severity:"MEDIUM",compliance:["SOC2"],fix:"Validate embeddings before use: const validated = validateEmbedding(embedding)",documentationLink:"https://owasp.org/www-project-top-10-for-large-language-model-applications/"})},schema:[{type:"object",properties:{embeddingPatterns:{type:"array",items:{type:"string"},description:"Patterns suggesting embedding operations"},validatorFunctions:{type:"array",items:{type:"string"},description:"Functions that validate embeddings"}},additionalProperties:false}]},defaultOptions:[{embeddingPatterns:["embed","embedding","embeddings","vector","encode","createEmbedding","getEmbedding","generateEmbedding"],validatorFunctions:["validate","verify","check","sanitize","normalize","validateEmbedding","verifyVector"]}],create(context){const[options={}]=context.options;const embeddingPatterns=options.embeddingPatterns??["embed","embedding","vector","encode"];const validatorFunctions=options.validatorFunctions??["validate","verify","check","sanitize"];const sourceCode=context.sourceCode;const vectorStoreOps=["upsert","insert","add","store","index","save"];function isEmbeddingCall(node){const callee=sourceCode.getText(node.callee);for(const pattern of embeddingPatterns){if(callee.toLowerCase().includes(pattern.toLowerCase())){return callee}}return null}function isValidated(node){const callee=sourceCode.getText(node.callee);return validatorFunctions.some(fn=>callee.toLowerCase().includes(fn.toLowerCase()))}function isVectorStoreOp(node){const callee=sourceCode.getText(node.callee);return vectorStoreOps.some(op=>callee.toLowerCase().includes(op.toLowerCase()))}return{CallExpression(node){if(!isVectorStoreOp(node))return;for(const arg of node.arguments){if(arg.type==="ObjectExpression"){for(const prop of arg.properties){if(prop.type!=="Property")continue;const keyName=prop.key.type==="Identifier"?prop.key.name:null;if(keyName==="embedding"||keyName==="vector"||keyName==="values"){let valueNode=prop.value;if(valueNode.type==="AwaitExpression"){valueNode=valueNode.argument}if(valueNode.type==="CallExpression"){const embeddingSource=isEmbeddingCall(valueNode);if(embeddingSource&&!isValidated(valueNode)){context.report({node:prop.value,messageId:"unvalidatedEmbedding",data:{source:embeddingSource}})}}}}}}}}}});

package/src/rules/require-error-handling/index.js

@@ -1,92 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireErrorHandling = void 0;
-const eslint_devkit_1 = require("@interlace/eslint-devkit");
-exports.requireErrorHandling = (0, eslint_devkit_1.createRule)({
-    name: 'require-error-handling',
-    meta: {
-        type: 'problem',
-        docs: {
-            url: 'https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-error-handling.md',
-            description: 'Require error handling for AI SDK calls to prevent cascading failures',
-            cwe: 'CWE-755',
-            cvss: 5,
-        },
-        messages: {
-            missingErrorHandling: (0, eslint_devkit_1.formatLLMMessage)({
-                icon: eslint_devkit_1.MessageIcons.WARNING,
-                issueName: 'Unhandled AI SDK Call',
-                cwe: 'CWE-755',
-                owasp: 'A05:2021',
-                cvss: 5.0,
-                description: '{{function}} call is not wrapped in try-catch. AI API failures can cause cascading errors.',
-                severity: 'MEDIUM',
-                compliance: ['SOC2'],
-                fix: 'Wrap in try-catch: try { await {{function}}(...) } catch (e) { /* handle error */ }',
-                documentationLink: 'https://sdk.vercel.ai/docs/ai-sdk-core/error-handling',
-            }),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    allowInTests: {
-                        type: 'boolean',
-                        description: 'Allow unhandled AI calls in test files',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        {
-            allowInTests: true,
-        },
-    ],
-    create(context) {
-        const [options = {}] = context.options;
-        const allowInTests = options.allowInTests ?? true;
-        const sourceCode = context.sourceCode;
-        const filename = context.filename;
-        if (allowInTests && /\.(test|spec)\.[jt]sx?$/.test(filename)) {
-            return {};
-        }
-        const aiSDKFunctions = ['generateText', 'streamText', 'generateObject', 'streamObject'];
-        function isInsideTryBlock(node) {
-            let parent = node.parent;
-            while (parent) {
-                if (parent.type === 'TryStatement') {
-                    return true;
-                }
-                parent = parent.parent;
-            }
-            return false;
-        }
-        return {
-            CallExpression(node) {
-                const callee = sourceCode.getText(node.callee);
-                const matchedFunction = aiSDKFunctions.find(fn => callee.includes(fn));
-                if (!matchedFunction)
-                    return;
-                const parent = node.parent;
-                if (parent?.type === 'AwaitExpression') {
-                    if (!isInsideTryBlock(parent)) {
-                        context.report({
-                            node,
-                            messageId: 'missingErrorHandling',
-                            data: { function: matchedFunction },
-                        });
-                    }
-                }
-                else if (!isInsideTryBlock(node)) {
-                    context.report({
-                        node,
-                        messageId: 'missingErrorHandling',
-                        data: { function: matchedFunction },
-                    });
-                }
-            },
-        };
-    },
-});
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.requireErrorHandling=void 0;const eslint_devkit_1=require("@interlace/eslint-devkit");exports.requireErrorHandling=(0,eslint_devkit_1.createRule)({name:"require-error-handling",meta:{type:"problem",docs:{url:"https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-error-handling.md",description:"Require error handling for AI SDK calls to prevent cascading failures",cwe:"CWE-755",cvss:5},messages:{missingErrorHandling:(0,eslint_devkit_1.formatLLMMessage)({icon:eslint_devkit_1.MessageIcons.WARNING,issueName:"Unhandled AI SDK Call",cwe:"CWE-755",owasp:"A05:2021",cvss:5,description:"{{function}} call is not wrapped in try-catch. AI API failures can cause cascading errors.",severity:"MEDIUM",compliance:["SOC2"],fix:"Wrap in try-catch: try { await {{function}}(...) } catch (e) { /* handle error */ }",documentationLink:"https://sdk.vercel.ai/docs/ai-sdk-core/error-handling"})},schema:[{type:"object",properties:{allowInTests:{type:"boolean",description:"Allow unhandled AI calls in test files"}},additionalProperties:false}]},defaultOptions:[{allowInTests:true}],create(context){const[options={}]=context.options;const allowInTests=options.allowInTests??true;const sourceCode=context.sourceCode;const filename=context.filename;if(allowInTests&&/\.(test|spec)\.[jt]sx?$/.test(filename)){return{}}const aiSDKFunctions=["generateText","streamText","generateObject","streamObject"];function isInsideTryBlock(node){let parent=node.parent;while(parent){if(parent.type==="TryStatement"){return true}parent=parent.parent}return false}return{CallExpression(node){const callee=sourceCode.getText(node.callee);const matchedFunction=aiSDKFunctions.find(fn=>callee.includes(fn));if(!matchedFunction)return;const parent=node.parent;if(parent?.type==="AwaitExpression"){if(!isInsideTryBlock(parent)){context.report({node,messageId:"missingErrorHandling",data:{function:matchedFunction}})}}else if(!isInsideTryBlock(node)){context.report({node,messageId:"missingErrorHandling",data:{function:matchedFunction}})}}}}});

package/src/rules/require-max-steps/index.js

@@ -1,88 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireMaxSteps = void 0;
-const eslint_devkit_1 = require("@interlace/eslint-devkit");
-exports.requireMaxSteps = (0, eslint_devkit_1.createRule)({
-    name: 'require-max-steps',
-    meta: {
-        type: 'problem',
-        docs: {
-            url: 'https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-max-steps.md',
-            description: 'Require maxSteps limit for multi-step tool calling to prevent infinite loops',
-            cwe: 'CWE-834',
-            cvss: 6.5,
-        },
-        messages: {
-            missingMaxSteps: (0, eslint_devkit_1.formatLLMMessage)({
-                icon: eslint_devkit_1.MessageIcons.WARNING,
-                issueName: 'Missing Step Limit in Multi-Step Tool Calling',
-                cwe: 'CWE-834',
-                owasp: 'A05:2021',
-                cvss: 6.5,
-                description: '{{function}} with tools is missing a step limit. Without a limit, tool calls can loop indefinitely.',
-                severity: 'MEDIUM',
-                compliance: ['SOC2'],
-                fix: 'Add a step limit: {{function}}({ ..., stopWhen: stepCountIs(5) }) (v5+) or maxSteps: 5 (v4)',
-                documentationLink: 'https://sdk.vercel.ai/docs/ai-sdk-core/tools-and-tool-calling#multi-step-calls-using-stopwhen',
-            }),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    suggestedMaxSteps: {
-                        type: 'number',
-                        description: 'Default max steps limit to suggest',
-                        default: 5,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        {
-            suggestedMaxSteps: 5,
-        },
-    ],
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const functionsWithTools = ['generateText', 'streamText'];
-        return {
-            CallExpression(node) {
-                const callee = sourceCode.getText(node.callee);
-                const matchedFunction = functionsWithTools.find(fn => callee.includes(fn));
-                if (!matchedFunction)
-                    return;
-                const optionsArg = node.arguments[0];
-                if (!optionsArg || optionsArg.type !== 'ObjectExpression')
-                    return;
-                const hasTools = optionsArg.properties.some(prop => {
-                    if (prop.type !== 'Property')
-                        return false;
-                    const keyName = prop.key.type === 'Identifier' ? prop.key.name : null;
-                    return keyName === 'tools';
-                });
-                if (!hasTools)
-                    return;
-                const hasMaxSteps = optionsArg.properties.some(prop => {
-                    if (prop.type !== 'Property')
-                        return false;
-                    const keyName = prop.key.type === 'Identifier'
-                        ? prop.key.name
-                        : prop.key.type === 'Literal'
-                            ? String(prop.key.value)
-                            : null;
-                    return keyName === 'maxSteps' || keyName === 'max_steps' || keyName === 'stopWhen';
-                });
-                if (!hasMaxSteps) {
-                    context.report({
-                        node,
-                        messageId: 'missingMaxSteps',
-                        data: { function: matchedFunction },
-                    });
-                }
-            },
-        };
-    },
-});
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.requireMaxSteps=void 0;const eslint_devkit_1=require("@interlace/eslint-devkit");exports.requireMaxSteps=(0,eslint_devkit_1.createRule)({name:"require-max-steps",meta:{type:"problem",docs:{url:"https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-max-steps.md",description:"Require maxSteps limit for multi-step tool calling to prevent infinite loops",cwe:"CWE-834",cvss:6.5},messages:{missingMaxSteps:(0,eslint_devkit_1.formatLLMMessage)({icon:eslint_devkit_1.MessageIcons.WARNING,issueName:"Missing Step Limit in Multi-Step Tool Calling",cwe:"CWE-834",owasp:"A05:2021",cvss:6.5,description:"{{function}} with tools is missing a step limit. Without a limit, tool calls can loop indefinitely.",severity:"MEDIUM",compliance:["SOC2"],fix:"Add a step limit: {{function}}({ ..., stopWhen: stepCountIs(5) }) (v5+) or maxSteps: 5 (v4)",documentationLink:"https://sdk.vercel.ai/docs/ai-sdk-core/tools-and-tool-calling#multi-step-calls-using-stopwhen"})},schema:[{type:"object",properties:{suggestedMaxSteps:{type:"number",description:"Default max steps limit to suggest",default:5}},additionalProperties:false}]},defaultOptions:[{suggestedMaxSteps:5}],create(context){const sourceCode=context.sourceCode;const functionsWithTools=["generateText","streamText"];return{CallExpression(node){const callee=sourceCode.getText(node.callee);const matchedFunction=functionsWithTools.find(fn=>callee.includes(fn));if(!matchedFunction)return;const optionsArg=node.arguments[0];if(!optionsArg||optionsArg.type!=="ObjectExpression")return;const hasTools=optionsArg.properties.some(prop=>{if(prop.type!=="Property")return false;const keyName=prop.key.type==="Identifier"?prop.key.name:null;return keyName==="tools"});if(!hasTools)return;const hasMaxSteps=optionsArg.properties.some(prop=>{if(prop.type!=="Property")return false;const keyName=prop.key.type==="Identifier"?prop.key.name:prop.key.type==="Literal"?String(prop.key.value):null;return keyName==="maxSteps"||keyName==="max_steps"||keyName==="stopWhen"});if(!hasMaxSteps){context.report({node,messageId:"missingMaxSteps",data:{function:matchedFunction}})}}}}});

package/src/rules/require-max-tokens/index.js

@@ -1,94 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireMaxTokens = void 0;
-const eslint_devkit_1 = require("@interlace/eslint-devkit");
-exports.requireMaxTokens = (0, eslint_devkit_1.createRule)({
-    name: 'require-max-tokens',
-    meta: {
-        type: 'problem',
-        docs: {
-            url: 'https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-max-tokens.md',
-            description: 'Require maxTokens limit in generateText and streamText calls',
-            cwe: 'CWE-770',
-            cvss: 6.5,
-        },
-        messages: {
-            missingMaxTokens: (0, eslint_devkit_1.formatLLMMessage)({
-                icon: eslint_devkit_1.MessageIcons.WARNING,
-                issueName: 'Missing Token Limit in Vercel AI SDK',
-                cwe: 'CWE-770',
-                owasp: 'A05:2021',
-                cvss: 6.5,
-                description: '{{function}} call without a token limit can lead to excessive resource consumption',
-                severity: 'MEDIUM',
-                compliance: ['SOC2'],
-                fix: 'Add a token limit: {{function}}({ maxOutputTokens: 4096, ... }) (v5+) or maxTokens (v4)',
-                documentationLink: 'https://sdk.vercel.ai/docs/ai-sdk-core/generating-text',
-            }),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    suggestedLimit: {
-                        type: 'number',
-                        description: 'Default max tokens limit to suggest',
-                        default: 4096,
-                    },
-                    targetFunctions: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Function names that require max tokens',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        {
-            suggestedLimit: 4096,
-            targetFunctions: ['generateText', 'streamText', 'generateObject', 'streamObject'],
-        },
-    ],
-    create(context) {
-        const [options = {}] = context.options;
-        const targetFunctions = options.targetFunctions ?? [
-            'generateText', 'streamText', 'generateObject', 'streamObject',
-        ];
-        const sourceCode = context.sourceCode;
-        return {
-            CallExpression(node) {
-                const callee = sourceCode.getText(node.callee);
-                const matchedFunction = targetFunctions.find((fn) => callee.includes(fn));
-                if (!matchedFunction) {
-                    return;
-                }
-                const optionsArg = node.arguments[0];
-                if (!optionsArg || optionsArg.type !== 'ObjectExpression') {
-                    return;
-                }
-                const hasMaxTokens = optionsArg.properties.some(prop => {
-                    if (prop.type !== 'Property')
-                        return false;
-                    const keyName = prop.key.type === 'Identifier'
-                        ? prop.key.name
-                        : prop.key.type === 'Literal'
-                            ? String(prop.key.value)
-                            : null;
-                    return (keyName === 'maxTokens' ||
-                        keyName === 'max_tokens' ||
-                        keyName === 'maxOutputTokens' ||
-                        keyName === 'max_output_tokens');
-                });
-                if (!hasMaxTokens) {
-                    context.report({
-                        node,
-                        messageId: 'missingMaxTokens',
-                        data: { function: matchedFunction },
-                    });
-                }
-            },
-        };
-    },
-});
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.requireMaxTokens=void 0;const eslint_devkit_1=require("@interlace/eslint-devkit");exports.requireMaxTokens=(0,eslint_devkit_1.createRule)({name:"require-max-tokens",meta:{type:"problem",docs:{url:"https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-max-tokens.md",description:"Require maxTokens limit in generateText and streamText calls",cwe:"CWE-770",cvss:6.5},messages:{missingMaxTokens:(0,eslint_devkit_1.formatLLMMessage)({icon:eslint_devkit_1.MessageIcons.WARNING,issueName:"Missing Token Limit in Vercel AI SDK",cwe:"CWE-770",owasp:"A05:2021",cvss:6.5,description:"{{function}} call without a token limit can lead to excessive resource consumption",severity:"MEDIUM",compliance:["SOC2"],fix:"Add a token limit: {{function}}({ maxOutputTokens: 4096, ... }) (v5+) or maxTokens (v4)",documentationLink:"https://sdk.vercel.ai/docs/ai-sdk-core/generating-text"})},schema:[{type:"object",properties:{suggestedLimit:{type:"number",description:"Default max tokens limit to suggest",default:4096},targetFunctions:{type:"array",items:{type:"string"},description:"Function names that require max tokens"}},additionalProperties:false}]},defaultOptions:[{suggestedLimit:4096,targetFunctions:["generateText","streamText","generateObject","streamObject"]}],create(context){const[options={}]=context.options;const targetFunctions=options.targetFunctions??["generateText","streamText","generateObject","streamObject"];const sourceCode=context.sourceCode;return{CallExpression(node){const callee=sourceCode.getText(node.callee);const matchedFunction=targetFunctions.find(fn=>callee.includes(fn));if(!matchedFunction){return}const optionsArg=node.arguments[0];if(!optionsArg||optionsArg.type!=="ObjectExpression"){return}const hasMaxTokens=optionsArg.properties.some(prop=>{if(prop.type!=="Property")return false;const keyName=prop.key.type==="Identifier"?prop.key.name:prop.key.type==="Literal"?String(prop.key.value):null;return keyName==="maxTokens"||keyName==="max_tokens"||keyName==="maxOutputTokens"||keyName==="max_output_tokens"});if(!hasMaxTokens){context.report({node,messageId:"missingMaxTokens",data:{function:matchedFunction}})}}}}});

package/src/rules/require-output-filtering/index.js

@@ -1,123 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireOutputFiltering = void 0;
-const eslint_devkit_1 = require("@interlace/eslint-devkit");
-exports.requireOutputFiltering = (0, eslint_devkit_1.createRule)({
-    name: 'require-output-filtering',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            url: 'https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-output-filtering.md',
-            description: 'Require filtering of sensitive data returned by AI tools',
-            cwe: 'CWE-200',
-            cvss: 6.5,
-        },
-        messages: {
-            missingOutputFilter: (0, eslint_devkit_1.formatLLMMessage)({
-                icon: eslint_devkit_1.MessageIcons.WARNING,
-                issueName: 'Unfiltered Tool Output',
-                cwe: 'CWE-200',
-                owasp: 'A01:2021',
-                cvss: 6.5,
-                description: 'Tool "{{toolName}}" returns data from "{{source}}" without filtering. This may leak sensitive information.',
-                severity: 'MEDIUM',
-                compliance: ['SOC2', 'GDPR'],
-                fix: 'Filter sensitive fields before returning: return filterSensitive(data)',
-                documentationLink: 'https://owasp.org/www-project-top-10-for-large-language-model-applications/',
-            }),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    dataSourcePatterns: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Patterns suggesting data sources',
-                    },
-                    filterFunctions: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Functions considered safe filters',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        {
-            dataSourcePatterns: [
-                'query', 'find', 'select', 'fetch', 'get', 'read', 'load',
-                'database', 'db', 'sql', 'mongo', 'prisma', 'supabase',
-            ],
-            filterFunctions: [
-                'filter', 'sanitize', 'redact', 'mask', 'clean',
-                'filterSensitive', 'removePII', 'scrub',
-            ],
-        },
-    ],
-    create(context) {
-        const [options = {}] = context.options;
-        const dataSourcePatterns = options.dataSourcePatterns ?? [
-            'query', 'find', 'select', 'fetch', 'get', 'read',
-        ];
-        const filterFunctions = options.filterFunctions ?? [
-            'filter', 'sanitize', 'redact', 'mask',
-        ];
-        const sourceCode = context.sourceCode;
-        function isDataSourceCall(node) {
-            const callee = sourceCode.getText(node.callee);
-            for (const pattern of dataSourcePatterns) {
-                if (callee.toLowerCase().includes(pattern.toLowerCase())) {
-                    return callee;
-                }
-            }
-            return null;
-        }
-        function isFilteredCall(node) {
-            const callee = sourceCode.getText(node.callee);
-            return filterFunctions.some((filter) => callee.toLowerCase().includes(filter.toLowerCase()));
-        }
-        function getToolName(node) {
-            let current = node.parent;
-            while (current) {
-                if (current.type === 'Property' && current.parent?.type === 'ObjectExpression') {
-                    const grandparent = current.parent.parent;
-                    if (grandparent?.type === 'Property' &&
-                        grandparent.key.type === 'Identifier' &&
-                        grandparent.key.name === 'tools') {
-                        if (current.key.type === 'Identifier') {
-                            return current.key.name;
-                        }
-                    }
-                }
-                current = current.parent;
-            }
-            return 'unknown';
-        }
-        return {
-            ArrowFunctionExpression(node) {
-                const parent = node.parent;
-                if (parent?.type !== 'Property')
-                    return;
-                const keyName = parent.key.type === 'Identifier' ? parent.key.name : null;
-                if (keyName !== 'execute')
-                    return;
-                if (node.body.type === 'CallExpression') {
-                    const source = isDataSourceCall(node.body);
-                    if (source && !isFilteredCall(node.body)) {
-                        context.report({
-                            node: node.body,
-                            messageId: 'missingOutputFilter',
-                            data: {
-                                toolName: getToolName(node),
-                                source,
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
-});
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.requireOutputFiltering=void 0;const eslint_devkit_1=require("@interlace/eslint-devkit");exports.requireOutputFiltering=(0,eslint_devkit_1.createRule)({name:"require-output-filtering",meta:{type:"suggestion",docs:{url:"https://github.com/ofri-peretz/eslint/blob/main/packages/eslint-plugin-vercel-ai-security/docs/rules/require-output-filtering.md",description:"Require filtering of sensitive data returned by AI tools",cwe:"CWE-200",cvss:6.5},messages:{missingOutputFilter:(0,eslint_devkit_1.formatLLMMessage)({icon:eslint_devkit_1.MessageIcons.WARNING,issueName:"Unfiltered Tool Output",cwe:"CWE-200",owasp:"A01:2021",cvss:6.5,description:'Tool "{{toolName}}" returns data from "{{source}}" without filtering. This may leak sensitive information.',severity:"MEDIUM",compliance:["SOC2","GDPR"],fix:"Filter sensitive fields before returning: return filterSensitive(data)",documentationLink:"https://owasp.org/www-project-top-10-for-large-language-model-applications/"})},schema:[{type:"object",properties:{dataSourcePatterns:{type:"array",items:{type:"string"},description:"Patterns suggesting data sources"},filterFunctions:{type:"array",items:{type:"string"},description:"Functions considered safe filters"}},additionalProperties:false}]},defaultOptions:[{dataSourcePatterns:["query","find","select","fetch","get","read","load","database","db","sql","mongo","prisma","supabase"],filterFunctions:["filter","sanitize","redact","mask","clean","filterSensitive","removePII","scrub"]}],create(context){const[options={}]=context.options;const dataSourcePatterns=options.dataSourcePatterns??["query","find","select","fetch","get","read"];const filterFunctions=options.filterFunctions??["filter","sanitize","redact","mask"];const sourceCode=context.sourceCode;function isDataSourceCall(node){const callee=sourceCode.getText(node.callee);for(const pattern of dataSourcePatterns){if(callee.toLowerCase().includes(pattern.toLowerCase())){return callee}}return null}function isFilteredCall(node){const callee=sourceCode.getText(node.callee);return filterFunctions.some(filter=>callee.toLowerCase().includes(filter.toLowerCase()))}function getToolName(node){let current=node.parent;while(current){if(current.type==="Property"&&current.parent?.type==="ObjectExpression"){const grandparent=current.parent.parent;if(grandparent?.type==="Property"&&grandparent.key.type==="Identifier"&&grandparent.key.name==="tools"){if(current.key.type==="Identifier"){return current.key.name}}}current=current.parent}return"unknown"}return{ArrowFunctionExpression(node){const parent=node.parent;if(parent?.type!=="Property")return;const keyName=parent.key.type==="Identifier"?parent.key.name:null;if(keyName!=="execute")return;if(node.body.type==="CallExpression"){const source=isDataSourceCall(node.body);if(source&&!isFilteredCall(node.body)){context.report({node:node.body,messageId:"missingOutputFilter",data:{toolName:getToolName(node),source}})}}}}}});