aura-security 0.4.0

package/dist/slop/server.js

@@ -0,0 +1,343 @@
+// SLOP Server - Minimal implementation for auditor pipeline
+// Exposes /tools, /memory, /info, /settings, /audits, /stats endpoints
+import { createServer } from 'http';
+import { getDatabase } from '../database/index.js';
+import { NotificationService, createNotificationFromAudit } from '../integrations/notifications.js';
+export class SlopServer {
+    server = null;
+    tools = new Map();
+    memory = new Map();
+    config;
+    db;
+    notificationService;
+    constructor(config) {
+        this.config = {
+            port: config.port,
+            host: config.host ?? '127.0.0.1',
+            dbPath: config.dbPath ?? process.cwd()
+        };
+        // Initialize database
+        this.db = getDatabase(this.config.dbPath);
+        // Initialize notification service
+        this.notificationService = new NotificationService({}, this.config.dbPath);
+        this.notificationService.loadFromDatabase();
+    }
+    getNotificationService() {
+        return this.notificationService;
+    }
+    reloadNotifications() {
+        this.notificationService.loadFromDatabase();
+    }
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    getDatabase() {
+        return this.db;
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
+        const path = url.pathname;
+        // CORS headers for visualizer access
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        res.setHeader('Content-Type', 'application/json');
+        // Handle preflight
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
+        try {
+            // Core SLOP endpoints
+            if (path === '/info' && req.method === 'GET') {
+                await this.handleInfo(res);
+            }
+            else if (path === '/tools' && req.method === 'GET') {
+                await this.handleListTools(res);
+            }
+            else if (path === '/tools' && req.method === 'POST') {
+                await this.handleCallTool(req, res);
+            }
+            else if (path === '/memory' && req.method === 'POST') {
+                await this.handleMemoryWrite(req, res);
+            }
+            else if (path === '/memory' && req.method === 'GET') {
+                await this.handleMemoryRead(url, res);
+            }
+            // Settings endpoints
+            else if (path === '/settings' && req.method === 'GET') {
+                await this.handleGetSettings(url, res);
+            }
+            else if (path === '/settings' && req.method === 'POST') {
+                await this.handleSaveSettings(req, res);
+            }
+            // Audit history endpoints
+            else if (path === '/audits' && req.method === 'GET') {
+                await this.handleGetAudits(url, res);
+            }
+            else if (path.startsWith('/audits/') && req.method === 'GET') {
+                const id = path.slice(8);
+                await this.handleGetAudit(id, res);
+            }
+            else if (path.startsWith('/audits/') && req.method === 'DELETE') {
+                const id = path.slice(8);
+                await this.handleDeleteAudit(id, res);
+            }
+            // Stats endpoint
+            else if (path === '/stats' && req.method === 'GET') {
+                await this.handleGetStats(res);
+            }
+            // Notifications endpoints
+            else if (path === '/notifications' && req.method === 'GET') {
+                await this.handleGetNotifications(url, res);
+            }
+            else if (path === '/notifications/test' && req.method === 'POST') {
+                await this.handleTestNotification(req, res);
+            }
+            else if (path === '/notifications/send' && req.method === 'POST') {
+                await this.handleSendNotification(req, res);
+            }
+            else {
+                res.statusCode = 404;
+                res.end(JSON.stringify({ error: 'Not found' }));
+            }
+        }
+        catch (err) {
+            console.error('[SERVER] Error:', err);
+            // Fail-closed: return 500 on any error
+            res.statusCode = 500;
+            res.end(JSON.stringify({
+                error: 'Internal server error',
+                message: err instanceof Error ? err.message : 'Unknown error',
+                blocked: true
+            }));
+        }
+    }
+    async handleInfo(res) {
+        res.statusCode = 200;
+        res.end(JSON.stringify({
+            name: 'slop-auditor',
+            version: '0.2.0',
+            endpoints: ['/info', '/tools', '/memory', '/settings', '/audits', '/stats', '/notifications'],
+            tools: Array.from(this.tools.keys()),
+            database: true
+        }));
+    }
+    async handleListTools(res) {
+        const toolList = Array.from(this.tools.values()).map(t => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+        }));
+        res.statusCode = 200;
+        res.end(JSON.stringify({ tools: toolList }));
+    }
+    async handleCallTool(req, res) {
+        const body = await this.readBody(req);
+        const { tool, arguments: args } = JSON.parse(body);
+        const toolDef = this.tools.get(tool);
+        if (!toolDef) {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: `Tool not found: ${tool}` }));
+            return;
+        }
+        const result = await toolDef.handler(args ?? {});
+        res.statusCode = 200;
+        res.end(JSON.stringify({ result }));
+    }
+    async handleMemoryWrite(req, res) {
+        const body = await this.readBody(req);
+        const { key, value, metadata } = JSON.parse(body);
+        this.memory.set(key, { value, metadata, timestamp: new Date().toISOString() });
+        res.statusCode = 201;
+        res.end(JSON.stringify({ status: 'stored', key }));
+    }
+    async handleMemoryRead(url, res) {
+        const key = url.searchParams.get('key');
+        if (key) {
+            const entry = this.memory.get(key);
+            if (entry) {
+                res.statusCode = 200;
+                res.end(JSON.stringify(entry));
+            }
+            else {
+                res.statusCode = 404;
+                res.end(JSON.stringify({ error: 'Key not found' }));
+            }
+        }
+        else {
+            res.statusCode = 200;
+            res.end(JSON.stringify({ keys: Array.from(this.memory.keys()) }));
+        }
+    }
+    // ============ SETTINGS ENDPOINTS ============
+    async handleGetSettings(url, res) {
+        const prefix = url.searchParams.get('prefix');
+        let settings;
+        if (prefix) {
+            settings = this.db.getSettings(prefix);
+        }
+        else {
+            settings = this.db.getAllSettings();
+        }
+        res.statusCode = 200;
+        res.end(JSON.stringify({ settings }));
+    }
+    async handleSaveSettings(req, res) {
+        const body = await this.readBody(req);
+        const { settings } = JSON.parse(body);
+        if (!settings || typeof settings !== 'object') {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ error: 'Invalid settings object' }));
+            return;
+        }
+        this.db.setSettings(settings);
+        res.statusCode = 200;
+        res.end(JSON.stringify({ status: 'saved', count: Object.keys(settings).length }));
+    }
+    // ============ AUDIT HISTORY ENDPOINTS ============
+    async handleGetAudits(url, res) {
+        const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+        const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+        const type = url.searchParams.get('type') || undefined;
+        const audits = this.db.getAudits(limit, offset, type);
+        const total = this.db.getAuditCount(type);
+        // Return without full data for list view (lighter response)
+        const auditList = audits.map(a => ({
+            id: a.id,
+            type: a.type,
+            timestamp: a.timestamp,
+            target: a.target,
+            summary: a.summary
+        }));
+        res.statusCode = 200;
+        res.end(JSON.stringify({ audits: auditList, total, limit, offset }));
+    }
+    async handleGetAudit(id, res) {
+        const audit = this.db.getAudit(id);
+        if (!audit) {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: 'Audit not found' }));
+            return;
+        }
+        // Parse the stored JSON data
+        let data;
+        try {
+            data = JSON.parse(audit.data);
+        }
+        catch {
+            data = audit.data;
+        }
+        res.statusCode = 200;
+        res.end(JSON.stringify({
+            id: audit.id,
+            type: audit.type,
+            timestamp: audit.timestamp,
+            target: audit.target,
+            summary: audit.summary,
+            data
+        }));
+    }
+    async handleDeleteAudit(id, res) {
+        const deleted = this.db.deleteAudit(id);
+        if (!deleted) {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: 'Audit not found' }));
+            return;
+        }
+        res.statusCode = 200;
+        res.end(JSON.stringify({ status: 'deleted', id }));
+    }
+    // ============ STATS ENDPOINT ============
+    async handleGetStats(res) {
+        const stats = this.db.getStats();
+        res.statusCode = 200;
+        res.end(JSON.stringify(stats));
+    }
+    // ============ NOTIFICATIONS ENDPOINT ============
+    async handleGetNotifications(url, res) {
+        const auditId = url.searchParams.get('audit_id') || undefined;
+        const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+        const notifications = this.db.getNotifications(auditId, limit);
+        res.statusCode = 200;
+        res.end(JSON.stringify({ notifications }));
+    }
+    async handleTestNotification(req, res) {
+        const body = await this.readBody(req);
+        const { channel } = JSON.parse(body);
+        if (!channel || !['slack', 'discord', 'webhook'].includes(channel)) {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ error: 'Invalid channel. Must be: slack, discord, or webhook' }));
+            return;
+        }
+        // Reload settings before testing
+        this.notificationService.loadFromDatabase();
+        const result = await this.notificationService.testChannel(channel);
+        res.statusCode = result.success ? 200 : 400;
+        res.end(JSON.stringify(result));
+    }
+    async handleSendNotification(req, res) {
+        const body = await this.readBody(req);
+        const { auditId, title, message, severity } = JSON.parse(body);
+        // If auditId provided, create notification from audit data
+        let payload;
+        if (auditId) {
+            const audit = this.db.getAudit(auditId);
+            if (!audit) {
+                res.statusCode = 404;
+                res.end(JSON.stringify({ error: 'Audit not found' }));
+                return;
+            }
+            payload = createNotificationFromAudit(audit.id, audit.type, audit.target, audit.summary);
+        }
+        else {
+            // Manual notification
+            payload = {
+                title: title || 'Manual Notification',
+                message: message || 'Test notification from SLOP Auditor',
+                severity: severity || 'low'
+            };
+        }
+        // Reload settings and send
+        this.notificationService.loadFromDatabase();
+        const result = await this.notificationService.notify(payload);
+        res.statusCode = 200;
+        res.end(JSON.stringify(result));
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', chunk => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => {
+                this.handleRequest(req, res).catch(() => {
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: 'Internal error', blocked: true }));
+                });
+            });
+            this.server.on('error', reject);
+            this.server.listen(this.config.port, this.config.host, () => {
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getMemorySnapshot() {
+        return new Map(this.memory);
+    }
+}

package/dist/types/events.d.ts

@@ -0,0 +1,62 @@
+export type ChangeEventType = 'pull_request' | 'deploy' | 'infra_change';
+export type Environment = 'dev' | 'staging' | 'prod';
+export type RiskTolerance = 'low' | 'medium' | 'high';
+export type Severity = 'low' | 'medium' | 'high' | 'critical';
+export type AgentState = 'idle' | 'analyzing' | 'conflict' | 'escalated' | 'blocked';
+export type EventType = 'analysis_started' | 'finding_raised' | 'conflict_detected' | 'escalation_triggered';
+export type EvidenceType = 'diff' | 'sbom' | 'scan' | 'provenance' | 'runtime';
+export type AssuranceBreak = 'integrity' | 'access_control' | 'isolation' | 'auditability';
+export interface ChangeEvent {
+    id: string;
+    type: ChangeEventType;
+    environment: Environment;
+    repo: string;
+    commit: string;
+    files_changed: string[];
+    diff: string;
+}
+export interface EvidenceBundle {
+    sbom?: string;
+    vuln_scan?: string;
+    sast_results?: string;
+    iac_scan?: string;
+    provenance?: string;
+    runtime_delta?: string;
+}
+export interface PolicyContext {
+    critical_assets: string[];
+    risk_tolerance: RiskTolerance;
+}
+export interface AuditorInput {
+    change_event: ChangeEvent;
+    evidence_bundle: EvidenceBundle;
+    policy_context: PolicyContext;
+}
+export interface EvidenceRef {
+    type: EvidenceType;
+    pointer: string;
+}
+export interface FindingPayload {
+    severity: Severity;
+    claim: string;
+    attack_path: string[];
+    affected_assets: string[];
+    evidence_refs: EvidenceRef[];
+    assurance_break: AssuranceBreak[];
+    confidence: number;
+}
+export interface AuditEvent {
+    event_type: EventType;
+    target: string;
+    payload: FindingPayload;
+    timestamp: string;
+}
+export interface AuditorOutput {
+    agent_id: string;
+    agent_state: AgentState;
+    events: AuditEvent[];
+    meta: {
+        assumptions: string[];
+        uncertainties: string[];
+    };
+}

package/dist/types/events.js

@@ -0,0 +1,2 @@
+// Aura Event Types - Strict schema definitions
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './events.js';

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from './events.js';

package/dist/visualizer/index.d.ts

@@ -0,0 +1,4 @@
+import type { AuditorOutput, AgentState } from '../types/events.js';
+export declare function visualize(output: AuditorOutput): string;
+export declare function visualizeState(state: AgentState): string;
+export declare function visualizeCompact(output: AuditorOutput): string;

package/dist/visualizer/index.js

@@ -0,0 +1,181 @@
+// Aura Visualizer - Renders audit findings to console/terminal
+// Auracraft-style visualization
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m'
+};
+const SEVERITY_COLORS = {
+    critical: COLORS.bgRed + COLORS.white,
+    high: COLORS.red,
+    medium: COLORS.yellow,
+    low: COLORS.green
+};
+const STATE_ICONS = {
+    idle: '○',
+    analyzing: '◐',
+    conflict: '⚡',
+    escalated: '▲',
+    blocked: '■'
+};
+const STATE_COLORS = {
+    idle: COLORS.dim,
+    analyzing: COLORS.cyan,
+    conflict: COLORS.yellow,
+    escalated: COLORS.magenta,
+    blocked: COLORS.red
+};
+export function visualize(output) {
+    const lines = [];
+    // Header
+    lines.push('');
+    lines.push(`${COLORS.bright}╔══════════════════════════════════════════════════════════════╗${COLORS.reset}`);
+    lines.push(`${COLORS.bright}║           AURASECURITY - SECURITY ANALYSIS REPORT            ║${COLORS.reset}`);
+    lines.push(`${COLORS.bright}╚══════════════════════════════════════════════════════════════╝${COLORS.reset}`);
+    lines.push('');
+    // Agent Status
+    const stateColor = STATE_COLORS[output.agent_state];
+    const stateIcon = STATE_ICONS[output.agent_state];
+    lines.push(`${COLORS.bright}AGENT:${COLORS.reset} ${output.agent_id}`);
+    lines.push(`${COLORS.bright}STATE:${COLORS.reset} ${stateColor}${stateIcon} ${output.agent_state.toUpperCase()}${COLORS.reset}`);
+    lines.push('');
+    // Findings Summary
+    const criticalCount = output.events.filter(e => e.payload.severity === 'critical').length;
+    const highCount = output.events.filter(e => e.payload.severity === 'high').length;
+    const mediumCount = output.events.filter(e => e.payload.severity === 'medium').length;
+    const lowCount = output.events.filter(e => e.payload.severity === 'low').length;
+    lines.push(`${COLORS.bright}FINDINGS SUMMARY:${COLORS.reset}`);
+    lines.push(`  ${SEVERITY_COLORS.critical} CRITICAL ${COLORS.reset} ${criticalCount}`);
+    lines.push(`  ${SEVERITY_COLORS.high} HIGH ${COLORS.reset}     ${highCount}`);
+    lines.push(`  ${SEVERITY_COLORS.medium} MEDIUM ${COLORS.reset}   ${mediumCount}`);
+    lines.push(`  ${SEVERITY_COLORS.low} LOW ${COLORS.reset}      ${lowCount}`);
+    lines.push('');
+    // Events Detail
+    lines.push(`${COLORS.bright}─────────────────────────────────────────────────────────────────${COLORS.reset}`);
+    lines.push(`${COLORS.bright}EVENTS:${COLORS.reset}`);
+    lines.push('');
+    for (const event of output.events) {
+        lines.push(formatEvent(event));
+        lines.push('');
+    }
+    // Meta
+    if (output.meta.assumptions.length > 0 || output.meta.uncertainties.length > 0) {
+        lines.push(`${COLORS.bright}─────────────────────────────────────────────────────────────────${COLORS.reset}`);
+        lines.push(`${COLORS.bright}META:${COLORS.reset}`);
+        if (output.meta.assumptions.length > 0) {
+            lines.push(`  ${COLORS.dim}Assumptions:${COLORS.reset}`);
+            for (const a of output.meta.assumptions) {
+                lines.push(`    • ${a}`);
+            }
+        }
+        if (output.meta.uncertainties.length > 0) {
+            lines.push(`  ${COLORS.dim}Uncertainties:${COLORS.reset}`);
+            for (const u of output.meta.uncertainties) {
+                lines.push(`    • ${u}`);
+            }
+        }
+        lines.push('');
+    }
+    // Footer
+    lines.push(`${COLORS.bright}═══════════════════════════════════════════════════════════════${COLORS.reset}`);
+    return lines.join('\n');
+}
+function formatEvent(event) {
+    const lines = [];
+    const sevColor = SEVERITY_COLORS[event.payload.severity];
+    // Event header
+    lines.push(`  ${sevColor}[${event.payload.severity.toUpperCase()}]${COLORS.reset} ${COLORS.bright}${event.event_type}${COLORS.reset}`);
+    lines.push(`  ${COLORS.dim}${event.timestamp}${COLORS.reset}`);
+    lines.push('');
+    // Claim
+    lines.push(`  ${COLORS.cyan}CLAIM:${COLORS.reset} ${event.payload.claim}`);
+    lines.push(`  ${COLORS.cyan}CONFIDENCE:${COLORS.reset} ${(event.payload.confidence * 100).toFixed(0)}%`);
+    // Attack path
+    if (event.payload.attack_path.length > 0) {
+        lines.push(`  ${COLORS.cyan}ATTACK PATH:${COLORS.reset}`);
+        for (let i = 0; i < event.payload.attack_path.length; i++) {
+            const prefix = i === event.payload.attack_path.length - 1 ? '└─' : '├─';
+            lines.push(`    ${prefix} ${event.payload.attack_path[i]}`);
+        }
+    }
+    // Affected assets
+    if (event.payload.affected_assets.length > 0) {
+        lines.push(`  ${COLORS.cyan}AFFECTED:${COLORS.reset} ${event.payload.affected_assets.join(', ')}`);
+    }
+    // Assurance breaks
+    if (event.payload.assurance_break.length > 0) {
+        lines.push(`  ${COLORS.cyan}ASSURANCE BREAK:${COLORS.reset} ${event.payload.assurance_break.join(', ')}`);
+    }
+    // Evidence refs
+    if (event.payload.evidence_refs.length > 0) {
+        lines.push(`  ${COLORS.cyan}EVIDENCE:${COLORS.reset}`);
+        for (const ref of event.payload.evidence_refs) {
+            lines.push(`    • [${ref.type}] ${ref.pointer}`);
+        }
+    }
+    return lines.join('\n');
+}
+// Simple ASCII visualization for state
+export function visualizeState(state) {
+    const frames = {
+        idle: [
+            '    ○    ',
+            '   ───   ',
+            '  │   │  ',
+            '  └───┘  '
+        ],
+        analyzing: [
+            '    ◐    ',
+            '   ╱─╲   ',
+            '  │ ⚙ │  ',
+            '  └───┘  '
+        ],
+        conflict: [
+            '   ⚡⚡   ',
+            '   ╱─╲   ',
+            '  │ ! │  ',
+            '  └───┘  '
+        ],
+        escalated: [
+            '    ▲    ',
+            '   ╱!╲   ',
+            '  │ ▲ │  ',
+            '  └───┘  '
+        ],
+        blocked: [
+            '   ███   ',
+            '   █■█   ',
+            '  █ ✗ █  ',
+            '   ███   '
+        ]
+    };
+    const stateColor = STATE_COLORS[state];
+    return frames[state].map(line => `${stateColor}${line}${COLORS.reset}`).join('\n');
+}
+export function visualizeCompact(output) {
+    const criticalCount = output.events.filter(e => e.payload.severity === 'critical').length;
+    const highCount = output.events.filter(e => e.payload.severity === 'high').length;
+    const stateColor = STATE_COLORS[output.agent_state];
+    const stateIcon = STATE_ICONS[output.agent_state];
+    let statusLine = `${stateColor}${stateIcon}${COLORS.reset} `;
+    statusLine += `${output.agent_id} │ `;
+    statusLine += `${stateColor}${output.agent_state.toUpperCase()}${COLORS.reset} │ `;
+    if (criticalCount > 0) {
+        statusLine += `${SEVERITY_COLORS.critical} ${criticalCount} CRIT ${COLORS.reset} `;
+    }
+    if (highCount > 0) {
+        statusLine += `${SEVERITY_COLORS.high} ${highCount} HIGH ${COLORS.reset} `;
+    }
+    return statusLine;
+}

package/dist/websocket/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * WebSocket Server for aurasecurity
+ *
+ * Provides real-time updates to connected clients:
+ * - Audit started/completed events
+ * - Finding notifications
+ * - Settings changes
+ * - Server status updates
+ */
+export interface WSMessage {
+    type: 'audit_started' | 'audit_completed' | 'finding' | 'settings_changed' | 'status' | 'ping' | 'pong';
+    payload: unknown;
+    timestamp: string;
+}
+export interface AuditStartedPayload {
+    auditId: string;
+    type: string;
+    target: string;
+}
+export interface AuditCompletedPayload {
+    auditId: string;
+    type: string;
+    target: string;
+    summary: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    duration?: number;
+}
+export interface FindingPayload {
+    auditId: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    type: string;
+    message: string;
+    file?: string;
+    line?: number;
+}
+export declare class AuditorWebSocket {
+    private port;
+    private wss;
+    private clients;
+    private pingInterval;
+    constructor(port?: number);
+    /**
+     * Start the WebSocket server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the WebSocket server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle incoming messages from clients
+     */
+    private handleMessage;
+    /**
+     * Send message to a specific client
+     */
+    private sendTo;
+    /**
+     * Broadcast message to all connected clients
+     */
+    broadcast(message: WSMessage): void;
+    /**
+     * Notify clients that an audit has started
+     */
+    notifyAuditStarted(payload: AuditStartedPayload): void;
+    /**
+     * Notify clients that an audit has completed
+     */
+    notifyAuditCompleted(payload: AuditCompletedPayload): void;
+    /**
+     * Notify clients of a finding during an audit
+     */
+    notifyFinding(payload: FindingPayload): void;
+    /**
+     * Notify clients that settings have changed
+     */
+    notifySettingsChanged(section?: string): void;
+    /**
+     * Get the number of connected clients
+     */
+    getClientCount(): number;
+}
+export declare function getWebSocketServer(port?: number): AuditorWebSocket;
+export declare function closeWebSocketServer(): Promise<void>;