ferret-scan 2.1.2 → 2.3.0

package/dist/__tests__/scannerExtra.test.js

@@ -0,0 +1,194 @@
+/**
+ * Additional Scanner Tests
+ * Tests for getExitCode and other scanner utility functions
+ */
+// Mock ora to prevent ESM issues in scanner
+jest.mock('ora', () => ({
+    __esModule: true,
+    default: jest.fn().mockReturnValue({
+        start: jest.fn().mockReturnThis(),
+        stop: jest.fn().mockReturnThis(),
+        succeed: jest.fn().mockReturnThis(),
+        fail: jest.fn().mockReturnThis(),
+        text: '',
+    }),
+}));
+// Mock all the ESM-only analyzers
+jest.mock('../scanner/analyzers/EntropyAnalyzer.js', () => ({
+    EntropyAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/McpAnalyzer.js', () => ({
+    McpAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/DependencyAnalyzer.js', () => ({
+    DependencyAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/CapabilityAnalyzer.js', () => ({
+    CapabilityAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/LlmAnalyzer.js', () => ({
+    LlmAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/SemanticAnalyzer.js', () => ({
+    SemanticAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+jest.mock('../scanner/analyzers/ThreatIntelAnalyzer.js', () => ({
+    ThreatIntelAnalyzer: jest.fn().mockImplementation(() => ({
+        analyze: jest.fn().mockResolvedValue([]),
+    })),
+}));
+import { getExitCode } from '../scanner/Scanner.js';
+import { DEFAULT_CONFIG } from '../types.js';
+function makeFinding(severity) {
+    return {
+        ruleId: 'TEST-001',
+        ruleName: 'Test',
+        severity,
+        category: 'injection',
+        file: '/test.md',
+        relativePath: 'test.md',
+        line: 1,
+        match: 'bad',
+        context: [],
+        remediation: 'fix',
+        timestamp: new Date(),
+        riskScore: 75,
+    };
+}
+function makeScanResult(overrides = {}) {
+    return {
+        success: true,
+        startTime: new Date(),
+        endTime: new Date(),
+        duration: 100,
+        scannedPaths: ['/project'],
+        totalFiles: 1,
+        analyzedFiles: 1,
+        skippedFiles: 0,
+        findings: [],
+        findingsBySeverity: {
+            CRITICAL: [],
+            HIGH: [],
+            MEDIUM: [],
+            LOW: [],
+            INFO: [],
+        },
+        findingsByCategory: {},
+        overallRiskScore: 0,
+        summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0, total: 0 },
+        errors: [],
+        ...overrides,
+    };
+}
+function makeConfig(failOn = 'HIGH') {
+    return { ...DEFAULT_CONFIG, failOn };
+}
+describe('getExitCode', () => {
+    it('returns 0 when no findings', () => {
+        const result = makeScanResult();
+        expect(getExitCode(result, makeConfig('HIGH'))).toBe(0);
+    });
+    it('returns 3 when success=false', () => {
+        const result = makeScanResult({ success: false });
+        expect(getExitCode(result, makeConfig())).toBe(3);
+    });
+    it('returns 2 for CRITICAL findings with failOn=CRITICAL', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [makeFinding('CRITICAL')],
+                HIGH: [], MEDIUM: [], LOW: [], INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('CRITICAL'))).toBe(2);
+    });
+    it('returns 2 for CRITICAL findings with failOn=HIGH', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [makeFinding('CRITICAL')],
+                HIGH: [], MEDIUM: [], LOW: [], INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('HIGH'))).toBe(2);
+    });
+    it('returns 1 for HIGH findings with failOn=HIGH', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [],
+                HIGH: [makeFinding('HIGH')],
+                MEDIUM: [], LOW: [], INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('HIGH'))).toBe(1);
+    });
+    it('returns 0 for HIGH findings with failOn=CRITICAL', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [],
+                HIGH: [makeFinding('HIGH')],
+                MEDIUM: [], LOW: [], INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('CRITICAL'))).toBe(0);
+    });
+    it('returns 1 for MEDIUM findings with failOn=MEDIUM', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [], HIGH: [],
+                MEDIUM: [makeFinding('MEDIUM')],
+                LOW: [], INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('MEDIUM'))).toBe(1);
+    });
+    it('returns 0 for LOW findings with failOn=HIGH', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [], HIGH: [], MEDIUM: [],
+                LOW: [makeFinding('LOW')],
+                INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('HIGH'))).toBe(0);
+    });
+    it('returns 1 for LOW findings with failOn=LOW', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [], HIGH: [], MEDIUM: [],
+                LOW: [makeFinding('LOW')],
+                INFO: [],
+            },
+        });
+        expect(getExitCode(result, makeConfig('LOW'))).toBe(1);
+    });
+    it('returns 0 for INFO findings with failOn=LOW', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [], HIGH: [], MEDIUM: [], LOW: [],
+                INFO: [makeFinding('INFO')],
+            },
+        });
+        expect(getExitCode(result, makeConfig('LOW'))).toBe(0);
+    });
+    it('returns 1 for INFO findings with failOn=INFO', () => {
+        const result = makeScanResult({
+            findingsBySeverity: {
+                CRITICAL: [], HIGH: [], MEDIUM: [], LOW: [],
+                INFO: [makeFinding('INFO')],
+            },
+        });
+        expect(getExitCode(result, makeConfig('INFO'))).toBe(1);
+    });
+});
+//# sourceMappingURL=scannerExtra.test.js.map

package/dist/__tests__/scannerMitre.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scanner MITRE Atlas and LLM initialization tests
+ */
+export {};
+//# sourceMappingURL=scannerMitre.test.d.ts.map

package/dist/__tests__/scannerMitre.test.js

@@ -0,0 +1,141 @@
+/**
+ * Scanner MITRE Atlas and LLM initialization tests
+ */
+jest.mock('ora', () => ({
+    __esModule: true,
+    default: jest.fn().mockReturnValue({
+        start: jest.fn().mockReturnThis(),
+        stop: jest.fn().mockReturnThis(),
+        succeed: jest.fn().mockReturnThis(),
+        fail: jest.fn().mockReturnThis(),
+        text: '',
+    }),
+}));
+import { scan } from '../scanner/Scanner.js';
+import { DEFAULT_CONFIG } from '../types.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+function makeConfig(overrides = {}) {
+    return {
+        ...DEFAULT_CONFIG,
+        ci: true,
+        verbose: false,
+        llmAnalysis: false,
+        threatIntel: false,
+        semanticAnalysis: false,
+        correlationAnalysis: false,
+        entropyAnalysis: false,
+        mcpValidation: false,
+        dependencyAnalysis: false,
+        capabilityMapping: false,
+        mitreAtlas: false,
+        mitreAtlasCatalog: {
+            ...DEFAULT_CONFIG.mitreAtlasCatalog,
+            enabled: false,
+        },
+        ...overrides,
+    };
+}
+describe('scan() with mitreAtlasCatalog', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ferret-mitre-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('handles mitreAtlasCatalog.enabled=true with failed catalog load', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        const config = makeConfig({
+            paths: [tmpDir],
+            mitreAtlasCatalog: {
+                enabled: true,
+                autoUpdate: false,
+                sourceUrl: 'http://localhost:9999/nonexistent', // Will fail
+                cachePath: path.join(tmpDir, 'nonexistent-cache.json'),
+                cacheTtlHours: 0,
+                timeoutMs: 100,
+                forceRefresh: false,
+            },
+        });
+        // Should succeed even with catalog load failure
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+        // Should have a non-fatal error about catalog
+        expect(result.errors.some(e => e.message.includes('catalog'))).toBe(true);
+    });
+    it('handles LLM enabled but missing API key', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        // Make sure env var doesn't exist
+        const origKey = process.env['NONEXISTENT_KEY_ABC123'];
+        delete process.env['NONEXISTENT_KEY_ABC123'];
+        const config = makeConfig({
+            paths: [tmpDir],
+            llmAnalysis: true,
+            llm: {
+                ...DEFAULT_CONFIG.llm,
+                provider: 'openai-compatible',
+                baseUrl: 'https://api.openai.com/v1/chat/completions',
+                apiKeyEnv: 'NONEXISTENT_KEY_ABC123',
+            },
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+        // Should have a non-fatal error about LLM
+        expect(result.errors.some(e => e.message.includes('LLM') || e.message.includes('provider'))).toBe(true);
+        if (origKey !== undefined)
+            process.env['NONEXISTENT_KEY_ABC123'] = origKey;
+    });
+});
+describe('scan() with custom rules', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ferret-custom-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('loads custom rules from file', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        const rulesPath = path.join(tmpDir, 'custom-rules.json');
+        fs.writeFileSync(rulesPath, JSON.stringify({
+            version: '1.0',
+            rules: [
+                {
+                    id: 'CUSTOM-001',
+                    name: 'Test Custom Rule',
+                    category: 'injection',
+                    severity: 'HIGH',
+                    description: 'Test rule',
+                    patterns: ['test-pattern-xyz'],
+                },
+            ],
+        }));
+        const config = makeConfig({
+            paths: [tmpDir],
+            customRules: [rulesPath],
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+    });
+    it('handles invalid custom rules file gracefully', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        const config = makeConfig({
+            paths: [tmpDir],
+            customRules: ['/nonexistent/rules.json'],
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+        // Invalid rules file should generate a non-fatal error
+    });
+});
+//# sourceMappingURL=scannerMitre.test.js.map

package/dist/__tests__/scannerSSRF.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scanner SSRF protection and remote rules tests
+ */
+export {};
+//# sourceMappingURL=scannerSSRF.test.d.ts.map

package/dist/__tests__/scannerSSRF.test.js

@@ -0,0 +1,149 @@
+/**
+ * Scanner SSRF protection and remote rules tests
+ */
+jest.mock('ora', () => ({
+    __esModule: true,
+    default: jest.fn().mockReturnValue({
+        start: jest.fn().mockReturnThis(),
+        stop: jest.fn().mockReturnThis(),
+        succeed: jest.fn().mockReturnThis(),
+        fail: jest.fn().mockReturnThis(),
+        text: '',
+    }),
+}));
+import { scan } from '../scanner/Scanner.js';
+import { DEFAULT_CONFIG } from '../types.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+function makeConfig(overrides = {}) {
+    return {
+        ...DEFAULT_CONFIG,
+        ci: true,
+        verbose: false,
+        llmAnalysis: false,
+        threatIntel: false,
+        semanticAnalysis: false,
+        correlationAnalysis: false,
+        entropyAnalysis: false,
+        mcpValidation: false,
+        dependencyAnalysis: false,
+        capabilityMapping: false,
+        mitreAtlas: false,
+        mitreAtlasCatalog: {
+            ...DEFAULT_CONFIG.mitreAtlasCatalog,
+            enabled: false,
+        },
+        ...overrides,
+    };
+}
+describe('scan() SSRF protection', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ferret-ssrf-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('blocks remote custom rules URLs when allowRemoteRules=false', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        const config = makeConfig({
+            paths: [tmpDir],
+            customRules: ['https://malicious.example.com/rules.json'],
+            allowRemoteRules: false,
+        });
+        // Should succeed but skip the remote URL
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+        // The remote URL should be blocked - no findings from it
+    });
+    it('allows remote custom rules URLs when allowRemoteRules=true', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        // Mock fetch to return valid rules
+        globalThis.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({
+                version: '1.0',
+                rules: [{
+                        id: 'CUSTOM-001',
+                        name: 'Remote Rule',
+                        category: 'injection',
+                        severity: 'HIGH',
+                        description: 'Test',
+                        patterns: ['nonexistent-pattern-xyz-abc'],
+                    }],
+            })),
+        });
+        const config = makeConfig({
+            paths: [tmpDir],
+            customRules: ['https://trusted.example.com/rules.json'],
+            allowRemoteRules: true,
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+    });
+    it('handles conventional rule discovery from .ferret/ directory', async () => {
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent');
+        // Create a .ferret/rules.json in the scan path
+        const ferretDir = path.join(tmpDir, '.ferret');
+        fs.mkdirSync(ferretDir);
+        fs.writeFileSync(path.join(ferretDir, 'rules.json'), JSON.stringify({
+            version: '1.0',
+            rules: [{
+                    id: 'CUSTOM-001',
+                    name: 'Convention Rule',
+                    category: 'injection',
+                    severity: 'HIGH',
+                    description: 'Test',
+                    patterns: ['convention-pattern-xyz'],
+                }],
+        }));
+        const config = makeConfig({ paths: [tmpDir] });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+    });
+});
+describe('scan() documentation dampening', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ferret-docpath-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('dampens CRED-001 CRITICAL in documentation paths', async () => {
+        // Create a docs directory with a markdown file that might trigger CRED-001
+        const docsDir = path.join(tmpDir, 'docs');
+        fs.mkdirSync(docsDir);
+        // Create a file that would be a "documentation path"
+        fs.writeFileSync(path.join(docsDir, 'readme.md'), '# Documentation\nThis is documentation about usage.');
+        const agentsDir = path.join(tmpDir, '.claude', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'agent.md'), '# Agent\nSome config here.');
+        const config = makeConfig({
+            paths: [tmpDir],
+            docDampening: true,
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+    });
+    it('scan with references/ directory detects documentation path', async () => {
+        const refsDir = path.join(tmpDir, '.claude', 'plugins', 'marketplaces', 'plugin1', 'references');
+        fs.mkdirSync(refsDir, { recursive: true });
+        fs.writeFileSync(path.join(refsDir, 'api.md'), '# API Reference\nDocumentation here.');
+        const config = makeConfig({
+            paths: [tmpDir],
+            docDampening: true,
+            marketplaceMode: 'all',
+        });
+        const result = await scan(config);
+        expect(result.success).toBe(true);
+    });
+});
+//# sourceMappingURL=scannerSSRF.test.js.map

package/dist/__tests__/schemas.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Schemas Tests
+ * Tests for safeParseJSON and validateSchema utilities
+ */
+export {};
+//# sourceMappingURL=schemas.test.d.ts.map

package/dist/__tests__/schemas.test.js

@@ -0,0 +1,125 @@
+/**
+ * Schemas Tests
+ * Tests for safeParseJSON and validateSchema utilities
+ */
+import { safeParseJSON, validateSchema, ConfigFileSchema, BaselineSchema, } from '../utils/schemas.js';
+import { z } from 'zod';
+describe('safeParseJSON', () => {
+    const SimpleSchema = z.object({
+        name: z.string(),
+        value: z.number(),
+    });
+    it('returns success for valid JSON matching schema', () => {
+        const result = safeParseJSON('{"name":"test","value":42}', SimpleSchema);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.name).toBe('test');
+            expect(result.data.value).toBe(42);
+        }
+    });
+    it('returns failure for invalid JSON', () => {
+        const result = safeParseJSON('{invalid json}', SimpleSchema);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toContain('JSON parse error');
+        }
+    });
+    it('returns failure when schema validation fails', () => {
+        const result = safeParseJSON('{"name":123,"value":"not-a-number"}', SimpleSchema);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toContain('Schema validation failed');
+        }
+    });
+    it('returns failure for content exceeding maxLength', () => {
+        const bigContent = JSON.stringify({ name: 'x'.repeat(100), value: 1 });
+        const result = safeParseJSON(bigContent, SimpleSchema, { maxLength: 10 });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toContain('exceeds maximum length');
+        }
+    });
+    it('uses default 10MB maxLength', () => {
+        const content = JSON.stringify({ name: 'test', value: 1 });
+        const result = safeParseJSON(content, SimpleSchema);
+        expect(result.success).toBe(true);
+    });
+    it('parses ConfigFileSchema', () => {
+        const content = JSON.stringify({
+            severity: ['CRITICAL', 'HIGH'],
+            ignore: ['node_modules/**'],
+        });
+        const result = safeParseJSON(content, ConfigFileSchema);
+        expect(result.success).toBe(true);
+    });
+    it('rejects unknown severity values in ConfigFileSchema', () => {
+        const content = JSON.stringify({
+            severity: ['INVALID_SEVERITY'],
+        });
+        const result = safeParseJSON(content, ConfigFileSchema);
+        expect(result.success).toBe(false);
+    });
+    it('accepts empty object for ConfigFileSchema (all fields optional)', () => {
+        const result = safeParseJSON('{}', ConfigFileSchema);
+        expect(result.success).toBe(true);
+    });
+    it('limits error reporting to 5 issues', () => {
+        const StrictSchema = z.object({
+            a: z.number(),
+            b: z.number(),
+            c: z.number(),
+            d: z.number(),
+            e: z.number(),
+            f: z.number(),
+        });
+        const result = safeParseJSON('{"a":"x","b":"x","c":"x","d":"x","e":"x","f":"x"}', StrictSchema);
+        expect(result.success).toBe(false);
+        // Error message should not be excessively long
+        if (!result.success) {
+            expect(result.error.length).toBeLessThan(5000);
+        }
+    });
+});
+describe('validateSchema', () => {
+    const PersonSchema = z.object({
+        name: z.string().min(1),
+        age: z.number().int().min(0),
+    });
+    it('returns success for valid data', () => {
+        const result = validateSchema({ name: 'Alice', age: 30 }, PersonSchema);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.name).toBe('Alice');
+        }
+    });
+    it('returns failure for invalid data', () => {
+        const result = validateSchema({ name: '', age: -1 }, PersonSchema);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toContain('Schema validation failed');
+        }
+    });
+    it('returns failure for wrong type', () => {
+        const result = validateSchema('not-an-object', PersonSchema);
+        expect(result.success).toBe(false);
+    });
+    it('returns failure for null', () => {
+        const result = validateSchema(null, PersonSchema);
+        expect(result.success).toBe(false);
+    });
+    it('validates BaselineSchema structure', () => {
+        const baseline = {
+            version: '1.0.0',
+            createdDate: '2024-01-01T00:00:00Z',
+            lastUpdated: '2024-01-01T00:00:00Z',
+            findings: [],
+        };
+        const result = validateSchema(baseline, BaselineSchema);
+        expect(result.success).toBe(true);
+    });
+    it('rejects BaselineSchema with missing required fields', () => {
+        const result = validateSchema({ version: '1.0.0' }, BaselineSchema);
+        expect(result.success).toBe(false);
+    });
+});
+//# sourceMappingURL=schemas.test.js.map

package/dist/__tests__/webhooks.extra.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Additional Webhook Tests
+ * Covers sendWebhook with slack/discord/teams includeDetails formatting
+ */
+export {};
+//# sourceMappingURL=webhooks.extra.test.d.ts.map