mcp4openapi 0.2.8 → 0.3.0

package/dist/src/testing/test-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-schema.d.ts","sourceRoot":"","sources":["../../../src/testing/test-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;GAYrB,CAAC;AAEL,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOtC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/src/testing/test-schema.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+const RequestExpectationSchema = z.object({
+    method: z.string().optional().describe('Expected HTTP method'),
+    path: z.string().optional().describe('Expected request path'),
+    path_regex: z.string().optional().describe('Regex to match request path'),
+    origin: z.string().optional().describe('Expected request origin (protocol + host + port)'),
+    origin_regex: z.string().optional().describe('Regex to match request origin (protocol + host + port)'),
+    query: z
+        .record(z.union([z.string(), z.number(), z.boolean(), z.array(z.union([z.string(), z.number(), z.boolean()]))]))
+        .optional()
+        .describe('Expected query parameters (strings, numbers, booleans, or arrays)'),
+    query_absent: z.array(z.string()).optional().describe('Query parameters that must NOT be present'),
+    query_regex: z.record(z.string()).optional().describe('Regex to match query parameter values'),
+    headers: z.record(z.string()).optional().describe('Expected HTTP headers'),
+    headers_regex: z.record(z.string()).optional().describe('Regex to match header values'),
+    headers_absent: z.array(z.string()).optional().describe('Headers that must NOT be present on the request'),
+    body: z.any().optional().describe('Expected request body (partial match allowed)'),
+    body_exact: z.any().optional().describe('Expected request body (exact match required)'),
+    body_regex: z.string().optional().describe('Regex to match stringified request body')
+});
+export const MockDefinitionSchema = z.object({
+    operationId: z.string().optional().describe('The OpenAPI operationId to mock'),
+    path: z.string().optional().describe('Raw URL path pattern (e.g. /api/v4/projects)'),
+    method: z.string().optional().describe('HTTP method (GET, POST, etc.)'),
+    response: z
+        .object({
+        status: z.number().optional().default(200),
+        body: z.any().optional(),
+        headers: z.record(z.string()).optional(),
+        delay: z.number().optional().describe('Response delay in milliseconds')
+    })
+        .optional()
+}).refine(data => data.operationId || (data.path && data.method), {
+    message: 'Either operationId or (path and method) must be provided'
+});
+export const TestExpectationSchema = z.object({
+    success: z.boolean().default(true).describe('Whether the tool call should succeed'),
+    result: z.any().optional().describe('Expected exact result (partial match)'),
+    result_exact: z.any().optional().describe('Expected result with deep equality (no extra fields)'),
+    error_code: z.string().optional().describe('Expected error code if success is false'),
+    error_message_regex: z.string().optional().describe('Regex to match error message'),
+    request: RequestExpectationSchema.optional().describe('Expected HTTP request details for the scenario'),
+    requests: z.array(RequestExpectationSchema).optional().describe('Expected ordered list of HTTP requests'),
+    allow_additional_requests: z.boolean().optional().describe('If true, additional captured requests are allowed beyond expectations')
+});
+export const TestScenarioSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    tool: z.string().describe('Name of the MCP tool to call'),
+    arguments: z.record(z.any()).describe('Arguments to pass to the tool'),
+    mocks: z.array(MockDefinitionSchema).optional().describe('Scenario-specific mock overrides'),
+    expect: TestExpectationSchema,
+    timeout_ms: z.number().optional()
+});
+const CoverageRulesSchema = z
+    .object({
+    require_all_actions: z.boolean().default(false),
+    skip_actions: z.record(z.string().min(1)).default({}),
+    require_request_assertions: z.boolean().default(false),
+    skip_request_assertions: z.record(z.string().min(1)).default({})
+})
+    .default({
+    require_all_actions: false,
+    skip_actions: {},
+    require_request_assertions: false,
+    skip_request_assertions: {}
+});
+export const ProfileTestDefinitionSchema = z.object({
+    $schema: z.string().optional(),
+    profile_name: z.string().optional(),
+    variables: z.record(z.any()).optional().describe('Global variables for templating'),
+    global_mocks: z.array(MockDefinitionSchema).optional().describe('Default mocks applied to all scenarios'),
+    scenarios: z.array(TestScenarioSchema),
+    coverage: CoverageRulesSchema
+});
+//# sourceMappingURL=test-schema.js.map

package/dist/src/testing/test-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-schema.js","sourceRoot":"","sources":["../../../src/testing/test-schema.ts"],"names":[],"mappings":"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"}

package/dist/src/tool-filter/compat.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Compatibility functions for legacy code
+ *
+ * These functions provide backward-compatible API for code that hasn't
+ * been migrated to use the new modular architecture yet.
+ */
+import type { ToolDefinition } from '../types/profile.js';
+import type { SessionToolFilterRequest } from './types.js';
+export interface SessionToolFilter {
+    allowedToolNames: Set<string>;
+    reasons: Map<string, string[]>;
+    patterns: {
+        allow: RegExp[];
+    };
+    normalizedHeader: string;
+}
+/**
+ * Normalize tool filter header value
+ *
+ * @param value - Raw header value
+ * @returns Normalized value or undefined if empty
+ */
+export declare function normalizeToolFilterHeaderValue(value?: string): string | undefined;
+/**
+ * Parse session tool filter header
+ *
+ * Legacy wrapper around HeaderConfigParser for backward compatibility.
+ * New code should use HeaderConfigParser directly.
+ *
+ * @param headerValue - Header value to parse
+ * @returns Parsed session filter request
+ */
+export declare function parseSessionToolFilterHeader(headerValue: string): SessionToolFilterRequest;
+/**
+ * Apply session tool filter
+ *
+ * Legacy function for backward compatibility.
+ * New code should use SessionToolFilter class directly.
+ *
+ * @param tools - Tools to filter
+ * @param request - Filter request from header
+ * @param resolver - Operation resolver (optional, for legacy compatibility)
+ * @returns Session filter result
+ */
+export declare function applySessionToolFilter(tools: ToolDefinition[], request: SessionToolFilterRequest, resolver?: {
+    getOperationById?: (id: string) => any;
+    getOperationForCall?: (call: string) => any;
+}): SessionToolFilter;
+//# sourceMappingURL=compat.d.ts.map

package/dist/src/tool-filter/compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../../../src/tool-filter/compat.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAqB,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAS9E,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/B,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB,CAM1F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,wBAAwB,EACjC,QAAQ,CAAC,EAAE;IAAE,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,GAAG,CAAC;IAAC,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;CAAE,GACjG,iBAAiB,CAqBnB"}

package/dist/src/tool-filter/compat.js

@@ -0,0 +1,72 @@
+/**
+ * Compatibility functions for legacy code
+ *
+ * These functions provide backward-compatible API for code that hasn't
+ * been migrated to use the new modular architecture yet.
+ */
+import { HeaderConfigParser } from './config/header-config-parser.js';
+import { RegexCompiler } from './regex/regex-compiler.js';
+import { RegexValidator } from './regex/regex-validator.js';
+import { SessionToolFilter as SessionToolFilterClass } from './filter/session-tool-filter.js';
+import { OperationClassifier } from './operation/operation-classifier.js';
+import { OperationDetector } from './operation/operation-detector.js';
+/**
+ * Normalize tool filter header value
+ *
+ * @param value - Raw header value
+ * @returns Normalized value or undefined if empty
+ */
+export function normalizeToolFilterHeaderValue(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return undefined;
+    }
+    return trimmed;
+}
+/**
+ * Parse session tool filter header
+ *
+ * Legacy wrapper around HeaderConfigParser for backward compatibility.
+ * New code should use HeaderConfigParser directly.
+ *
+ * @param headerValue - Header value to parse
+ * @returns Parsed session filter request
+ */
+export function parseSessionToolFilterHeader(headerValue) {
+    const validator = new RegexValidator();
+    const compiler = new RegexCompiler(validator);
+    const parser = new HeaderConfigParser(compiler);
+    return parser.parse(headerValue);
+}
+/**
+ * Apply session tool filter
+ *
+ * Legacy function for backward compatibility.
+ * New code should use SessionToolFilter class directly.
+ *
+ * @param tools - Tools to filter
+ * @param request - Filter request from header
+ * @param resolver - Operation resolver (optional, for legacy compatibility)
+ * @returns Session filter result
+ */
+export function applySessionToolFilter(tools, request, resolver) {
+    const detector = resolver
+        ? new OperationDetector(new OperationClassifier(), {
+            getOperationById: (operationId) => resolver.getOperationById?.(operationId),
+            getOperationForCall: (call) => resolver.getOperationForCall?.(call),
+        })
+        : undefined;
+    const filter = new SessionToolFilterClass(request, detector);
+    const result = filter.apply(tools);
+    // Convert to legacy format
+    return {
+        allowedToolNames: result.allowedToolNames,
+        reasons: result.reasons,
+        patterns: { allow: [] }, // Not tracked in new architecture
+        normalizedHeader: request.normalizedHeader
+    };
+}
+//# sourceMappingURL=compat.js.map

package/dist/src/tool-filter/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","sourceRoot":"","sources":["../../../src/tool-filter/compat.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,IAAI,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAUtE;;;;;GAKG;AACH,MAAM,UAAU,8BAA8B,CAAC,KAAc;IAC3D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,4BAA4B,CAAC,WAAmB;IAC9D,MAAM,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;IACvC,MAAM,QAAQ,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;IAC9C,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAEhD,OAAO,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAuB,EACvB,OAAiC,EACjC,QAAkG;IAElG,MAAM,QAAQ,GAAG,QAAQ;QACvB,CAAC,CAAC,IAAI,iBAAiB,CACnB,IAAI,mBAAmB,EAAE,EACzB;YACE,gBAAgB,EAAE,CAAC,WAAmB,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,WAAW,CAAC;YACnF,mBAAmB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,CAAC;SAChD,CAC9B;QACH,CAAC,CAAC,SAAS,CAAC;IAEd,MAAM,MAAM,GAAG,IAAI,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAEnC,2BAA2B;IAC3B,OAAO;QACL,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,kCAAkC;QAC3D,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;KAC3C,CAAC;AACJ,CAAC"}

package/dist/src/tool-filter/config/env-config-parser.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Environment variable config parser
+ */
+import type { ToolFilterConfig } from '../types.js';
+import type { RegexCompiler } from '../regex/regex-compiler.js';
+/**
+ * Parses tool filter configuration from environment variables
+ */
+export declare class EnvConfigParser {
+    private compiler;
+    constructor(compiler: RegexCompiler);
+    /**
+     * Parse config from environment variables
+     * @returns Config or undefined if no env vars set
+     */
+    parse(env: NodeJS.ProcessEnv): ToolFilterConfig | undefined;
+    /**
+     * Extract raw config from env vars
+     */
+    private extractRawConfig;
+    /**
+     * Build typed config from raw config
+     */
+    private buildConfig;
+    /**
+     * Parse categories from string array
+     */
+    private parseCategories;
+    /**
+     * Parse CSV list from env var value
+     */
+    private parseCsvList;
+    /**
+     * Check if all arrays are empty
+     */
+    private isEmpty;
+}
+//# sourceMappingURL=env-config-parser.d.ts.map

package/dist/src/tool-filter/config/env-config-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-config-parser.d.ts","sourceRoot":"","sources":["../../../../src/tool-filter/config/env-config-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAiB,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE;;GAEG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3C;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,gBAAgB,GAAG,SAAS;IAS3D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,OAAO,CAAC,WAAW;IAoCnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAsBvB;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,OAAO;CAGhB"}

package/dist/src/tool-filter/config/env-config-parser.js

@@ -0,0 +1,103 @@
+/**
+ * Environment variable config parser
+ */
+import { ConfigurationError } from '../../core/errors.js';
+/**
+ * Parses tool filter configuration from environment variables
+ */
+export class EnvConfigParser {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    /**
+     * Parse config from environment variables
+     * @returns Config or undefined if no env vars set
+     */
+    parse(env) {
+        const raw = this.extractRawConfig(env);
+        if (!raw) {
+            return undefined;
+        }
+        return this.buildConfig(raw);
+    }
+    /**
+     * Extract raw config from env vars
+     */
+    extractRawConfig(env) {
+        const allowList = this.parseCsvList(env.MCP4_TOOL_FILTER_ALLOW_NAMES);
+        const allowRegex = this.parseCsvList(env.MCP4_TOOL_FILTER_ALLOW_NAME_REGEX);
+        const denyList = this.parseCsvList(env.MCP4_TOOL_FILTER_DENY_NAMES);
+        const denyRegex = this.parseCsvList(env.MCP4_TOOL_FILTER_DENY_NAME_REGEX);
+        const allowCategories = this.parseCsvList(env.MCP4_TOOL_FILTER_ALLOW_CATEGORIES);
+        // Check if any config present
+        if (this.isEmpty(allowList, allowRegex, denyList, denyRegex, allowCategories)) {
+            return undefined;
+        }
+        return { allowList, allowRegex, denyList, denyRegex, allowCategories };
+    }
+    /**
+     * Build typed config from raw config
+     */
+    buildConfig(raw) {
+        const allowList = new Set(raw.allowList.map(name => name.normalize('NFC')));
+        const denyList = new Set(raw.denyList.map(name => name.normalize('NFC')));
+        const allowRegex = raw.allowRegex.map(pattern => this.compiler.compile(pattern, 'MCP4_TOOL_FILTER_ALLOW_NAME_REGEX'));
+        const denyRegex = raw.denyRegex.map(pattern => this.compiler.compile(pattern, 'MCP4_TOOL_FILTER_DENY_NAME_REGEX'));
+        const allowCategories = this.parseCategories(raw.allowCategories);
+        const hasAllowRules = raw.allowList.length > 0 ||
+            raw.allowRegex.length > 0 ||
+            allowCategories.size > 0;
+        return {
+            allowList,
+            denyList,
+            allowRegex,
+            denyRegex,
+            allowCategories,
+            hasAllowRules,
+            sources: {
+                allowList: raw.allowList,
+                allowRegex: raw.allowRegex,
+                denyList: raw.denyList,
+                denyRegex: raw.denyRegex,
+                allowCategories: raw.allowCategories
+            }
+        };
+    }
+    /**
+     * Parse categories from string array
+     */
+    parseCategories(entries) {
+        const categories = new Set();
+        for (const entry of entries) {
+            if (!entry) {
+                continue;
+            }
+            const normalized = entry.trim().toLowerCase();
+            if (normalized === 'list' || normalized === 'read') {
+                categories.add(normalized);
+                continue;
+            }
+            throw new ConfigurationError(`MCP4_TOOL_FILTER_ALLOW_CATEGORIES supports only 'list' and 'read', got '${entry}'`);
+        }
+        return categories;
+    }
+    /**
+     * Parse CSV list from env var value
+     */
+    parseCsvList(value) {
+        if (!value) {
+            return [];
+        }
+        return value
+            .split(',')
+            .map(part => part.trim())
+            .filter(Boolean);
+    }
+    /**
+     * Check if all arrays are empty
+     */
+    isEmpty(...arrays) {
+        return arrays.every(arr => arr.length === 0);
+    }
+}
+//# sourceMappingURL=env-config-parser.js.map

package/dist/src/tool-filter/config/env-config-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-config-parser.js","sourceRoot":"","sources":["../../../../src/tool-filter/config/env-config-parser.ts"],"names":[],"mappings":"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"}

package/dist/src/tool-filter/config/header-config-parser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Header config parser for session-based filtering
+ */
+import type { SessionToolFilterRequest } from '../types.js';
+import type { RegexCompiler } from '../regex/regex-compiler.js';
+/**
+ * Parses X-Mcp4-Tools header for session filtering
+ */
+export declare class HeaderConfigParser {
+    private compiler;
+    constructor(compiler: RegexCompiler);
+    /**
+     * Parse header value into session filter request
+     */
+    parse(headerValue: string): SessionToolFilterRequest;
+    /**
+     * Normalize header value
+     */
+    private normalizeHeader;
+    /**
+     * Split and validate header parts
+     */
+    private splitAndValidate;
+    /**
+     * Parse header parts into structured data
+     */
+    private parseParts;
+    /**
+     * Get max entries from env var
+     */
+    private getMaxEntries;
+    /**
+     * Create empty request
+     */
+    private emptyRequest;
+}
+//# sourceMappingURL=header-config-parser.d.ts.map

package/dist/src/tool-filter/config/header-config-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-config-parser.d.ts","sourceRoot":"","sources":["../../../../src/tool-filter/config/header-config-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAiB,MAAM,aAAa,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAMhE;;GAEG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3C;;OAEG;IACH,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB;IAmBpD;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;IACH,OAAO,CAAC,UAAU;IA6BlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,OAAO,CAAC,YAAY;CAUrB"}

package/dist/src/tool-filter/config/header-config-parser.js

@@ -0,0 +1,118 @@
+/**
+ * Header config parser for session-based filtering
+ */
+import { ValidationError, ConfigurationError } from '../../core/errors.js';
+const MAX_HEADER_ENTRY_LENGTH = 255;
+const DEFAULT_MAX_ENTRIES = 100;
+/**
+ * Parses X-Mcp4-Tools header for session filtering
+ */
+export class HeaderConfigParser {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    /**
+     * Parse header value into session filter request
+     */
+    parse(headerValue) {
+        const normalized = this.normalizeHeader(headerValue);
+        if (!normalized) {
+            return this.emptyRequest();
+        }
+        const parts = this.splitAndValidate(normalized);
+        const parsed = this.parseParts(parts);
+        return {
+            exactNames: parsed.exactNames,
+            regexPatterns: parsed.regexPatterns,
+            allowCategories: parsed.allowCategories,
+            normalizedHeader: normalized,
+            rawEntries: parts,
+            hasRules: parts.length > 0
+        };
+    }
+    /**
+     * Normalize header value
+     */
+    normalizeHeader(value) {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : '';
+    }
+    /**
+     * Split and validate header parts
+     */
+    splitAndValidate(value) {
+        const parts = value.split(',').map(p => p.trim()).filter(Boolean);
+        const maxEntries = this.getMaxEntries();
+        if (parts.length > maxEntries) {
+            throw new ValidationError(`X-Mcp4-Tools contains too many entries (${parts.length} > ${maxEntries}). ` +
+                `Reduce to ${maxEntries} or configure MCP4_TOOL_FILTER_SESSION_MAX_TOOLS.`);
+        }
+        // Validate entry lengths
+        for (const part of parts) {
+            if (part.length > MAX_HEADER_ENTRY_LENGTH) {
+                throw new ValidationError(`X-Mcp4-Tools entry exceeds ${MAX_HEADER_ENTRY_LENGTH} chars: ` +
+                    `'${part}' (${part.length} chars)`);
+            }
+        }
+        return parts;
+    }
+    /**
+     * Parse header parts into structured data
+     */
+    parseParts(parts) {
+        const exactNames = new Set();
+        const regexPatterns = [];
+        const allowCategories = new Set();
+        for (const part of parts) {
+            if (part === '_allow_list') {
+                allowCategories.add('list');
+            }
+            else if (part === '_allow_read') {
+                allowCategories.add('read');
+            }
+            else if (part.startsWith('_allow_')) {
+                throw new ValidationError('X-Mcp4-Tools supports only _allow_list and _allow_read. ' +
+                    'Other _allow_* keywords are not supported here. (Did you mean to use X-Mcp4-Params?)');
+            }
+            else if (part.startsWith('regex:')) {
+                const pattern = part.slice('regex:'.length).trim();
+                if (!pattern) {
+                    throw new ValidationError('X-Mcp4-Tools regex entry is empty');
+                }
+                regexPatterns.push(this.compiler.compile(pattern, 'X-Mcp4-Tools'));
+            }
+            else {
+                exactNames.add(part.normalize('NFC'));
+            }
+        }
+        return { exactNames, regexPatterns, allowCategories };
+    }
+    /**
+     * Get max entries from env var
+     */
+    getMaxEntries() {
+        const raw = process.env.MCP4_TOOL_FILTER_SESSION_MAX_TOOLS;
+        if (!raw) {
+            return DEFAULT_MAX_ENTRIES;
+        }
+        const parsed = parseInt(raw, 10);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            throw new ConfigurationError(`Invalid MCP4_TOOL_FILTER_SESSION_MAX_TOOLS: '${raw}' (must be positive integer)`);
+        }
+        return parsed;
+    }
+    /**
+     * Create empty request
+     */
+    emptyRequest() {
+        return {
+            exactNames: new Set(),
+            regexPatterns: [],
+            allowCategories: new Set(),
+            normalizedHeader: '',
+            rawEntries: [],
+            hasRules: false
+        };
+    }
+}
+//# sourceMappingURL=header-config-parser.js.map

package/dist/src/tool-filter/config/header-config-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-config-parser.js","sourceRoot":"","sources":["../../../../src/tool-filter/config/header-config-parser.ts"],"names":[],"mappings":"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"}

package/dist/src/tool-filter/errors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tool filter specific errors
+ */
+import { ConfigurationError as BaseConfigError, ValidationError as BaseValidationError } from '../core/errors.js';
+/**
+ * Invalid regex pattern error
+ */
+export declare class InvalidRegexError extends BaseConfigError {
+    readonly context: string;
+    readonly pattern: string;
+    readonly reason: string;
+    constructor(context: string, pattern: string, reason: string);
+}
+/**
+ * Re-export base errors for convenience
+ */
+export { BaseConfigError as ConfigurationError, BaseValidationError as ValidationError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/tool-filter/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/tool-filter/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,IAAI,eAAe,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAElH;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;aAElC,OAAO,EAAE,MAAM;aACf,OAAO,EAAE,MAAM;aACf,MAAM,EAAE,MAAM;gBAFd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM;CAKjC;AAED;;GAEG;AACH,OAAO,EAAE,eAAe,IAAI,kBAAkB,EAAE,mBAAmB,IAAI,eAAe,EAAE,CAAC"}

package/dist/src/tool-filter/errors.js

@@ -0,0 +1,21 @@
+/**
+ * Tool filter specific errors
+ */
+import { ConfigurationError as BaseConfigError, ValidationError as BaseValidationError } from '../core/errors.js';
+/**
+ * Invalid regex pattern error
+ */
+export class InvalidRegexError extends BaseConfigError {
+    constructor(context, pattern, reason) {
+        super(`${context} regex '${pattern}' is invalid: ${reason}`);
+        this.context = context;
+        this.pattern = pattern;
+        this.reason = reason;
+        this.name = 'InvalidRegexError';
+    }
+}
+/**
+ * Re-export base errors for convenience
+ */
+export { BaseConfigError as ConfigurationError, BaseValidationError as ValidationError };
+//# sourceMappingURL=errors.js.map

package/dist/src/tool-filter/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/tool-filter/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,IAAI,eAAe,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAElH;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,eAAe;IACpD,YACkB,OAAe,EACf,OAAe,EACf,MAAc;QAE9B,KAAK,CAAC,GAAG,OAAO,WAAW,OAAO,iBAAiB,MAAM,EAAE,CAAC,CAAC;QAJ7C,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAQ;QACf,WAAM,GAAN,MAAM,CAAQ;QAG9B,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AAED;;GAEG;AACH,OAAO,EAAE,eAAe,IAAI,kBAAkB,EAAE,mBAAmB,IAAI,eAAe,EAAE,CAAC"}

package/dist/src/tool-filter/filter/filter-engine.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Filter engine - orchestrates filter rules
+ */
+import type { FilterRule } from './filter-rules.js';
+import type { ToolDefinition } from '../../types/profile.js';
+/**
+ * Filter result
+ */
+export declare class FilterResult {
+    readonly allowed: boolean;
+    readonly reason?: string | undefined;
+    private constructor();
+    static allowed(reason?: string): FilterResult;
+    static denied(reason: string): FilterResult;
+}
+/**
+ * Filter engine that evaluates tools against rules
+ */
+export declare class FilterEngine {
+    private allowRules;
+    private denyRules;
+    constructor(allowRules: FilterRule[], denyRules: FilterRule[]);
+    /**
+     * Evaluate tool name against rules
+     *
+     * Rule precedence:
+     * 1. Deny rules (if any match, deny immediately)
+     * 2. If no allow rules, allow by default
+     * 3. Allow rules (must match at least one)
+     */
+    evaluate(toolName: string): FilterResult;
+    /**
+     * Evaluate tool definition against rules
+     *
+     * Used when rules need full tool definition (e.g., CategoryMatchRule).
+     * Tool name is normalized (NFC) before passing to name-based rules.
+     *
+     * Rule precedence:
+     * 1. Deny rules (if any match, deny immediately)
+     * 2. If no allow rules, allow by default
+     * 3. Allow rules (must match at least one)
+     */
+    evaluateTool(tool: ToolDefinition): FilterResult;
+}
+//# sourceMappingURL=filter-engine.d.ts.map

package/dist/src/tool-filter/filter/filter-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-engine.d.ts","sourceRoot":"","sources":["../../../../src/tool-filter/filter/filter-engine.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D;;GAEG;AACH,qBAAa,YAAY;aAEL,OAAO,EAAE,OAAO;aAChB,MAAM,CAAC,EAAE,MAAM;IAFjC,OAAO;IAKP,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,YAAY;IAI7C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;CAG5C;AAED;;GAEG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,SAAS;gBADT,UAAU,EAAE,UAAU,EAAE,EACxB,SAAS,EAAE,UAAU,EAAE;IAGjC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY;IA2BxC;;;;;;;;;;OAUG;IACH,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY;CA6BjD"}