aura-security 0.4.0

package/dist/websocket/index.js

@@ -0,0 +1,195 @@
+/**
+ * WebSocket Server for aurasecurity
+ *
+ * Provides real-time updates to connected clients:
+ * - Audit started/completed events
+ * - Finding notifications
+ * - Settings changes
+ * - Server status updates
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+export class AuditorWebSocket {
+    port;
+    wss = null;
+    clients = new Set();
+    pingInterval = null;
+    constructor(port = 3001) {
+        this.port = port;
+    }
+    /**
+     * Start the WebSocket server
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            this.wss = new WebSocketServer({ port: this.port });
+            this.wss.on('connection', (ws, req) => {
+                console.log(`[WS] Client connected from ${req.socket.remoteAddress}`);
+                this.clients.add(ws);
+                // Send welcome message
+                this.sendTo(ws, {
+                    type: 'status',
+                    payload: { connected: true, clientCount: this.clients.size },
+                    timestamp: new Date().toISOString()
+                });
+                ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(ws, message);
+                    }
+                    catch (err) {
+                        console.error('[WS] Invalid message:', err);
+                    }
+                });
+                ws.on('close', () => {
+                    console.log('[WS] Client disconnected');
+                    this.clients.delete(ws);
+                });
+                ws.on('error', (err) => {
+                    console.error('[WS] Client error:', err);
+                    this.clients.delete(ws);
+                });
+            });
+            this.wss.on('error', (err) => {
+                console.error('[WS] Server error:', err);
+                reject(err);
+            });
+            this.wss.on('listening', () => {
+                console.log(`[WS] WebSocket server running on ws://127.0.0.1:${this.port}`);
+                // Start ping interval to keep connections alive
+                this.pingInterval = setInterval(() => {
+                    this.broadcast({
+                        type: 'ping',
+                        payload: { time: Date.now() },
+                        timestamp: new Date().toISOString()
+                    });
+                }, 30000);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the WebSocket server
+     */
+    stop() {
+        return new Promise((resolve) => {
+            if (this.pingInterval) {
+                clearInterval(this.pingInterval);
+                this.pingInterval = null;
+            }
+            if (this.wss) {
+                // Close all client connections
+                for (const client of this.clients) {
+                    client.close(1000, 'Server shutting down');
+                }
+                this.clients.clear();
+                this.wss.close(() => {
+                    console.log('[WS] WebSocket server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Handle incoming messages from clients
+     */
+    handleMessage(ws, message) {
+        switch (message.type) {
+            case 'ping':
+                this.sendTo(ws, {
+                    type: 'pong',
+                    payload: { time: Date.now() },
+                    timestamp: new Date().toISOString()
+                });
+                break;
+            case 'pong':
+                // Client responded to ping
+                break;
+            default:
+                console.log('[WS] Received:', message.type);
+        }
+    }
+    /**
+     * Send message to a specific client
+     */
+    sendTo(ws, message) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Broadcast message to all connected clients
+     */
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(data);
+            }
+        }
+    }
+    /**
+     * Notify clients that an audit has started
+     */
+    notifyAuditStarted(payload) {
+        this.broadcast({
+            type: 'audit_started',
+            payload,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Notify clients that an audit has completed
+     */
+    notifyAuditCompleted(payload) {
+        this.broadcast({
+            type: 'audit_completed',
+            payload,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Notify clients of a finding during an audit
+     */
+    notifyFinding(payload) {
+        this.broadcast({
+            type: 'finding',
+            payload,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Notify clients that settings have changed
+     */
+    notifySettingsChanged(section) {
+        this.broadcast({
+            type: 'settings_changed',
+            payload: { section },
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Get the number of connected clients
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+}
+// Singleton instance
+let wsServer = null;
+export function getWebSocketServer(port) {
+    if (!wsServer) {
+        wsServer = new AuditorWebSocket(port);
+    }
+    return wsServer;
+}
+export function closeWebSocketServer() {
+    if (wsServer) {
+        const server = wsServer;
+        wsServer = null;
+        return server.stop();
+    }
+    return Promise.resolve();
+}

package/dist/zones/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Aura Protocol - Zones
+ *
+ * Export zone types and manager.
+ */
+export * from './types.js';
+export * from './manager.js';

package/dist/zones/index.js

@@ -0,0 +1,7 @@
+/**
+ * Aura Protocol - Zones
+ *
+ * Export zone types and manager.
+ */
+export * from './types.js';
+export * from './manager.js';

package/dist/zones/manager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Aura Protocol - Zone Manager
+ *
+ * Manages creation, execution, and lifecycle of zones.
+ * Zones are isolated execution environments that contain agents.
+ */
+import { EventEmitter } from 'events';
+import { Zone, ZoneConfig, ZoneFinding, ZoneResult, ZoneStatus } from './types.js';
+import { Agent } from '../agents/types.js';
+export declare class ZoneManager extends EventEmitter {
+    private zones;
+    private agents;
+    constructor();
+    private initializeDefaultZones;
+    /**
+     * Create a new zone
+     */
+    createZone(config: ZoneConfig): Zone;
+    /**
+     * Get a zone by ID
+     */
+    getZone(zoneId: string): Zone | undefined;
+    /**
+     * Get all zones
+     */
+    getAllZones(): Zone[];
+    /**
+     * Register an agent
+     */
+    registerAgent(agent: Agent): void;
+    /**
+     * Get an agent by ID
+     */
+    getAgent(agentId: string): Agent | undefined;
+    /**
+     * Get all agents
+     */
+    getAllAgents(): Agent[];
+    /**
+     * Get agents for a specific zone
+     */
+    getZoneAgents(zoneId: string): Agent[];
+    /**
+     * Assign an agent to a zone
+     */
+    assignAgentToZone(agentId: string, zoneId: string): void;
+    /**
+     * Remove an agent from a zone
+     */
+    removeAgentFromZone(agentId: string, zoneId: string): void;
+    /**
+     * Create a zone context for agent execution
+     */
+    private createZoneContext;
+    /**
+     * Execute a single zone
+     */
+    executeZone(zoneId: string, targetPath: string): Promise<ZoneResult>;
+    /**
+     * Execute multiple zones in parallel
+     */
+    executeZonesParallel(zoneIds: string[], targetPath: string): Promise<Map<string, ZoneResult>>;
+    /**
+     * Execute all zones in parallel
+     */
+    executeAllZones(targetPath: string): Promise<Map<string, ZoneResult>>;
+    /**
+     * Reset a zone to idle state
+     */
+    resetZone(zoneId: string): void;
+    /**
+     * Get zone status
+     */
+    getZoneStatus(zoneId: string): ZoneStatus | undefined;
+    /**
+     * Get all findings from all zones
+     */
+    getAllFindings(): ZoneFinding[];
+    /**
+     * Export zone state for visualization
+     */
+    exportState(): {
+        zones: Array<{
+            id: string;
+            name: string;
+            type: string;
+            color: string;
+            status: ZoneStatus;
+            agentCount: number;
+            findingCount: number;
+        }>;
+        agents: Array<{
+            id: string;
+            name: string;
+            role: string;
+            zoneId: string | null;
+            status: string;
+        }>;
+    };
+}
+export declare const zoneManager: ZoneManager;

package/dist/zones/manager.js

@@ -0,0 +1,304 @@
+/**
+ * Aura Protocol - Zone Manager
+ *
+ * Manages creation, execution, and lifecycle of zones.
+ * Zones are isolated execution environments that contain agents.
+ */
+import { EventEmitter } from 'events';
+import { DEFAULT_ZONES, } from './types.js';
+export class ZoneManager extends EventEmitter {
+    zones = new Map();
+    agents = new Map();
+    constructor() {
+        super();
+        // Initialize default zones
+        this.initializeDefaultZones();
+    }
+    initializeDefaultZones() {
+        for (const config of DEFAULT_ZONES) {
+            this.createZone(config);
+        }
+    }
+    /**
+     * Create a new zone
+     */
+    createZone(config) {
+        const zone = {
+            config,
+            status: 'idle',
+            memory: {
+                data: new Map(),
+                findings: [],
+                logs: [],
+            },
+        };
+        this.zones.set(config.id, zone);
+        this.emit('zone:created', { zoneId: config.id, zone });
+        return zone;
+    }
+    /**
+     * Get a zone by ID
+     */
+    getZone(zoneId) {
+        return this.zones.get(zoneId);
+    }
+    /**
+     * Get all zones
+     */
+    getAllZones() {
+        return Array.from(this.zones.values());
+    }
+    /**
+     * Register an agent
+     */
+    registerAgent(agent) {
+        this.agents.set(agent.config.id, agent);
+        this.emit('agent:registered', { agentId: agent.config.id, agent });
+    }
+    /**
+     * Get an agent by ID
+     */
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    /**
+     * Get all agents
+     */
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+    /**
+     * Get agents for a specific zone
+     */
+    getZoneAgents(zoneId) {
+        const zone = this.zones.get(zoneId);
+        if (!zone)
+            return [];
+        return zone.config.agentIds
+            .map((id) => this.agents.get(id))
+            .filter((agent) => agent !== undefined);
+    }
+    /**
+     * Assign an agent to a zone
+     */
+    assignAgentToZone(agentId, zoneId) {
+        const zone = this.zones.get(zoneId);
+        if (!zone)
+            throw new Error(`Zone ${zoneId} not found`);
+        if (!zone.config.agentIds.includes(agentId)) {
+            zone.config.agentIds.push(agentId);
+            this.emit('agent:assigned', { agentId, zoneId });
+        }
+    }
+    /**
+     * Remove an agent from a zone
+     */
+    removeAgentFromZone(agentId, zoneId) {
+        const zone = this.zones.get(zoneId);
+        if (!zone)
+            return;
+        const index = zone.config.agentIds.indexOf(agentId);
+        if (index > -1) {
+            zone.config.agentIds.splice(index, 1);
+            this.emit('agent:removed', { agentId, zoneId });
+        }
+    }
+    /**
+     * Create a zone context for agent execution
+     */
+    createZoneContext(zone, targetPath) {
+        return {
+            zoneId: zone.config.id,
+            zoneName: zone.config.name,
+            zoneType: zone.config.type,
+            targetPath,
+            memory: zone.memory,
+            config: zone.config.config || {},
+            addFinding: (finding) => {
+                const fullFinding = {
+                    ...finding,
+                    id: `${zone.config.id}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                    timestamp: Date.now(),
+                };
+                zone.memory.findings.push(fullFinding);
+                this.emit('finding:added', { zoneId: zone.config.id, finding: fullFinding });
+            },
+            log: (level, message) => {
+                const log = {
+                    level,
+                    message,
+                    timestamp: Date.now(),
+                };
+                zone.memory.logs.push(log);
+                this.emit('zone:log', { zoneId: zone.config.id, log });
+            },
+        };
+    }
+    /**
+     * Execute a single zone
+     */
+    async executeZone(zoneId, targetPath) {
+        const zone = this.zones.get(zoneId);
+        if (!zone)
+            throw new Error(`Zone ${zoneId} not found`);
+        // Update zone status
+        zone.status = 'running';
+        zone.startTime = Date.now();
+        zone.memory.findings = [];
+        zone.memory.logs = [];
+        this.emit('zone:started', { zoneId });
+        const context = this.createZoneContext(zone, targetPath);
+        const agentResults = [];
+        try {
+            // Get agents for this zone
+            const agents = this.getZoneAgents(zoneId);
+            // Execute all agents in parallel within the zone
+            const results = await Promise.all(agents.map(async (agent) => {
+                const agentStartTime = Date.now();
+                try {
+                    // Check if agent is available
+                    const isAvailable = await agent.isAvailable();
+                    if (!isAvailable) {
+                        context.log('warn', `Agent ${agent.config.name} not available, skipping`);
+                        return {
+                            agentId: agent.config.id,
+                            agentName: agent.config.name,
+                            status: 'skipped',
+                            findings: [],
+                            duration: Date.now() - agentStartTime,
+                        };
+                    }
+                    this.emit('agent:started', { zoneId, agentId: agent.config.id });
+                    context.log('info', `Starting agent: ${agent.config.name}`);
+                    const result = await agent.execute(context);
+                    this.emit('agent:completed', { zoneId, agentId: agent.config.id, result });
+                    context.log('info', `Agent ${agent.config.name} completed with ${result.findings.length} findings`);
+                    return result;
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    context.log('error', `Agent ${agent.config.name} failed: ${errorMsg}`);
+                    this.emit('agent:error', { zoneId, agentId: agent.config.id, error: errorMsg });
+                    return {
+                        agentId: agent.config.id,
+                        agentName: agent.config.name,
+                        status: 'error',
+                        findings: [],
+                        duration: Date.now() - agentStartTime,
+                        error: errorMsg,
+                    };
+                }
+            }));
+            agentResults.push(...results);
+            zone.status = 'complete';
+            zone.endTime = Date.now();
+            this.emit('zone:completed', { zoneId });
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            zone.status = 'error';
+            zone.error = errorMsg;
+            zone.endTime = Date.now();
+            this.emit('zone:error', { zoneId, error: errorMsg });
+        }
+        return {
+            zoneId: zone.config.id,
+            zoneName: zone.config.name,
+            zoneType: zone.config.type,
+            status: zone.status,
+            findings: zone.memory.findings,
+            logs: zone.memory.logs,
+            duration: (zone.endTime || Date.now()) - (zone.startTime || Date.now()),
+            agentResults,
+            error: zone.error,
+        };
+    }
+    /**
+     * Execute multiple zones in parallel
+     */
+    async executeZonesParallel(zoneIds, targetPath) {
+        this.emit('execution:started', { zoneIds, targetPath });
+        const results = await Promise.all(zoneIds.map((zoneId) => this.executeZone(zoneId, targetPath)));
+        const resultMap = new Map();
+        for (const result of results) {
+            resultMap.set(result.zoneId, result);
+        }
+        this.emit('execution:completed', { results: resultMap });
+        return resultMap;
+    }
+    /**
+     * Execute all zones in parallel
+     */
+    async executeAllZones(targetPath) {
+        const zoneIds = Array.from(this.zones.keys());
+        return this.executeZonesParallel(zoneIds, targetPath);
+    }
+    /**
+     * Reset a zone to idle state
+     */
+    resetZone(zoneId) {
+        const zone = this.zones.get(zoneId);
+        if (!zone)
+            return;
+        zone.status = 'idle';
+        zone.startTime = undefined;
+        zone.endTime = undefined;
+        zone.error = undefined;
+        zone.memory = {
+            data: new Map(),
+            findings: [],
+            logs: [],
+        };
+        this.emit('zone:reset', { zoneId });
+    }
+    /**
+     * Get zone status
+     */
+    getZoneStatus(zoneId) {
+        return this.zones.get(zoneId)?.status;
+    }
+    /**
+     * Get all findings from all zones
+     */
+    getAllFindings() {
+        const findings = [];
+        for (const zone of this.zones.values()) {
+            findings.push(...zone.memory.findings);
+        }
+        return findings;
+    }
+    /**
+     * Export zone state for visualization
+     */
+    exportState() {
+        const zones = Array.from(this.zones.values()).map((zone) => ({
+            id: zone.config.id,
+            name: zone.config.name,
+            type: zone.config.type,
+            color: zone.config.color,
+            status: zone.status,
+            agentCount: zone.config.agentIds.length,
+            findingCount: zone.memory.findings.length,
+        }));
+        const agents = Array.from(this.agents.values()).map((agent) => {
+            // Find which zone this agent belongs to
+            let zoneId = null;
+            for (const zone of this.zones.values()) {
+                if (zone.config.agentIds.includes(agent.config.id)) {
+                    zoneId = zone.config.id;
+                    break;
+                }
+            }
+            return {
+                id: agent.config.id,
+                name: agent.config.name,
+                role: agent.config.role,
+                zoneId,
+                status: agent.getStatus(),
+            };
+        });
+        return { zones, agents };
+    }
+}
+// Export singleton instance
+export const zoneManager = new ZoneManager();

package/dist/zones/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Aura Protocol - Zone Types
+ *
+ * Zones are isolated execution environments that contain agents.
+ * Each zone has its own memory space and can run in parallel with other zones.
+ */
+export type ZoneStatus = 'idle' | 'running' | 'complete' | 'error';
+export type ZoneType = 'scanner' | 'policy' | 'remediation' | 'reporting';
+export interface ZoneConfig {
+    id: string;
+    name: string;
+    type: ZoneType;
+    color: string;
+    description?: string;
+    agentIds: string[];
+    config?: Record<string, unknown>;
+}
+export interface ZoneMemory {
+    data: Map<string, unknown>;
+    findings: ZoneFinding[];
+    logs: ZoneLog[];
+}
+export interface ZoneFinding {
+    id: string;
+    agentId: string;
+    type: 'secret' | 'vulnerability' | 'policy_violation' | 'recommendation';
+    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    title: string;
+    description: string;
+    file?: string;
+    line?: number;
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+}
+export interface ZoneLog {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    agentId?: string;
+    timestamp: number;
+}
+export interface Zone {
+    config: ZoneConfig;
+    status: ZoneStatus;
+    memory: ZoneMemory;
+    startTime?: number;
+    endTime?: number;
+    error?: string;
+}
+export interface ZoneResult {
+    zoneId: string;
+    zoneName: string;
+    zoneType: ZoneType;
+    status: ZoneStatus;
+    findings: ZoneFinding[];
+    logs: ZoneLog[];
+    duration: number;
+    agentResults: AgentResult[];
+    error?: string;
+}
+export interface AgentResult {
+    agentId: string;
+    agentName: string;
+    status: 'success' | 'error' | 'skipped';
+    findings: ZoneFinding[];
+    duration: number;
+    error?: string;
+}
+export interface ZoneContext {
+    zoneId: string;
+    zoneName: string;
+    zoneType: ZoneType;
+    targetPath: string;
+    memory: ZoneMemory;
+    config: Record<string, unknown>;
+    addFinding: (finding: Omit<ZoneFinding, 'id' | 'timestamp'>) => void;
+    log: (level: ZoneLog['level'], message: string) => void;
+}
+export declare const DEFAULT_ZONES: ZoneConfig[];