@lov3kaizen/agentsea-redteam 0.5.1

package/dist/continuous.types-Btw2YvvR.d.ts

@@ -0,0 +1,588 @@
+import { c as Attack, S as Severity, e as AttackResult, f as AttackExecutionOptions, A as AttackCategory } from './attack.types-BK8Qc_Bl.js';
+import { d as BenchmarkResult } from './benchmark.types-COcarrIj.js';
+import { e as ComplianceCheckResult } from './compliance.types-CAnQxiA-.js';
+
+type TestStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+type TestResultOutcome = 'passed' | 'failed' | 'mixed' | 'error' | 'skipped';
+interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    attack: Attack;
+    preconditions?: string[];
+    expectedResult: 'blocked' | 'allowed' | 'detected' | 'mitigated';
+    failureSeverity: Severity;
+    tags: string[];
+    skip?: boolean;
+    skipReason?: string;
+    timeout?: number;
+}
+interface TestCaseResult {
+    testCase: TestCase;
+    attackResult: AttackResult;
+    passed: boolean;
+    status: TestStatus;
+    failureReason?: string;
+    durationMs: number;
+    timestamp: number;
+    retryCount: number;
+}
+interface TestSuiteConfig {
+    name: string;
+    description?: string;
+    testCases: TestCase[];
+    defaultOptions?: AttackExecutionOptions;
+    setup?: () => Promise<void>;
+    teardown?: () => Promise<void>;
+    beforeEach?: (testCase: TestCase) => Promise<void>;
+    afterEach?: (result: TestCaseResult) => Promise<void>;
+    parallel?: boolean;
+    maxParallel?: number;
+    failFast?: boolean;
+    filterTags?: string[];
+    skipTags?: string[];
+}
+interface TestSuiteResult {
+    id: string;
+    name: string;
+    outcome: TestResultOutcome;
+    status: TestStatus;
+    results: TestCaseResult[];
+    summary: TestSummary;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    error?: string;
+}
+interface TestSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    errors: number;
+    passRate: number;
+    bySeverity: {
+        critical: {
+            passed: number;
+            failed: number;
+        };
+        high: {
+            passed: number;
+            failed: number;
+        };
+        medium: {
+            passed: number;
+            failed: number;
+        };
+        low: {
+            passed: number;
+            failed: number;
+        };
+        informational: {
+            passed: number;
+            failed: number;
+        };
+    };
+}
+interface TestRunConfig {
+    runId?: string;
+    environment?: string;
+    target?: TargetInfo;
+    executionOptions?: AttackExecutionOptions;
+    outputFormat?: 'json' | 'junit' | 'html' | 'markdown';
+    outputPath?: string;
+    verbose?: boolean;
+    reporter?: TestReporter;
+}
+interface TargetInfo {
+    name: string;
+    type: 'agent' | 'api' | 'model' | 'endpoint' | 'custom';
+    version?: string;
+    endpoint?: string;
+    model?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TestReporter {
+    onSuiteStart?: (suite: TestSuiteConfig) => void;
+    onTestStart?: (testCase: TestCase) => void;
+    onTestComplete?: (result: TestCaseResult) => void;
+    onSuiteComplete?: (result: TestSuiteResult) => void;
+    onProgress?: (progress: TestProgress) => void;
+}
+interface TestProgress {
+    current: number;
+    total: number;
+    percentage: number;
+    currentTestName: string;
+    passed: number;
+    failed: number;
+    elapsedMs: number;
+    estimatedRemainingMs?: number;
+}
+interface TestAssertion {
+    type: 'contains' | 'notContains' | 'matches' | 'equals' | 'custom';
+    expected: string | RegExp;
+    actual?: string;
+    passed: boolean;
+    message?: string;
+}
+interface RetryPolicy {
+    maxRetries: number;
+    initialDelay: number;
+    backoffMultiplier: number;
+    maxDelay: number;
+    retryOn: ('error' | 'timeout' | 'rate_limit')[];
+}
+
+type ScanType = 'vulnerability' | 'prompt_analysis' | 'system_prompt_audit' | 'configuration_review' | 'comprehensive';
+type ScanStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+type VulnerabilityCategory = 'injection' | 'authentication' | 'authorization' | 'data_exposure' | 'misconfiguration' | 'insecure_design' | 'output_handling' | 'supply_chain' | 'model_theft' | 'custom';
+interface Vulnerability {
+    id: string;
+    name: string;
+    description: string;
+    category: VulnerabilityCategory;
+    severity: Severity;
+    cvssScore?: number;
+    cweId?: string;
+    owaspMapping?: string;
+    affectedComponent: string;
+    attackVector?: string;
+    exploitability: 'easy' | 'moderate' | 'difficult' | 'theoretical';
+    impact: string;
+    remediation: string;
+    references?: string[];
+    evidence?: VulnerabilityEvidence[];
+    firstDetected: number;
+    lastSeen: number;
+    status: 'open' | 'confirmed' | 'in_progress' | 'resolved' | 'accepted_risk' | 'false_positive';
+}
+interface VulnerabilityEvidence {
+    type: 'request' | 'response' | 'log' | 'screenshot' | 'test_result' | 'custom';
+    description: string;
+    content: string;
+    timestamp: number;
+}
+interface ScanConfig {
+    type: ScanType;
+    target: ScanTarget;
+    attackCategories?: AttackCategory[];
+    includeAttacks?: string[];
+    excludeAttacks?: string[];
+    minSeverity?: Severity;
+    maxDuration?: number;
+    parallel?: boolean;
+    maxParallel?: number;
+    stopOnFirstFinding?: boolean;
+    authentication?: ScanAuthentication;
+    rateLimit?: RateLimitConfig;
+    onProgress?: (progress: ScanProgress) => void;
+    onFinding?: (vulnerability: Vulnerability) => void;
+}
+interface ScanTarget {
+    type: 'agent' | 'endpoint' | 'model' | 'prompt' | 'system';
+    identifier: string;
+    name?: string;
+    model?: string;
+    systemPrompt?: string;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+interface ScanAuthentication {
+    type: 'api_key' | 'bearer' | 'basic' | 'oauth' | 'custom';
+    credentials: Record<string, string>;
+    headerName?: string;
+}
+interface RateLimitConfig {
+    requestsPerSecond: number;
+    burstSize?: number;
+    retryOnRateLimit?: boolean;
+    maxRetries?: number;
+}
+interface ScanResult {
+    id: string;
+    type: ScanType;
+    target: ScanTarget;
+    status: ScanStatus;
+    vulnerabilities: Vulnerability[];
+    summary: ScanSummary;
+    testResults?: TestSuiteResult;
+    metadata: ScanMetadata;
+    error?: string;
+}
+interface ScanSummary {
+    totalTests: number;
+    testsPassed: number;
+    testsFailed: number;
+    vulnerabilitiesFound: number;
+    bySeverity: Record<Severity, number>;
+    byCategory: Record<VulnerabilityCategory, number>;
+    riskScore: number;
+    riskLevel: 'critical' | 'high' | 'medium' | 'low' | 'minimal';
+}
+interface ScanMetadata {
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    scannerVersion: string;
+    configuration: Partial<ScanConfig>;
+    environment?: string;
+}
+interface ScanProgress {
+    scanId: string;
+    phase: 'initializing' | 'scanning' | 'analyzing' | 'reporting' | 'completed';
+    currentTest?: string;
+    testsCompleted: number;
+    totalTests: number;
+    percentage: number;
+    vulnerabilitiesFound: number;
+    elapsedMs: number;
+    estimatedRemainingMs?: number;
+}
+interface PromptAnalysisConfig {
+    prompt: string;
+    analysisTypes: PromptAnalysisType[];
+    checkInjections?: boolean;
+    checkSensitiveData?: boolean;
+    useLLM?: boolean;
+    model?: string;
+}
+type PromptAnalysisType = 'structure' | 'security' | 'quality' | 'effectiveness' | 'bias' | 'clarity' | 'completeness';
+interface PromptAnalysisResult {
+    prompt: string;
+    overallScore: number;
+    analyses: Record<PromptAnalysisType, PromptTypeAnalysis>;
+    issues: PromptIssue[];
+    suggestions: PromptSuggestion[];
+    securityAssessment?: PromptSecurityAssessment;
+    processingTimeMs: number;
+}
+interface PromptTypeAnalysis {
+    score: number;
+    findings: string[];
+    strengths?: string[];
+    weaknesses?: string[];
+}
+interface PromptIssue {
+    type: 'security' | 'quality' | 'clarity' | 'bias' | 'effectiveness';
+    severity: Severity;
+    description: string;
+    location?: {
+        start: number;
+        end: number;
+    };
+    recommendation: string;
+}
+interface PromptSuggestion {
+    type: 'improvement' | 'alternative' | 'addition' | 'removal';
+    description: string;
+    currentText?: string;
+    suggestedText?: string;
+    expectedImprovement: string;
+    priority: 'high' | 'medium' | 'low';
+}
+interface PromptSecurityAssessment {
+    securityScore: number;
+    injectionVulnerability: number;
+    dataLeakageRisk: number;
+    jailbreakSusceptibility: number;
+    detectedPatterns: SecurityPattern[];
+    recommendations: string[];
+}
+interface SecurityPattern {
+    name: string;
+    risk: Severity;
+    description: string;
+    location?: {
+        start: number;
+        end: number;
+    };
+}
+interface SystemPromptAuditConfig {
+    systemPrompt: string;
+    categories: SystemPromptAuditCategory[];
+    compareBestPractices?: boolean;
+    testVulnerabilities?: boolean;
+    generateImproved?: boolean;
+}
+type SystemPromptAuditCategory = 'security' | 'clarity' | 'boundaries' | 'consistency' | 'completeness' | 'safety' | 'instruction_hierarchy';
+interface SystemPromptAuditResult {
+    systemPrompt: string;
+    overallScore: number;
+    categoryScores: Record<SystemPromptAuditCategory, number>;
+    issues: SystemPromptIssue[];
+    vulnerabilities: Vulnerability[];
+    bestPracticeViolations?: BestPracticeViolation[];
+    improvedVersion?: string;
+    improvementExplanation?: string;
+}
+interface SystemPromptIssue {
+    category: SystemPromptAuditCategory;
+    severity: Severity;
+    description: string;
+    location?: {
+        start: number;
+        end: number;
+    };
+    suggestion: string;
+}
+interface BestPracticeViolation {
+    practice: string;
+    description: string;
+    impact: string;
+    recommendation: string;
+    reference?: string;
+}
+
+type ScheduleFrequency = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'on_deploy' | 'on_change' | 'custom';
+type RunStatus = 'scheduled' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped';
+type AlertSeverity = 'critical' | 'warning' | 'info';
+interface ContinuousTestingConfig {
+    enabled: boolean;
+    testSuites: string[];
+    scans?: string[];
+    benchmarks?: string[];
+    complianceChecks?: string[];
+    schedule: ScheduleConfig;
+    triggers?: TriggerConfig[];
+    alerts: AlertConfig;
+    retention?: RetentionConfig;
+    parallel?: boolean;
+    maxParallel?: number;
+    failThreshold?: FailThreshold;
+}
+interface ScheduleConfig {
+    frequency: ScheduleFrequency;
+    cronExpression?: string;
+    timeOfDay?: string;
+    daysOfWeek?: number[];
+    dayOfMonth?: number;
+    timezone?: string;
+    skipIfRunning?: boolean;
+    maxDuration?: number;
+}
+interface TriggerConfig {
+    type: 'webhook' | 'git_push' | 'pr_merge' | 'deployment' | 'schedule' | 'manual' | 'api';
+    name: string;
+    enabled: boolean;
+    conditions?: TriggerCondition[];
+    webhookUrl?: string;
+    webhookSecret?: string;
+    branchFilter?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface TriggerCondition {
+    field: string;
+    operator: 'equals' | 'not_equals' | 'contains' | 'matches' | 'greater' | 'less';
+    value: string | number | boolean;
+}
+interface AlertConfig {
+    enabled: boolean;
+    channels: AlertChannel[];
+    rules: AlertRule[];
+    quietHours?: QuietHours;
+    grouping?: AlertGrouping;
+    escalation?: EscalationPolicy;
+}
+interface AlertChannel {
+    id: string;
+    type: 'email' | 'slack' | 'webhook' | 'pagerduty' | 'teams' | 'discord' | 'custom';
+    name: string;
+    enabled: boolean;
+    config: AlertChannelConfig;
+    severities: AlertSeverity[];
+}
+interface AlertChannelConfig {
+    emails?: string[];
+    webhookUrl?: string;
+    slackChannel?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    template?: string;
+    settings?: Record<string, unknown>;
+}
+interface AlertRule {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    condition: AlertCondition;
+    severity: AlertSeverity;
+    channelIds: string[];
+    throttleMs?: number;
+    autoResolve?: boolean;
+    tags?: string[];
+}
+interface AlertCondition {
+    type: 'threshold' | 'change' | 'pattern' | 'anomaly' | 'custom';
+    metric: string;
+    operator: 'greater' | 'less' | 'equals' | 'not_equals' | 'between' | 'outside';
+    value: number | number[];
+    windowMs?: number;
+    consecutiveCount?: number;
+    customEvaluator?: string;
+}
+interface QuietHours {
+    enabled: boolean;
+    startTime: string;
+    endTime: string;
+    daysOfWeek: number[];
+    timezone?: string;
+    overrideForCritical?: boolean;
+}
+interface AlertGrouping {
+    enabled: boolean;
+    groupBy: string[];
+    windowMs: number;
+    maxAlertsPerGroup?: number;
+}
+interface EscalationPolicy {
+    enabled: boolean;
+    levels: EscalationLevel[];
+}
+interface EscalationLevel {
+    level: number;
+    delayMs: number;
+    channelIds: string[];
+    repeatIntervalMs?: number;
+    maxRepeats?: number;
+}
+interface RetentionConfig {
+    retentionDays: number;
+    summaryRetentionDays?: number;
+    archive?: boolean;
+    archiveLocation?: string;
+}
+interface FailThreshold {
+    maxCritical?: number;
+    maxHigh?: number;
+    minPassRate?: number;
+    minComplianceScore?: number;
+    minBenchmarkScore?: number;
+}
+interface TestRun {
+    id: string;
+    name?: string;
+    status: RunStatus;
+    trigger: TriggerConfig['type'];
+    triggeredBy?: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    testResults?: TestSuiteResult[];
+    scanResults?: ScanResult[];
+    benchmarkResults?: BenchmarkResult[];
+    complianceResults?: ComplianceCheckResult[];
+    summary?: RunSummary;
+    alerts?: Alert[];
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface RunSummary {
+    overallStatus: 'passed' | 'failed' | 'warning' | 'error';
+    tests?: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+    vulnerabilities?: {
+        total: number;
+        bySeverity: Record<Severity, number>;
+    };
+    benchmarks?: {
+        averageScore: number;
+        passed: number;
+        failed: number;
+    };
+    compliance?: {
+        averageScore: number;
+        compliant: number;
+        nonCompliant: number;
+    };
+    comparison?: {
+        testsDelta: number;
+        vulnerabilitiesDelta: number;
+        benchmarkDelta: number;
+        complianceDelta: number;
+        trend: 'improved' | 'degraded' | 'stable';
+    };
+}
+interface Alert {
+    id: string;
+    ruleId: string;
+    ruleName: string;
+    severity: AlertSeverity;
+    status: 'triggered' | 'acknowledged' | 'resolved' | 'suppressed';
+    title: string;
+    message: string;
+    details?: Record<string, unknown>;
+    triggeredAt: number;
+    acknowledgedAt?: number;
+    acknowledgedBy?: string;
+    resolvedAt?: number;
+    resolvedBy?: string;
+    resolutionNotes?: string;
+    runId?: string;
+    notificationHistory: NotificationRecord[];
+}
+interface NotificationRecord {
+    channelId: string;
+    channelType: AlertChannel['type'];
+    sentAt: number;
+    status: 'sent' | 'failed' | 'bounced';
+    error?: string;
+}
+interface ScheduleStatus {
+    nextRun?: number;
+    lastRun?: TestRun;
+    isRunning: boolean;
+    currentRunId?: string;
+    runsToday: number;
+    activeAlerts: number;
+}
+interface HistoricalMetrics {
+    timeRange: {
+        start: number;
+        end: number;
+    };
+    dataPoints: MetricDataPoint[];
+    aggregations: {
+        mean: number;
+        median: number;
+        min: number;
+        max: number;
+        stdDev: number;
+    };
+    trends: {
+        direction: 'up' | 'down' | 'stable';
+        changePercent: number;
+        significance: 'high' | 'medium' | 'low';
+    };
+}
+interface MetricDataPoint {
+    timestamp: number;
+    value: number;
+    runId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DashboardSummary {
+    currentStatus: 'healthy' | 'warning' | 'critical' | 'unknown';
+    lastRun?: TestRun;
+    nextRun?: number;
+    activeAlerts: Alert[];
+    recentRuns: TestRun[];
+    metrics: {
+        passRate: HistoricalMetrics;
+        vulnerabilities: HistoricalMetrics;
+        benchmarkScores: HistoricalMetrics;
+        complianceScores: HistoricalMetrics;
+    };
+    trends: {
+        overall: 'improving' | 'stable' | 'degrading';
+        security: 'improving' | 'stable' | 'degrading';
+        compliance: 'improving' | 'stable' | 'degrading';
+    };
+}
+
+export type { EscalationPolicy as $, PromptSuggestion as A, PromptSecurityAssessment as B, SecurityPattern as C, SystemPromptAuditConfig as D, SystemPromptAuditCategory as E, SystemPromptAuditResult as F, SystemPromptIssue as G, BestPracticeViolation as H, ScheduleFrequency as I, RunStatus as J, AlertSeverity as K, ContinuousTestingConfig as L, ScheduleConfig as M, TriggerConfig as N, TriggerCondition as O, PromptAnalysisConfig as P, AlertConfig as Q, RetryPolicy as R, ScanType as S, TestStatus as T, AlertChannel as U, VulnerabilityCategory as V, AlertChannelConfig as W, AlertRule as X, AlertCondition as Y, QuietHours as Z, AlertGrouping as _, TestResultOutcome as a, EscalationLevel as a0, RetentionConfig as a1, FailThreshold as a2, TestRun as a3, RunSummary as a4, Alert as a5, NotificationRecord as a6, ScheduleStatus as a7, HistoricalMetrics as a8, MetricDataPoint as a9, DashboardSummary as aa, TestCase as b, TestCaseResult as c, TestSuiteConfig as d, TestSuiteResult as e, TestSummary as f, TestRunConfig as g, TargetInfo as h, TestReporter as i, TestProgress as j, TestAssertion as k, ScanStatus as l, Vulnerability as m, VulnerabilityEvidence as n, ScanConfig as o, ScanTarget as p, ScanAuthentication as q, RateLimitConfig as r, ScanResult as s, ScanSummary as t, ScanMetadata as u, ScanProgress as v, PromptAnalysisType as w, PromptAnalysisResult as x, PromptTypeAnalysis as y, PromptIssue as z };