ferret-scan 2.2.0 → 2.4.0

package/dist/__tests__/MarketplaceScanner.test.js

@@ -0,0 +1,212 @@
+/**
+ * MarketplaceScanner Tests
+ */
+import { MarketplaceScanner } from '../marketplace/MarketplaceScanner.js';
+// Mock the scan function to avoid real FS operations
+jest.mock('../scanner/Scanner.js', () => ({
+    scan: jest.fn().mockResolvedValue({ findings: [] }),
+}));
+// Mock fs/promises to avoid real temp dir creation
+jest.mock('fs/promises', () => ({
+    mkdtemp: jest.fn().mockResolvedValue('/tmp/test-plugin-dir'),
+    rm: jest.fn().mockResolvedValue(undefined),
+}));
+function makePlugin(overrides = {}) {
+    return {
+        id: 'test-plugin-001',
+        name: 'Test Plugin',
+        author: 'test-author',
+        version: '1.0.0',
+        source: 'community',
+        capabilities: [],
+        permissions: [],
+        metadata: {
+            description: 'A test plugin',
+            downloads: 1000,
+            rating: 4.0,
+            lastUpdated: new Date('2024-01-01'),
+        },
+        ...overrides,
+    };
+}
+describe('MarketplaceScanner', () => {
+    let scanner;
+    beforeEach(() => {
+        scanner = new MarketplaceScanner();
+    });
+    // -------------------------------------------------------------------------
+    // scanMarketplace
+    // -------------------------------------------------------------------------
+    describe('scanMarketplace', () => {
+        it('returns empty array when no plugins found', async () => {
+            const config = { source: 'claude-marketplace' };
+            const results = await scanner.scanMarketplace(config);
+            expect(results).toEqual([]);
+        });
+        it('resolves without throwing for generic source', async () => {
+            await expect(scanner.scanMarketplace({ source: 'community' })).resolves.toBeDefined();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // analyzePlugin – permission checks
+    // -------------------------------------------------------------------------
+    describe('analyzePlugin – permission checks', () => {
+        it('returns safe recommendation for plugin with no capabilities', async () => {
+            const plugin = makePlugin({ capabilities: [] });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.plugin).toBe(plugin);
+            expect(result.recommendation).toBe('safe');
+            expect(result.riskScore).toBe(0);
+        });
+        it('detects shell:execute + network:outbound as CRITICAL', async () => {
+            const plugin = makePlugin({
+                capabilities: ['shell:execute', 'network:outbound'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.findings.some(f => f.severity === 'CRITICAL')).toBe(true);
+            expect(result.recommendation).toBe('malicious');
+        });
+        it('detects file:write + network:outbound + startup:autorun as CRITICAL', async () => {
+            const plugin = makePlugin({
+                capabilities: ['file:write', 'network:outbound', 'startup:autorun'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            const criticalFindings = result.findings.filter(f => f.severity === 'CRITICAL');
+            expect(criticalFindings.length).toBeGreaterThan(0);
+        });
+        it('detects clipboard:read + network:outbound as HIGH', async () => {
+            const plugin = makePlugin({
+                capabilities: ['clipboard:read', 'network:outbound'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.findings.some(f => f.severity === 'HIGH')).toBe(true);
+        });
+        it('detects file:read + network:outbound as MEDIUM', async () => {
+            const plugin = makePlugin({
+                capabilities: ['file:read', 'network:outbound'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.findings.some(f => f.severity === 'MEDIUM')).toBe(true);
+        });
+        it('detects excessive permissions (>8 capabilities)', async () => {
+            const plugin = makePlugin({
+                capabilities: [
+                    'cap1', 'cap2', 'cap3', 'cap4', 'cap5',
+                    'cap6', 'cap7', 'cap8', 'cap9',
+                ],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            const excessFindings = result.findings.filter(f => f.ruleId === 'MARKETPLACE-002');
+            expect(excessFindings.length).toBe(1);
+            expect(excessFindings[0]?.severity).toBe('MEDIUM');
+        });
+        it('does not flag exactly 8 capabilities', async () => {
+            const plugin = makePlugin({
+                capabilities: ['cap1', 'cap2', 'cap3', 'cap4', 'cap5', 'cap6', 'cap7', 'cap8'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            const excessFindings = result.findings.filter(f => f.ruleId === 'MARKETPLACE-002');
+            expect(excessFindings.length).toBe(0);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // risk score calculation
+    // -------------------------------------------------------------------------
+    describe('risk score calculation', () => {
+        it('reduces risk for popular highly-rated plugins (>10k downloads, >4.5 rating)', async () => {
+            const dangerousPlugin = makePlugin({
+                capabilities: ['file:read', 'network:outbound'],
+                metadata: {
+                    description: 'Popular plugin',
+                    downloads: 50000,
+                    rating: 4.8,
+                    lastUpdated: new Date(),
+                },
+            });
+            const lowRatedPlugin = makePlugin({
+                capabilities: ['file:read', 'network:outbound'],
+                metadata: {
+                    description: 'Low-rated plugin',
+                    downloads: 100,
+                    rating: 2.0,
+                    lastUpdated: new Date(),
+                },
+            });
+            const popularResult = await scanner.analyzePlugin(dangerousPlugin);
+            const lowRatedResult = await scanner.analyzePlugin(lowRatedPlugin);
+            expect(popularResult.riskScore).toBeLessThanOrEqual(lowRatedResult.riskScore);
+        });
+        it('reduces risk for claude-marketplace source', async () => {
+            const marketplacePlugin = makePlugin({
+                capabilities: ['file:read', 'network:outbound'],
+                source: 'claude-marketplace',
+            });
+            const communityPlugin = makePlugin({
+                capabilities: ['file:read', 'network:outbound'],
+                source: 'community',
+            });
+            const marketplaceResult = await scanner.analyzePlugin(marketplacePlugin);
+            const communityResult = await scanner.analyzePlugin(communityPlugin);
+            expect(marketplaceResult.riskScore).toBeLessThanOrEqual(communityResult.riskScore);
+        });
+        it('caps risk score at 100', async () => {
+            const plugin = makePlugin({
+                capabilities: [
+                    'shell:execute', 'network:outbound',
+                    'file:write', 'startup:autorun',
+                    'clipboard:read',
+                ],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.riskScore).toBeLessThanOrEqual(100);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // recommendation thresholds
+    // -------------------------------------------------------------------------
+    describe('recommendations', () => {
+        it('returns safe for risk 0', async () => {
+            const plugin = makePlugin({ capabilities: [] });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.recommendation).toBe('safe');
+        });
+        it('returns malicious when CRITICAL finding present', async () => {
+            const plugin = makePlugin({
+                capabilities: ['shell:execute', 'network:outbound'],
+            });
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result.recommendation).toBe('malicious');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // analyzePlugin with sourceCode triggers code analysis path
+    // -------------------------------------------------------------------------
+    describe('analyzePlugin with sourceCode', () => {
+        it('includes code findings when sourceCode is provided', async () => {
+            const plugin = makePlugin({
+                sourceCode: '// some plugin code\nconst x = 1;',
+                capabilities: [],
+            });
+            // scan is mocked to return no findings
+            const result = await scanner.analyzePlugin(plugin);
+            expect(result).toBeDefined();
+            expect(result.findings).toBeDefined();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // error handling in scanMarketplace
+    // -------------------------------------------------------------------------
+    describe('error handling', () => {
+        it('handles analysis errors gracefully', async () => {
+            // Patch analyzePlugin to throw
+            const errorScanner = new MarketplaceScanner();
+            errorScanner.fetchPluginList = async () => [makePlugin()];
+            errorScanner.analyzePlugin = jest.fn().mockRejectedValue(new Error('analysis failed'));
+            const results = await errorScanner.scanMarketplace({ source: 'community' });
+            expect(results).toHaveLength(1);
+            expect(results[0]?.analysisSkipped).toContain('analysis failed');
+            expect(results[0]?.recommendation).toBe('review');
+        });
+    });
+});
+//# sourceMappingURL=MarketplaceScanner.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * RuleGenerator Tests
+ * Tests for AIRuleGenerator in src/ai-rules/RuleGenerator.ts
+ */
+export {};
+//# sourceMappingURL=RuleGenerator.test.d.ts.map

package/dist/__tests__/RuleGenerator.test.js

@@ -0,0 +1,207 @@
+/**
+ * RuleGenerator Tests
+ * Tests for AIRuleGenerator in src/ai-rules/RuleGenerator.ts
+ */
+import { AIRuleGenerator } from '../ai-rules/RuleGenerator.js';
+// Mock the LLM provider creation
+jest.mock('../features/llmAnalysis.js', () => ({
+    createLlmProvider: jest.fn().mockReturnValue({
+        name: 'mock-provider',
+        analyze: jest.fn(),
+    }),
+}));
+import { createLlmProvider } from '../features/llmAnalysis.js';
+function makeThreatReport(overrides = {}) {
+    return {
+        id: 'THREAT-001',
+        title: 'Prompt Injection Attack',
+        category: 'injection',
+        description: 'Attacker crafts prompts to override instructions',
+        attackVectors: ['user input', 'system prompt manipulation'],
+        iocs: ['IGNORE PREVIOUS', 'jailbreak', 'DAN mode'],
+        ...overrides,
+    };
+}
+describe('AIRuleGenerator', () => {
+    let generator;
+    let mockAnalyze;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Get the mocked analyze function
+        const mockProvider = {
+            name: 'mock-provider',
+            analyze: jest.fn(),
+        };
+        mockAnalyze = mockProvider.analyze;
+        createLlmProvider.mockReturnValue(mockProvider);
+        generator = new AIRuleGenerator('test-api-key', 'gpt-4o-mini');
+    });
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    describe('constructor', () => {
+        it('creates an instance successfully when provider is returned', () => {
+            expect(generator).toBeInstanceOf(AIRuleGenerator);
+        });
+        it('throws when createLlmProvider returns null', () => {
+            createLlmProvider.mockReturnValueOnce(null);
+            expect(() => new AIRuleGenerator('key')).toThrow('Failed to create LLM provider');
+        });
+        it('uses default model when not specified', () => {
+            expect(() => new AIRuleGenerator('key')).not.toThrow();
+        });
+        it('accepts custom model parameter', () => {
+            expect(() => new AIRuleGenerator('key', 'gpt-3.5-turbo')).not.toThrow();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // generateFromThreatIntel
+    // -------------------------------------------------------------------------
+    describe('generateFromThreatIntel', () => {
+        it('returns empty array for empty reports', async () => {
+            const rules = await generator.generateFromThreatIntel([]);
+            expect(rules).toEqual([]);
+        });
+        it('generates rules from a threat report', async () => {
+            const ruleResponse = JSON.stringify({
+                rules: [
+                    {
+                        id: 'INJ-001',
+                        name: 'Prompt Injection Detection',
+                        category: 'injection',
+                        severity: 'HIGH',
+                        description: 'Detects prompt injection patterns',
+                        patterns: ['IGNORE PREVIOUS', 'jailbreak'],
+                        fileTypes: ['md', 'json'],
+                        components: ['agent', 'skill'],
+                        remediation: 'Validate all user input',
+                        confidence: 0.85,
+                    },
+                ],
+            });
+            mockAnalyze.mockResolvedValue(ruleResponse);
+            const rules = await generator.generateFromThreatIntel([makeThreatReport()]);
+            expect(rules).toHaveLength(1);
+            expect(rules[0]?.id).toBe('INJ-001');
+            expect(rules[0]?.name).toBe('Prompt Injection Detection');
+            expect(rules[0]?.generatedFrom).toBe('THREAT-001');
+            expect(rules[0]?.validated).toBe(false);
+            expect(rules[0]?.enabled).toBe(false);
+            expect(rules[0]?.confidence).toBe(0.85);
+        });
+        it('converts patterns strings to RegExp objects', async () => {
+            const ruleResponse = JSON.stringify({
+                rules: [
+                    {
+                        id: 'INJ-002',
+                        name: 'Test Rule',
+                        category: 'injection',
+                        severity: 'MEDIUM',
+                        description: 'Test',
+                        patterns: ['test.*pattern', '\\bmalicious\\b'],
+                        fileTypes: ['md'],
+                        components: ['agent'],
+                        remediation: 'Fix it',
+                        confidence: 0.7,
+                    },
+                ],
+            });
+            mockAnalyze.mockResolvedValue(ruleResponse);
+            const rules = await generator.generateFromThreatIntel([makeThreatReport()]);
+            expect(rules[0]?.patterns[0]).toBeInstanceOf(RegExp);
+            expect(rules[0]?.patterns[1]).toBeInstanceOf(RegExp);
+        });
+        it('uses default confidence of 0.7 when not provided', async () => {
+            const ruleResponse = JSON.stringify({
+                rules: [
+                    {
+                        id: 'INJ-003',
+                        name: 'No Confidence Rule',
+                        category: 'injection',
+                        severity: 'LOW',
+                        description: 'Test',
+                        patterns: ['test'],
+                        fileTypes: ['md'],
+                        components: [],
+                        remediation: 'Fix',
+                        // confidence omitted
+                    },
+                ],
+            });
+            mockAnalyze.mockResolvedValue(ruleResponse);
+            const rules = await generator.generateFromThreatIntel([makeThreatReport()]);
+            expect(rules[0]?.confidence).toBe(0.7);
+        });
+        it('processes multiple threat reports', async () => {
+            const ruleResponse1 = JSON.stringify({
+                rules: [{ id: 'R-001', name: 'Rule 1', category: 'injection', severity: 'HIGH',
+                        description: 'D', patterns: ['p1'], fileTypes: ['md'], components: [], remediation: 'fix', confidence: 0.8 }],
+            });
+            const ruleResponse2 = JSON.stringify({
+                rules: [{ id: 'R-002', name: 'Rule 2', category: 'credentials', severity: 'CRITICAL',
+                        description: 'D', patterns: ['p2'], fileTypes: ['json'], components: [], remediation: 'fix', confidence: 0.9 }],
+            });
+            mockAnalyze
+                .mockResolvedValueOnce(ruleResponse1)
+                .mockResolvedValueOnce(ruleResponse2);
+            const reports = [
+                makeThreatReport({ id: 'T-001' }),
+                makeThreatReport({ id: 'T-002', category: 'credentials' }),
+            ];
+            const rules = await generator.generateFromThreatIntel(reports);
+            expect(rules).toHaveLength(2);
+            expect(rules[0]?.generatedFrom).toBe('T-001');
+            expect(rules[1]?.generatedFrom).toBe('T-002');
+        });
+        it('skips reports that fail to generate and continues with others', async () => {
+            const successResponse = JSON.stringify({
+                rules: [
+                    {
+                        id: 'R-001', name: 'Good Rule', category: 'injection', severity: 'HIGH',
+                        description: 'D', patterns: ['p1'], fileTypes: ['md'], components: [], remediation: 'fix', confidence: 0.8,
+                    },
+                ],
+            });
+            mockAnalyze
+                .mockRejectedValueOnce(new Error('LLM error'))
+                .mockResolvedValueOnce(successResponse);
+            const reports = [
+                makeThreatReport({ id: 'FAIL-001' }),
+                makeThreatReport({ id: 'SUCCESS-001' }),
+            ];
+            const rules = await generator.generateFromThreatIntel(reports);
+            // Only the second report should produce rules
+            expect(rules).toHaveLength(1);
+            expect(rules[0]?.generatedFrom).toBe('SUCCESS-001');
+        });
+        it('generates rules with references as empty array', async () => {
+            const ruleResponse = JSON.stringify({
+                rules: [
+                    {
+                        id: 'R-001', name: 'Rule', category: 'injection', severity: 'HIGH',
+                        description: 'D', patterns: ['p'], fileTypes: ['md'], components: [], remediation: 'fix', confidence: 0.8,
+                    },
+                ],
+            });
+            mockAnalyze.mockResolvedValue(ruleResponse);
+            const rules = await generator.generateFromThreatIntel([makeThreatReport()]);
+            expect(rules[0]?.references).toEqual([]);
+        });
+        it('handles multiple rules returned from a single report', async () => {
+            const ruleResponse = JSON.stringify({
+                rules: [
+                    { id: 'R-001', name: 'Rule 1', category: 'injection', severity: 'HIGH',
+                        description: 'D', patterns: ['p1'], fileTypes: ['md'], components: [], remediation: 'fix', confidence: 0.8 },
+                    { id: 'R-002', name: 'Rule 2', category: 'injection', severity: 'MEDIUM',
+                        description: 'D', patterns: ['p2'], fileTypes: ['json'], components: [], remediation: 'fix', confidence: 0.75 },
+                    { id: 'R-003', name: 'Rule 3', category: 'injection', severity: 'LOW',
+                        description: 'D', patterns: ['p3'], fileTypes: ['yaml'], components: [], remediation: 'fix', confidence: 0.6 },
+                ],
+            });
+            mockAnalyze.mockResolvedValue(ruleResponse);
+            const rules = await generator.generateFromThreatIntel([makeThreatReport()]);
+            expect(rules).toHaveLength(3);
+        });
+    });
+});
+//# sourceMappingURL=RuleGenerator.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * ThreatFeed Tests
+ * Tests for threat intelligence database operations: load, save, add, remove, query.
+ */
+export {};
+//# sourceMappingURL=ThreatFeed.test.d.ts.map