0xray 2.0.0 → 2.1.0

package/dist/security/security-headers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Security Headers Middleware
+ *
+ * Comprehensive security headers implementation for HTTP responses.
+ * Integrates with boot orchestrator and API endpoints.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+export interface HttpResponse {
+    setHeader(name: string, value: string): void;
+}
+export interface ExpressMiddlewareParams {
+    req: unknown;
+    res: HttpResponse;
+    next: (err?: Error) => void;
+}
+export interface FastifyMiddlewareParams {
+    request: unknown;
+    reply: HttpResponse;
+    done: (err?: Error) => void;
+}
+export interface SecurityHeadersConfig {
+    enableCSP: boolean;
+    enableHSTS: boolean;
+    enableFrameOptions: boolean;
+    enableXSSProtection: boolean;
+    enableContentTypeOptions: boolean;
+    enableReferrerPolicy: boolean;
+    enablePermissionsPolicy: boolean;
+    customCSP?: string;
+    hstsMaxAge?: number;
+    hstsIncludeSubdomains?: boolean;
+    hstsPreload?: boolean;
+}
+export declare class SecurityHeadersMiddleware {
+    private config;
+    constructor(config?: Partial<SecurityHeadersConfig>);
+    /**
+     * Apply security headers to HTTP response
+     */
+    applySecurityHeaders(response: HttpResponse): void;
+    /**
+     * Express.js middleware function
+     */
+    getExpressMiddleware(): (req: unknown, res: HttpResponse, next: (err?: Error) => void) => void;
+    /**
+     * Fastify middleware function
+     */
+    getFastifyMiddleware(): (request: unknown, reply: HttpResponse, done: (err?: Error) => void) => void;
+    /**
+     * Generic middleware for any HTTP framework
+     */
+    getMiddleware(): (response: HttpResponse) => void;
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<SecurityHeadersConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SecurityHeadersConfig;
+}
+export declare const securityHeadersMiddleware: SecurityHeadersMiddleware;

package/dist/security/security-orchestration-layer.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Security Orchestration Layer
+ *
+ * Coordinates multiple security agents for comprehensive vulnerability scanning,
+ * automated remediation, and compliance validation using weighted voting
+ * for architectural decisions.
+ *
+ * @version 1.22.13
+ */
+import { EventEmitter } from "events";
+import { Vulnerability, RemediationPlan, ComplianceStandard } from "./comprehensive-security-audit.js";
+export interface SecurityAgent {
+    id: string;
+    name: string;
+    type: SecurityAgentType;
+    weight: number;
+    status: AgentStatus;
+    lastActive?: Date;
+    capabilities: string[];
+}
+export type SecurityAgentType = "security-auditor" | "code-analyzer" | "testing-lead" | "architect" | "vulnerability-scanner" | "compliance-validator" | "remediation-specialist";
+export type AgentStatus = "idle" | "scanning" | "analyzing" | "reporting" | "error";
+export interface OrchestrationConfig {
+    enableWeightedVoting: boolean;
+    enableAutoRemediation: boolean;
+    decisionThreshold: number;
+    agentWeights: Record<SecurityAgentType, number>;
+    scanDepth: "shallow" | "medium" | "deep";
+    complianceStandards: ComplianceStandard[];
+    maxConcurrentAgents: number;
+    timeout: number;
+}
+export interface SecurityTask {
+    id: string;
+    type: SecurityTaskType;
+    priority: "critical" | "high" | "medium" | "low";
+    assignedAgent?: SecurityAgent;
+    status: "pending" | "in-progress" | "completed" | "failed";
+    result?: unknown;
+    error?: string;
+    createdAt: Date;
+    completedAt?: Date;
+}
+export type SecurityTaskType = "vulnerability-scan" | "code-analysis" | "compliance-check" | "remediation" | "threat-detection" | "security-review";
+export interface AgentVote {
+    agentId: string;
+    agentName: string;
+    vote: "approve" | "reject" | "abstain";
+    weight: number;
+    reasoning: string;
+    concerns: string[] | undefined;
+    confidence: number;
+}
+export interface SecurityDecision {
+    id: string;
+    title: string;
+    description: string;
+    type: "approval" | "rejection" | "revision-required";
+    votes: AgentVote[];
+    weightedApproval: number;
+    threshold: number;
+    approved: boolean;
+    timestamp: Date;
+    relatedVulnerabilities: string[] | undefined;
+}
+export interface SecurityOrchestrationReport {
+    auditId: string;
+    timestamp: Date;
+    duration: number;
+    agents: SecurityAgent[];
+    tasks: SecurityTask[];
+    decisions: SecurityDecision[];
+    summary: {
+        totalVulnerabilities: number;
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+        securityScore: number;
+        complianceScore: number;
+    };
+    vulnerabilities: Vulnerability[];
+    prioritizedRemediation: RemediationPlan[];
+    recommendations: string[];
+}
+export declare class SecurityOrchestrationLayer extends EventEmitter {
+    private config;
+    private agents;
+    private tasks;
+    private decisions;
+    private auditSystem;
+    private isRunning;
+    constructor(config?: Partial<OrchestrationConfig>);
+    private initializeAgents;
+    runSecurityOrchestration(projectPath: string): Promise<SecurityOrchestrationReport>;
+    private createTask;
+    private executeVulnerabilityScan;
+    private executeComplianceCheck;
+    private executeRemediationPlanning;
+    private updateAgentStatus;
+    private collectAgentVotes;
+    private generateAgentVote;
+    private makeSecurityDecisions;
+    private createDecision;
+    private generateOrchestrationReport;
+    private calculateSecurityScore;
+    private calculateComplianceScore;
+    private prioritizeRemediation;
+    private estimateFixTime;
+    private generateRecommendations;
+    getAgents(): SecurityAgent[];
+    getAgent(agentId: string): SecurityAgent | undefined;
+    getTasks(): SecurityTask[];
+    getDecisions(): SecurityDecision[];
+    getActiveAgents(): SecurityAgent[];
+    getVulnerabilities(): Vulnerability[];
+}
+export declare function createSecurityOrchestrationLayer(config?: Partial<OrchestrationConfig>): SecurityOrchestrationLayer;
+export declare function runSecurityOrchestration(projectPath: string, config?: Partial<OrchestrationConfig>): Promise<SecurityOrchestrationReport>;

package/dist/security/security-scanner.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 0xRay Framework - Security Scanner
+ *
+ * Automated security vulnerability scanning and compliance validation
+ * Integrates with security tools and provides comprehensive security reports
+ */
+export interface SecurityScanConfig {
+    enabled: boolean;
+    tools: {
+        npmAudit: boolean;
+        trivy: boolean;
+        eslintSecurity: boolean;
+        dependencyCheck: boolean;
+    };
+    severityThreshold: "low" | "moderate" | "high" | "critical";
+    reportPath: string;
+    failOnVulnerabilities: boolean;
+}
+export interface SecurityVulnerability {
+    id: string;
+    title: string;
+    description: string;
+    severity: "low" | "moderate" | "high" | "critical";
+    package?: string;
+    version?: string;
+    cve?: string;
+    url?: string;
+    recommendation: string;
+}
+export interface SecurityReport {
+    timestamp: string;
+    duration: number;
+    tools: {
+        npmAudit: SecurityVulnerability[];
+        trivy: SecurityVulnerability[];
+        eslintSecurity: SecurityVulnerability[];
+        dependencyCheck: SecurityVulnerability[];
+    };
+    summary: {
+        totalVulnerabilities: number;
+        bySeverity: Record<string, number>;
+        byTool: Record<string, number>;
+    };
+    recommendations: string[];
+    compliant: boolean;
+}
+export declare class SecurityScanner {
+    private config;
+    constructor(config?: Partial<SecurityScanConfig>);
+    /**
+     * Run comprehensive security scan
+     */
+    runSecurityScan(): Promise<SecurityReport>;
+    /**
+     * Run npm audit
+     */
+    private runNpmAudit;
+    /**
+     * Run Trivy security scan
+     */
+    private runTrivyScan;
+    /**
+     * Run ESLint security rules
+     */
+    private runEslintSecurity;
+    /**
+     * Run OWASP Dependency Check
+     */
+    private runDependencyCheck;
+    /**
+     * Generate comprehensive security report
+     */
+    private generateReport;
+    /**
+     * Generate security recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Save report to file
+     */
+    private saveReport;
+    /**
+     * Log security scan results
+     */
+    private logResults;
+    /**
+     * Map npm audit severity levels
+     */
+    private mapNpmSeverity;
+    /**
+     * Map Trivy severity levels
+     */
+    private mapTrivySeverity;
+    /**
+     * Map Dependency Check severity levels
+     */
+    private mapDependencyCheckSeverity;
+    /**
+     * Validate AI prompt security
+     */
+    validatePrompt(prompt: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Validate AI response security
+     */
+    validateResponse(response: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Create empty report when scanning is disabled
+     */
+    private createEmptyReport;
+}
+export declare const securityScanner: SecurityScanner;

package/dist/services/inference-tuner.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Inference Tuner - Autonomous Learning Service
+ *
+ * Implements the autonomous inference improvement loop:
+ * 1. Collects routing outcomes and pattern metrics
+ * 2. Analyzes performance and detects drift
+ * 3. Generates refinement reports
+ * 4. Updates configuration automatically
+ *
+ * @module services
+ * @version 1.0.0
+ */
+export interface TuningConfig {
+    autoUpdateMappings: boolean;
+    autoUpdateThresholds: boolean;
+    minConfidenceThreshold: number;
+    minSuccessRateForAutoAdd: number;
+    learningIntervalMs: number;
+    maxMappingsToAdd: number;
+}
+export declare class InferenceTuner {
+    private config;
+    private lastTuningTime;
+    private tuningInProgress;
+    private tuningInterval;
+    constructor(config?: Partial<TuningConfig>);
+    /**
+     * Start autonomous tuning
+     */
+    start(): void;
+    /**
+     * Stop autonomous tuning
+     */
+    stop(): void;
+    /**
+     * Run a single tuning cycle
+     */
+    runTuningCycle(): Promise<void>;
+    /**
+     * Perform the actual tuning work
+     */
+    private performTuning;
+    /**
+     * Suggest new mappings based on patterns and outcomes
+     */
+    private suggestMappingsFromPatterns;
+    /**
+     * Resolve the path to the routing-mappings.json file.
+     * Checks multiple known locations and returns the first one found.
+     */
+    private resolveMappingsPath;
+    /**
+     * Load current routing mappings from disk.
+     */
+    private loadMappings;
+    /**
+     * Save routing mappings to disk.
+     */
+    private saveMappings;
+    /**
+     * Add a keyword mapping to the routing-mappings.json file.
+     *
+     * Checks for conflicts (keyword already mapped to a different agent)
+     * before adding. If the keyword already exists for the same agent,
+     * updates the confidence if the new value is higher.
+     */
+    private addKeywordMapping;
+    /**
+     * Get tuning status
+     */
+    getStatus(): {
+        running: boolean;
+        lastTuningTime: number;
+        config: TuningConfig;
+    };
+}
+export declare const inferenceTuner: InferenceTuner;

package/dist/services/inference-tuner.js

@@ -181,9 +181,9 @@ export class InferenceTuner {
      */
     resolveMappingsPath() {
         const candidates = [
-            path.resolve(process.cwd(), ".strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".opencode/strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".opencode/xray/routing-mappings.json"),
             path.resolve(process.cwd(), "routing-mappings.json"),
         ];
         for (const p of candidates) {

package/dist/session/index.d.ts

@@ -0,0 +1,3 @@
+export { SessionCleanupManager, createSessionCleanupManager } from "./session-cleanup-manager.js";
+export { SessionMonitor, createSessionMonitor } from "./session-monitor.js";
+export { SessionStateManager, createSessionStateManager } from "./session-state-manager.js";

package/dist/session/session-cleanup-manager.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Session Cleanup Manager
+ *
+ * Manages automatic cleanup of sessions with TTL-based expiration,
+ * idle session detection, and manual cleanup utilities.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { SessionMonitor } from "./session-monitor.js";
+export interface SessionMetadata {
+    sessionId: string;
+    createdAt: number;
+    lastActivity: number;
+    ttlMs: number;
+    isActive: boolean;
+    agentCount: number;
+    memoryUsage: number;
+    cleanupReason?: string;
+}
+export interface CleanupConfig {
+    ttlMs: number;
+    idleTimeoutMs: number;
+    maxSessions: number;
+    cleanupIntervalMs: number;
+    enableAutoCleanup: boolean;
+}
+export interface CleanupResult {
+    sessionsCleaned: number;
+    sessionsExpired: number;
+    sessionsIdle: number;
+    errors: string[];
+}
+export declare class SessionCleanupManager {
+    private stateManager;
+    private config;
+    private cleanupInterval?;
+    private _sessionMetadata?;
+    private _metadataLoaded;
+    private sessionMonitor;
+    constructor(stateManager: XrayStateManager, config?: Partial<CleanupConfig>, sessionMonitor?: SessionMonitor);
+    /**
+     * Lazy-loaded session metadata - loads from state manager on first access
+     */
+    private get sessionMetadata();
+    private set sessionMetadata(value);
+    /**
+     * Initialize cleanup manager and start auto-cleanup if enabled
+     */
+    private initialize;
+    start(): void;
+    /**
+     * Register a new session for cleanup tracking
+     */
+    registerSession(sessionId: string, ttlMs?: number): void;
+    updateActivity(sessionId: string): void;
+    updateMetadata(sessionId: string, updates: Partial<SessionMetadata>): void;
+    /**
+     * Check if session should be cleaned up
+     */
+    shouldCleanup(sessionId: string): boolean;
+    /**
+     * Perform cleanup of expired/idle sessions
+     */
+    performCleanup(): Promise<CleanupResult>;
+    /**
+     * Manually cleanup a specific session
+     */
+    manualCleanup(sessionId: string, reason?: string): Promise<boolean>;
+    /**
+     * Cleanup all sessions (emergency cleanup)
+     */
+    emergencyCleanup(): Promise<CleanupResult>;
+    /**
+     * Get cleanup statistics
+     */
+    getCleanupStats(): {
+        totalSessions: number;
+        activeSessions: number;
+        expiredSessions: number;
+        idleSessions: number;
+        nextCleanup: number;
+    };
+    /**
+     * Get session metadata
+     */
+    getSessionMetadata(sessionId: string): SessionMetadata | undefined;
+    /**
+     * List all sessions with metadata
+     */
+    listSessions(): SessionMetadata[];
+    /**
+     * Start automatic cleanup interval
+     */
+    private startAutoCleanup;
+    /**
+     * Stop automatic cleanup
+     */
+    stopAutoCleanup(): void;
+    /**
+     * Load session metadata from state manager (lazy loading)
+     */
+    private loadSessionMetadata;
+    /**
+     * Persist session metadata to state manager
+     */
+    private persistSessionMetadata;
+    /**
+     * Cleanup a specific session
+     */
+    private cleanupSession;
+    /**
+     * Shutdown cleanup manager
+     */
+    shutdown(): void;
+}
+export declare const createSessionCleanupManager: (stateManager: XrayStateManager, config?: Partial<CleanupConfig>, sessionMonitor?: SessionMonitor) => SessionCleanupManager;

package/dist/session/session-monitor.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Session Monitor
+ *
+ * Provides real-time monitoring of sessions with health checks,
+ * performance tracking, and alerting capabilities.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { SessionCoordinator } from "../delegation/session-coordinator.js";
+import { SessionCleanupManager } from "./session-cleanup-manager.js";
+export interface SessionHealth {
+    sessionId: string;
+    status: "healthy" | "degraded" | "critical" | "unknown";
+    lastCheck: number;
+    responseTime: number;
+    errorCount: number;
+    activeAgents: number;
+    memoryUsage: number;
+    issues: string[];
+}
+export interface SessionMetrics {
+    sessionId: string;
+    timestamp: number;
+    totalInteractions: number;
+    successfulInteractions: number;
+    failedInteractions: number;
+    averageResponseTime: number;
+    conflictResolutionRate: number;
+    coordinationEfficiency: number;
+    memoryUsage: number;
+    agentCount: number;
+}
+export interface InteractionRecord {
+    timestamp: number;
+    duration: number;
+    success: boolean;
+    agentId?: string;
+    operation?: string;
+}
+export interface MonitorConfig {
+    healthCheckIntervalMs: number;
+    metricsCollectionIntervalMs: number;
+    alertThresholds: {
+        maxResponseTime: number;
+        maxErrorRate: number;
+        maxMemoryUsage: number;
+        minCoordinationEfficiency: number;
+        maxConflicts: number;
+    };
+    enableAlerts: boolean;
+    enableMetrics: boolean;
+}
+export interface Alert {
+    id: string;
+    sessionId: string;
+    type: "health" | "performance" | "resource" | "coordination";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    timestamp: number;
+    resolved: boolean;
+    resolvedAt?: number;
+}
+export declare class SessionMonitor {
+    private stateManager;
+    private sessionCoordinator;
+    private cleanupManager;
+    private config;
+    private healthChecks;
+    private metricsHistory;
+    private activeAlerts;
+    private healthCheckInterval?;
+    private metricsInterval?;
+    private interactionHistory;
+    private sessionResponseTimes;
+    private sessionErrors;
+    constructor(stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator, cleanupManager: SessionCleanupManager, config?: Partial<MonitorConfig>);
+    start(): void;
+    registerSession(sessionId: string): void;
+    unregisterSession(sessionId: string): void;
+    performHealthCheck(sessionId: string): Promise<SessionHealth>;
+    collectMetrics(sessionId: string): SessionMetrics | null;
+    getHealthStatus(sessionId: string): SessionHealth | null;
+    getMetricsHistory(sessionId: string, limit?: number): SessionMetrics[];
+    getActiveAlerts(sessionId?: string): Alert[];
+    resolveAlert(alertId: string): boolean;
+    getMonitoringStats(): {
+        totalSessions: number;
+        healthySessions: number;
+        degradedSessions: number;
+        criticalSessions: number;
+        activeAlerts: number;
+        totalMetricsPoints: number;
+    };
+    private startHealthChecks;
+    private startMetricsCollection;
+    private generateAlerts;
+    private loadPersistedData;
+    private persistHealthData;
+    private persistMetricsData;
+    private persistAlertData;
+    shutdown(): void;
+    /**
+     * Record an interaction for tracking
+     */
+    recordInteraction(sessionId: string, interaction: InteractionRecord): void;
+    /**
+     * Get interaction history for a session
+     */
+    getInteractionHistory(sessionId: string, limit?: number): InteractionRecord[];
+    /**
+     * Perform comprehensive health checks on a session
+     */
+    private performComprehensiveHealthChecks;
+    /**
+     * Calculate failure ratio from interactions
+     */
+    private calculateFailureRatio;
+    /**
+     * Calculate conflict resolution rate from interactions
+     */
+    private calculateConflictResolutionRate;
+    /**
+     * Calculate coordination efficiency from interactions
+     */
+    private calculateCoordinationEfficiency;
+    private persistInteractionData;
+    private calculateSessionMemoryUsage;
+    private countSessionConflicts;
+    private calculateAverageResponseTime;
+}
+export declare const createSessionMonitor: (stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator, cleanupManager: SessionCleanupManager, config?: Partial<MonitorConfig>) => SessionMonitor;