@dawans/promptshield
Version:
Secure your LLM stack with enterprise-grade RulePacks for AI safety scanning
266 lines (265 loc) • 13.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.setupContainer = setupContainer;
const ConfigManager_1 = require("../infrastructure/config/ConfigManager");
const Logger_1 = require("../infrastructure/logging/Logger");
// Domain implementations
const LocalFileReader_1 = require("../domains/scanning/adapters/LocalFileReader");
const JsonProcessor_1 = require("../domains/scanning/adapters/processors/JsonProcessor");
const TextProcessor_1 = require("../domains/scanning/adapters/processors/TextProcessor");
const ScanOrchestrator_1 = require("../domains/scanning/core/services/ScanOrchestrator");
const YamlRuleRepository_1 = require("../domains/rules/adapters/YamlRuleRepository");
const RuleEngineImpl_1 = require("../domains/rules/core/services/RuleEngineImpl");
const JsonRenderer_1 = require("../domains/reporting/adapters/renderers/JsonRenderer");
const MarkdownRenderer_1 = require("../domains/reporting/adapters/renderers/MarkdownRenderer");
const CsvRenderer_1 = require("../domains/reporting/adapters/renderers/CsvRenderer");
const HtmlRenderer_1 = require("../domains/reporting/adapters/renderers/HtmlRenderer");
const TableRenderer_1 = require("../domains/reporting/adapters/renderers/TableRenderer");
const NdjsonRenderer_1 = require("../domains/reporting/adapters/renderers/NdjsonRenderer");
const ReportServiceImpl_1 = require("../domains/reporting/core/services/ReportServiceImpl");
// Validation domain
const ValidationEngineImpl_1 = require("../domains/validation/core/services/ValidationEngineImpl");
const RulePackValidatorImpl_1 = require("../domains/validation/adapters/validators/RulePackValidatorImpl");
const InputFileValidatorImpl_1 = require("../domains/validation/adapters/validators/InputFileValidatorImpl");
// Application handlers
const ScanCommandHandler_1 = require("../application/commands/scan/ScanCommandHandler");
const ValidateCommandHandler_1 = require("../application/commands/validate/ValidateCommandHandler");
const RulePack_1 = require("../domains/rules/core/entities/RulePack");
const Rule_1 = require("../domains/rules/core/entities/Rule");
/**
* Sets up the dependency injection container
*/
function setupContainer(container) {
// Infrastructure
container.register('configManager', ConfigManager_1.ConfigManager.getInstance());
container.register('logger', Logger_1.LoggerFactory.create({
level: process.env.LOG_LEVEL || 'INFO',
options: {
includeTimestamp: true,
includeStackTrace: process.env.NODE_ENV === 'development',
},
}));
// Load configuration from environment
const configManager = container.resolve('configManager');
configManager.loadFromEnvironment();
// File system
container.register('fileReader', new LocalFileReader_1.LocalFileReader());
// Content processors
const processors = new Map();
processors.set('json', new JsonProcessor_1.JsonProcessor());
processors.set('text', new TextProcessor_1.TextProcessor());
container.register('contentProcessors', processors);
// Rule engine
container.registerFactory('ruleRepository', () => new YamlRuleRepository_1.YamlRuleRepository('rulepacks'), true);
container.registerFactory('ruleMatcher', () => new RuleEngineImpl_1.DefaultRuleMatcher(), true);
container.registerFactory('ruleEngine', () => new RuleEngineImpl_1.DefaultRuleEngine(container.resolve('ruleRepository'), container.resolve('ruleMatcher')), true);
// Scan engine
container.registerFactory('scanStrategy', () => ({
shouldUseStreaming: (size, threshold) => size > threshold * 1024 * 1024,
shouldUseParallelProcessing: (count, context) => context.config.parallel && count > context.getBatchSize(),
getOptimalBatchSize: (count, context) => Math.min(context.getBatchSize(), Math.ceil(count / 4)),
}), true);
container.registerFactory('metricsCollector', () => {
let startTime;
let objectCount = 0;
let memoryUsage = 0;
let streamingUsed = false;
return {
start: () => {
startTime = Date.now();
objectCount = 0;
memoryUsage = process.memoryUsage().heapUsed;
streamingUsed = false;
},
recordProcessing: (items, memory) => {
objectCount = items;
memoryUsage = Math.max(memoryUsage, memory);
},
setStreamingUsed: (used) => {
streamingUsed = used;
},
end: () => ({
objectsScanned: objectCount,
processingTime: Date.now() - startTime,
memoryUsage: memoryUsage,
rulesApplied: 0,
streamingUsed: streamingUsed,
}),
};
});
container.registerFactory('scanEngine', () => new ScanOrchestrator_1.DefaultScanOrchestrator(container.resolve('fileReader'), container.resolve('contentProcessors'), container.resolve('ruleEngine'), container.resolve('scanStrategy'), container.resolve('metricsCollector')), true);
// Report renderers
const renderers = new Map();
renderers.set('json', new JsonRenderer_1.JsonRenderer());
renderers.set('markdown', new MarkdownRenderer_1.MarkdownRenderer());
renderers.set('csv', new CsvRenderer_1.CsvRenderer());
renderers.set('html', new HtmlRenderer_1.HtmlRenderer());
renderers.set('table', new TableRenderer_1.TableRenderer());
renderers.set('ndjson', new NdjsonRenderer_1.NdjsonRenderer());
container.register('renderers', renderers);
// Report service
container.registerFactory('reportService', () => new ReportServiceImpl_1.ReportServiceImpl(renderers), true);
// Validation engine
container.registerFactory('validationEngine', () => {
const validationEngine = new ValidationEngineImpl_1.DefaultValidationEngine();
// Register validators
validationEngine.registerValidator('rulepack', new RulePackValidatorImpl_1.RulePackValidatorImpl());
validationEngine.registerValidator('input-file', new InputFileValidatorImpl_1.InputFileValidatorImpl());
return validationEngine;
}, true);
// Command handlers
container.registerFactory('scanCommandHandler', () => new ScanCommandHandler_1.ScanCommandHandler(container.resolve('scanEngine'), container.resolve('reportService'), container.resolve('logger')), true);
container.registerFactory('validateCommandHandler', () => new ValidateCommandHandler_1.ValidateCommandHandler(container.resolve('validationEngine'), container.resolve('logger')), true);
// List command handler
container.registerFactory('listCommandHandler', () => ({
execute: async (command) => {
const ruleEngine = container.resolve('ruleEngine');
const repository = container.resolve('ruleRepository');
try {
let rulepacks;
if (command.options.rulepack) {
const result = await ruleEngine.loadRulePack(command.options.rulepack);
if (result.isErr())
return result;
rulepacks = [result.value];
}
else {
const availableResult = await repository.listAvailable();
if (availableResult.isErr())
return availableResult;
const loadResults = await Promise.all(availableResult.value.map((path) => ruleEngine.loadRulePack(path)));
rulepacks = loadResults.filter((r) => r.isOk()).map((r) => r.value);
}
// Display rulepacks and rules
for (const rulepack of rulepacks) {
console.log(`\nRulePack: ${rulepack.name}`);
console.log(`Description: ${rulepack.description}`);
console.log(`Version: ${rulepack.version}`);
console.log(`Rules: ${rulepack.rules.length}\n`);
let rules = rulepack.rules;
// Apply filters
if (command.options.category) {
rules = rules.filter((r) => r.category === command.options.category);
}
if (command.options.severity) {
rules = rules.filter((r) => r.severity === command.options.severity);
}
if (command.options.enabledOnly) {
rules = rules.filter((r) => r.enabled);
}
for (const rule of rules) {
console.log(` - ${rule.id}: ${rule.description}`);
console.log(` Severity: ${rule.severity}, Category: ${rule.category}, Enabled: ${rule.enabled}`);
}
}
return { isOk: () => true, isErr: () => false };
}
catch (error) {
return { isErr: () => true, error };
}
},
}), true);
// Init command handler
container.registerFactory('initCommandHandler', () => ({
execute: async (command) => {
const repository = container.resolve('ruleRepository');
const templates = container.resolve('ruleTemplates');
try {
const template = templates.get(command.options.template || 'basic');
if (!template) {
return {
isErr: () => true,
error: new Error(`Unknown template: ${command.options.template}`),
};
}
// Create Rule instances from template
const rules = template.rules.map((ruleData) => new Rule_1.Rule(ruleData.id, ruleData.description, ruleData.match_regex || [], ruleData.match_keywords || [], ruleData.severity, ruleData.category, ruleData.enabled, false // case_sensitive default
));
// Create RulePack instance
const rulePack = new RulePack_1.RulePack(command.options.name || template.name, command.options.description || template.description, rules, template.version, new Date());
const result = await repository.saveToYaml(command.filename, rulePack);
if (result.isOk() && !command.options.quiet) {
console.log(`Created RulePack: ${command.filename}`);
if (command.options.verbose) {
console.log(`Template: ${command.options.template || 'basic'}`);
console.log(`Rules: ${rulePack.rules.length}`);
}
}
return result;
}
catch (error) {
return { isErr: () => true, error };
}
},
}), true);
// Rule templates
container.register('ruleTemplates', createRuleTemplates());
}
/**
* Creates rule templates
*/
function createRuleTemplates() {
const templates = new Map();
// Basic template
templates.set('basic', {
version: '1.0.0',
name: 'Basic RulePack',
description: 'Basic example rules for getting started',
rules: [
{
id: 'example_keyword',
description: 'Example keyword detection',
match_keywords: ['example', 'test'],
severity: 'low',
category: 'custom',
enabled: true,
},
{
id: 'example_regex',
description: 'Example regex pattern',
match_regex: ['\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'],
severity: 'medium',
category: 'custom',
enabled: true,
},
],
});
// PII template
templates.set('pii', {
version: '1.0.0',
name: 'PII Detection',
description: 'Detects personally identifiable information',
rules: [
{
id: 'email_addresses',
description: 'Detects email addresses',
match_regex: ['\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'],
severity: 'medium',
category: 'pii',
enabled: true,
},
{
id: 'phone_numbers',
description: 'Detects phone numbers',
match_regex: [
'\\b\\d{3}-\\d{3}-\\d{4}\\b',
'\\(\\d{3}\\)\\s?\\d{3}-\\d{4}',
'\\b\\d{10}\\b',
],
severity: 'medium',
category: 'pii',
enabled: true,
},
{
id: 'ssn',
description: 'Detects Social Security Numbers',
match_regex: ['\\b\\d{3}-\\d{2}-\\d{4}\\b'],
severity: 'high',
category: 'pii',
enabled: true,
},
],
});
// Add other templates (security, bias, compliance)...
return templates;
}