0xray 4.0.33 → 4.0.35

package/dist/integrations/base/ExampleIntegration.js

@@ -1,180 +0,0 @@
-/**
- * Example Integration - Demonstrates using the BaseIntegration class
- *
- * This is a simple example showing how to create a custom integration
- * that extends the BaseIntegration class.
- *
- * @since 2026-03-15
- */
-import { BaseIntegration, createSimpleIntegration, } from "./index.js";
-/**
- * Example custom integration
- *
- * Demonstrates how to extend BaseIntegration with custom logic.
- */
-class ExampleIntegration extends BaseIntegration {
-    /** Custom property for this integration */
-    connectionString = "";
-    connected = false;
-    /**
-     * Create a new ExampleIntegration
-     *
-     * @param config - Optional configuration
-     */
-    constructor(config) {
-        super("example-integration", "1.0.0", {
-            enabled: true,
-            debug: false,
-            logLevel: "info",
-            ...config,
-        });
-    }
-    /**
-     * Set connection string
-     */
-    setConnectionString(connStr) {
-        this.connectionString = connStr;
-    }
-    /**
-     * Check if connected
-     */
-    isConnected() {
-        return this.connected;
-    }
-    // ==========================================================================
-    // Protected abstract method implementations
-    // ==========================================================================
-    /**
-     * Perform integration-specific initialization
-     */
-    async performInitialization() {
-        await this.log("info", "Starting initialization...");
-        // Simulate async initialization (e.g., connecting to a service)
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        if (this.connectionString) {
-            // Would connect to external service here
-            this.connected = true;
-            await this.log("success", "Connected to service");
-        }
-        // Emit custom event
-        this.emit("custom-initialized", { connected: this.connected });
-    }
-    /**
-     * Perform integration-specific shutdown
-     */
-    async performShutdown() {
-        await this.log("info", "Starting shutdown...");
-        // Simulate async cleanup
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        this.connected = false;
-        await this.log("success", "Shutdown complete");
-    }
-    /**
-     * Perform integration-specific health check
-     */
-    async performHealthCheck() {
-        if (!this.connected) {
-            return {
-                healthy: false,
-                message: "Not connected to service",
-                details: { connectionString: !!this.connectionString },
-            };
-        }
-        // In a real integration, you might ping the service here
-        return {
-            healthy: true,
-            message: "Service connection healthy",
-            details: { connected: true },
-        };
-    }
-}
-// ==========================================================================
-// Usage Examples
-// ==========================================================================
-/**
- * Example 1: Using a custom integration class
- */
-async function exampleCustomIntegration() {
-    console.log("\n--- Example 1: Custom Integration ---");
-    // Create integration
-    const integration = new ExampleIntegration({
-        debug: true,
-        logLevel: "debug",
-    });
-    // Set connection string
-    integration.setConnectionString("http://localhost:3000");
-    // Setup event listener
-    integration.on("initialized", (event) => {
-        console.log("Integration initialized event:", event.type);
-    });
-    // Initialize
-    await integration.initialize();
-    // Check health
-    const health = await integration.healthCheck();
-    console.log("Health check:", health);
-    // Get stats
-    const stats = integration.getStats();
-    console.log("Stats:", stats);
-    // Shutdown
-    await integration.shutdown();
-}
-/**
- * Example 2: Using createSimpleIntegration factory
- */
-async function exampleSimpleIntegration() {
-    console.log("\n--- Example 2: Simple Integration ---");
-    // Create a simple integration without subclassing
-    const simple = createSimpleIntegration("simple-integration", "1.0.0", 
-    // Custom health check
-    async () => ({
-        healthy: true,
-        message: "Always healthy",
-    }), 
-    // Custom shutdown
-    async () => {
-        console.log("Custom cleanup performed");
-    });
-    // Initialize
-    await simple.initialize();
-    // Check health
-    const health = await simple.healthCheck();
-    console.log("Health check:", health);
-    // Shutdown
-    await simple.shutdown();
-}
-/**
- * Example 3: Error handling
- */
-async function exampleErrorHandling() {
-    console.log("\n--- Example 3: Error Handling ---");
-    // Create integration that will fail to initialize
-    class FailingIntegration extends BaseIntegration {
-        constructor() {
-            super("failing-integration", "1.0.0");
-        }
-        async performInitialization() {
-            throw new Error("Connection refused");
-        }
-        async performShutdown() {
-            // Cleanup even on failure
-        }
-        async performHealthCheck() {
-            return { healthy: false, message: "Not initialized" };
-        }
-    }
-    const failing = new FailingIntegration();
-    try {
-        await failing.initialize();
-    }
-    catch (error) {
-        console.log("Caught expected error:", error instanceof Error ? error.message : error);
-    }
-}
-// Run examples if this file is executed directly
-// (In a real project, you would import and use the classes)
-// Export for use in other modules
-export { ExampleIntegration };
-// Example usage (uncomment to run):
-// exampleCustomIntegration().catch(console.error);
-// exampleSimpleIntegration().catch(console.error);
-// exampleErrorHandling().catch(console.error);

package/dist/integrations/enforcement-gate.d.ts

@@ -1,44 +0,0 @@
-/**
- * Enforcement Gate — shared v3 pipeline entry point for TUI/CLI integration hooks.
- *
- * Provides beforeToolHook (early ValidatorRegistry + block decision) and
- * afterToolHook (post-tool v3 PostProcessor loop + governance routing) that
- * all four host integrations (OpenCode, Hermes, Grok, OpenClaw) call from
- * their programmatic hook surfaces (tool.execute.before/after, onPreToolCall,
- * PreToolUse, onToolBefore/onToolAfter).
- *
- * This is the canonical "how a TUI/CLI tool leverages v3 cleanly."
- *
- * @module integrations/enforcement-gate
- */
-export interface GateViolation {
-    ruleId: string;
-    severity: string;
-    message: string;
-    suggestions?: string[];
-}
-export interface BeforeHookResult {
-    allowed: boolean;
-    blocked: boolean;
-    violations: GateViolation[];
-    resonance: number;
-    duration: number;
-}
-export interface AfterHookResult {
-    processed: boolean;
-    violations: GateViolation[];
-    processorResults: Array<{
-        name: string;
-        success: boolean;
-        error?: string;
-    }>;
-    governanceTriggered: boolean;
-    duration: number;
-}
-export interface GateContext {
-    directory?: string;
-    projectRoot?: string;
-    sessionId?: string;
-}
-export declare function beforeToolHook(tool: string, args: Record<string, unknown> | null, _context?: GateContext): Promise<BeforeHookResult>;
-export declare function afterToolHook(tool: string, args: Record<string, unknown> | null, _result: unknown, _error: string | null, _context?: GateContext): Promise<AfterHookResult>;

package/dist/integrations/enforcement-gate.js

@@ -1,348 +0,0 @@
-/**
- * Enforcement Gate — shared v3 pipeline entry point for TUI/CLI integration hooks.
- *
- * Provides beforeToolHook (early ValidatorRegistry + block decision) and
- * afterToolHook (post-tool v3 PostProcessor loop + governance routing) that
- * all four host integrations (OpenCode, Hermes, Grok, OpenClaw) call from
- * their programmatic hook surfaces (tool.execute.before/after, onPreToolCall,
- * PreToolUse, onToolBefore/onToolAfter).
- *
- * This is the canonical "how a TUI/CLI tool leverages v3 cleanly."
- *
- * @module integrations/enforcement-gate
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-// ── Registry Cache ─────────────────────────────────────────────
-function getGlobalRegistry() {
-    if (globalThis.xrayValidatorRegistry) {
-        return globalThis.xrayValidatorRegistry;
-    }
-    return null;
-}
-async function loadRegistry() {
-    const cached = getGlobalRegistry();
-    if (cached)
-        return cached;
-    const candidatePaths = [
-        () => import("../enforcement/validators/validator-registry.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/enforcement/validators/validator-registry.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            const registry = mod.globalValidatorRegistry;
-            if (registry) {
-                globalThis.xrayValidatorRegistry = registry;
-                return registry;
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-// ── v3 PostProcessor Loader ────────────────────────────────────
-async function loadV3PostProcessor() {
-    const global = globalThis;
-    if (global.xrayPostProcessor && typeof global.xrayPostProcessor.executePostProcessorLoop === "function") {
-        return global.xrayPostProcessor;
-    }
-    // xrayPostProcessor fallback removed in v2.2
-    return null;
-}
-// ── Context Builder ────────────────────────────────────────────
-function buildValidationContext(tool, args) {
-    const op = mapToolToOperation(tool);
-    const files = [];
-    let newCode;
-    if (args) {
-        const filePath = args.filePath || args.path || args.file || "";
-        if (filePath)
-            files.push(filePath);
-        if (typeof args.content === "string") {
-            newCode = args.content;
-        }
-        else if (typeof args.code === "string") {
-            newCode = args.code;
-        }
-        else if (args.content instanceof Map && args.content.size > 0) {
-            newCode = Array.from(args.content.values()).join("\n");
-        }
-        else if (args.newCode instanceof Map && args.newCode.size > 0) {
-            newCode = Array.from(args.newCode.values()).join("\n");
-        }
-    }
-    return { operation: op, files, ...(newCode ? { newCode } : {}) };
-}
-function mapToolToOperation(tool) {
-    const writeTools = /^(write|edit|create|modify|patch|insert|replace|apply_diff|overwrite_file|write_file)$/i;
-    const readTools = /^(read|search|find|list|grep|glob|lookup|get)$/i;
-    const execTools = /^(run|execute|bash|terminal|command|shell)$/i;
-    if (writeTools.test(tool))
-        return "write";
-    if (readTools.test(tool))
-        return "read";
-    if (execTools.test(tool))
-        return "execute";
-    return "modify";
-}
-function isCodeProducingTool(tool) {
-    return mapToolToOperation(tool) === "write" || mapToolToOperation(tool) === "modify";
-}
-// ── beforeToolHook ─────────────────────────────────────────────
-export async function beforeToolHook(tool, args, _context) {
-    const start = Date.now();
-    try {
-        const registry = await loadRegistry();
-        if (!registry) {
-            await frameworkLogger.log("enforcement-gate", "before-hook-registry-unavailable", "warning", { tool });
-            return { allowed: true, blocked: false, violations: [], resonance: 0.85, duration: Date.now() - start };
-        }
-        const validationCtx = buildValidationContext(tool, args);
-        const allValidators = registry.getAllValidators();
-        const violations = [];
-        for (const v of allValidators) {
-            try {
-                const result = await v.validate(validationCtx);
-                if (!result.passed) {
-                    violations.push({
-                        ruleId: v.ruleId || v.id,
-                        severity: v.severity || "warning",
-                        message: result.message || `${v.id} violation detected`,
-                        ...(result.suggestions ? { suggestions: result.suggestions } : { suggestions: [] }),
-                    });
-                }
-            }
-            catch (valErr) {
-                await frameworkLogger.log("enforcement-gate", "validator-error", "warning", {
-                    ruleId: v.id,
-                    error: String(valErr),
-                });
-            }
-        }
-        const blockingViolations = violations.filter((v) => v.severity === "error" || v.severity === "blocking");
-        const blocked = blockingViolations.length > 0;
-        let resonance = 1.0;
-        for (const v of violations) {
-            resonance -= v.severity === "error" || v.severity === "blocking" ? 0.15 : 0.05;
-        }
-        resonance = Math.max(0.1, Math.min(1.0, resonance));
-        if (blocked || violations.length > 0) {
-            await frameworkLogger.log("enforcement-gate", "before-hook-result", blocked ? "error" : "warning", {
-                tool,
-                blocked,
-                violationCount: violations.length,
-                resonance,
-                duration: Date.now() - start,
-                violations: violations.map((v) => `[${v.severity}] ${v.ruleId}: ${v.message}`),
-            });
-        }
-        return {
-            allowed: !blocked,
-            blocked,
-            violations,
-            resonance,
-            duration: Date.now() - start,
-        };
-    }
-    catch (err) {
-        await frameworkLogger.log("enforcement-gate", "before-hook-error", "error", {
-            tool,
-            error: String(err),
-        });
-        return { allowed: true, blocked: false, violations: [], resonance: 0.85, duration: Date.now() - start };
-    }
-}
-// ── afterToolHook ──────────────────────────────────────────────
-export async function afterToolHook(tool, args, _result, _error, _context) {
-    const start = Date.now();
-    try {
-        if (!isCodeProducingTool(tool)) {
-            return { processed: false, violations: [], processorResults: [], governanceTriggered: false, duration: Date.now() - start };
-        }
-        await frameworkLogger.log("enforcement-gate", "after-hook-start", "info", { tool });
-        const registry = await loadRegistry();
-        const violations = [];
-        const processorResults = [];
-        // Step 1: Run per-pipeline validators (same as PostProcessor.ts:382-432)
-        if (registry) {
-            const validationCtx = buildValidationContext(tool, args);
-            const pipelineRules = ["error-resolution", "loop-safety", "boot-wiring", "console-log-usage"];
-            for (const ruleId of pipelineRules) {
-                try {
-                    const v = registry.getValidator(ruleId);
-                    if (!v)
-                        continue;
-                    const result = await v.validate(validationCtx);
-                    if (!result.passed) {
-                        violations.push({
-                            ruleId,
-                            severity: v.severity || "warning",
-                            message: result.message || `${ruleId} violation`,
-                            ...(result.suggestions ? { suggestions: result.suggestions } : { suggestions: [] }),
-                        });
-                    }
-                }
-                catch (valErr) {
-                    await frameworkLogger.log("enforcement-gate", "pipeline-validator-error", "warning", {
-                        ruleId,
-                        error: String(valErr),
-                    });
-                }
-            }
-        }
-        // Step 2: Legacy ProcessorManager compat (test-auto-creation etc.)
-        try {
-            const stateManager = await loadStateManager();
-            const ProcessorManager = await loadProcessorManager();
-            if (ProcessorManager && stateManager) {
-                const pm = new ProcessorManager(stateManager);
-                const config = { preProcessors: ["preValidate", "codexCompliance", "versionCompliance"] };
-                const registered = await pm.registerAllProcessors(config);
-                processorResults.push({ name: "register-processors", success: true });
-                if (registered) {
-                    const preCtx = {
-                        operation: mapToolToOperation(tool),
-                        files: args?.filePath ? [args.filePath] : [],
-                        directory: process.cwd(),
-                    };
-                    await pm.executePreProcessors(preCtx);
-                    processorResults.push({ name: "pre-processors", success: true });
-                }
-            }
-        }
-        catch (pmErr) {
-            processorResults.push({ name: "processor-manager", success: false, error: String(pmErr) });
-            await frameworkLogger.log("enforcement-gate", "processor-error", "warning", {
-                tool,
-                error: String(pmErr),
-            });
-        }
-        // Step 3: Try v3 PostProcessor loop (with critical violations from pipeline validators)
-        try {
-            const v3pp = await loadV3PostProcessor();
-            if (v3pp) {
-                const critical = violations.filter(v => v.severity === "error" || v.severity === "blocking");
-                const postCtx = {
-                    trigger: "manual",
-                    operation: mapToolToOperation(tool),
-                    filePath: args?.filePath || args?.path || "",
-                    directory: process.cwd(),
-                    newCode: buildValidationContext(tool, args).newCode || "",
-                    files: buildValidationContext(tool, args).files || [],
-                    tool,
-                    metadata: { source: "enforcement-gate", hookType: "integration" },
-                    criticalViolations: critical.length > 0 ? critical : undefined,
-                };
-                await v3pp.executePostProcessorLoop(postCtx);
-                processorResults.push({ name: "v3-post-processor-loop", success: true });
-            }
-        }
-        catch (v3Err) {
-            processorResults.push({ name: "v3-post-processor-loop", success: false, error: String(v3Err) });
-            await frameworkLogger.log("enforcement-gate", "v3-post-processor-error", "warning", {
-                tool,
-                error: String(v3Err),
-            });
-        }
-        // Step 4: Check for proposal-like results
-        let governanceTriggered = false;
-        try {
-            const result = _result;
-            if (result && typeof result === "object" && "title" in result && "description" in result) {
-                const { handleGovernRequest } = await import("../nucleus/index.js");
-                const localMode = process.env.XRAY_LOCAL_MODE === "1" || process.env.XRAY_LOCAL_MODE === "true";
-                const governanceResult = await handleGovernRequest({
-                    proposals: [
-                        {
-                            id: `gate-${Date.now()}`,
-                            type: String(result.type || "fix"),
-                            title: String(result.title || ""),
-                            description: String(result.description || ""),
-                            evidence: [],
-                            source: "manual",
-                            metadata: result,
-                        },
-                    ],
-                    options: {
-                        requireExternalDynamo: localMode ? false : undefined,
-                    },
-                });
-                governanceTriggered = governanceResult?.overallDecision === 'approve';
-                if (governanceTriggered) {
-                    await frameworkLogger.log("enforcement-gate", "governance-triggered", "info", {
-                        tool,
-                        proposalTitle: String(result.title),
-                    });
-                }
-            }
-        }
-        catch (govErr) {
-            await frameworkLogger.log("enforcement-gate", "governance-error", "warning", {
-                tool,
-                error: String(govErr),
-            });
-        }
-        await frameworkLogger.log("enforcement-gate", "after-hook-complete", "info", {
-            tool,
-            violations: violations.length,
-            processors: processorResults.length,
-            governanceTriggered,
-            duration: Date.now() - start,
-        });
-        return {
-            processed: true,
-            violations,
-            processorResults,
-            governanceTriggered,
-            duration: Date.now() - start,
-        };
-    }
-    catch (err) {
-        await frameworkLogger.log("enforcement-gate", "after-hook-error", "error", {
-            tool,
-            error: String(err),
-        });
-        return { processed: false, violations: [], processorResults: [], governanceTriggered: false, duration: Date.now() - start };
-    }
-}
-// ── Helpers ────────────────────────────────────────────────────
-async function loadStateManager() {
-    const global = globalThis;
-    if (global.xrayStateManager)
-        return global.xrayStateManager;
-    // xrayStateManager fallback removed in v2.2
-    const candidatePaths = [
-        () => import("../state/state-manager.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/state/state-manager.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            const SM = mod.XrayStateManager;
-            if (SM)
-                return SM;
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-async function loadProcessorManager() {
-    const candidatePaths = [
-        () => import("../processors/processor-manager.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/processors/processor-manager.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            return mod.ProcessorManager;
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}

package/dist/mcps/connection/connection-manager.d.ts

@@ -1,39 +0,0 @@
-import { IMcpConnection, IServerConfig } from '../types/index.js';
-/**
- * Connection Manager
- * Manages MCP connection lifecycle and provides centralized access to connections
- */
-export declare class ConnectionManager {
-    private connections;
-    /**
-     * Get or create a connection for a server
-     * @param config - Server configuration
-     * @returns Promise resolving to an MCP connection
-     */
-    getConnection(config: IServerConfig): Promise<IMcpConnection>;
-    /**
-     * Disconnect a specific server
-     * @param serverName - Name of the server to disconnect
-     */
-    disconnect(serverName: string): Promise<void>;
-    /**
-     * Disconnect all managed connections
-     */
-    disconnectAll(): Promise<void>;
-    /**
-     * Check if a connection exists for a server
-     * @param serverName - Name of the server
-     * @returns True if connection exists and is connected
-     */
-    hasConnection(serverName: string): boolean;
-    /**
-     * Get all connected server names
-     * @returns Array of server names
-     */
-    getConnectedServers(): string[];
-    /**
-     * Get the number of active connections
-     * @returns Number of connections
-     */
-    getConnectionCount(): number;
-}

package/dist/mcps/connection/connection-manager.js

@@ -1,79 +0,0 @@
-import { McpConnection } from './mcp-connection.js';
-import { frameworkLogger } from '../../core/framework-logger.js';
-/**
- * Connection Manager
- * Manages MCP connection lifecycle and provides centralized access to connections
- */
-export class ConnectionManager {
-    connections = new Map();
-    /**
-     * Get or create a connection for a server
-     * @param config - Server configuration
-     * @returns Promise resolving to an MCP connection
-     */
-    async getConnection(config) {
-        const existingConnection = this.connections.get(config.serverName);
-        if (existingConnection && existingConnection.isConnected) {
-            return existingConnection;
-        }
-        // If existing connection is disconnected, remove it
-        if (existingConnection) {
-            await existingConnection.disconnect();
-            this.connections.delete(config.serverName);
-        }
-        // Create new connection
-        const connection = new McpConnection(config);
-        await connection.connect();
-        this.connections.set(config.serverName, connection);
-        return connection;
-    }
-    /**
-     * Disconnect a specific server
-     * @param serverName - Name of the server to disconnect
-     */
-    async disconnect(serverName) {
-        const connection = this.connections.get(serverName);
-        if (connection) {
-            await connection.disconnect();
-            this.connections.delete(serverName);
-        }
-    }
-    /**
-     * Disconnect all managed connections
-     */
-    async disconnectAll() {
-        const disconnectPromises = [];
-        for (const [serverName, connection] of this.connections) {
-            disconnectPromises.push(connection.disconnect().catch((error) => {
-                frameworkLogger.log("connection-manager", "disconnect-error", "error", { serverName, error });
-            }));
-        }
-        await Promise.all(disconnectPromises);
-        this.connections.clear();
-    }
-    /**
-     * Check if a connection exists for a server
-     * @param serverName - Name of the server
-     * @returns True if connection exists and is connected
-     */
-    hasConnection(serverName) {
-        const connection = this.connections.get(serverName);
-        return connection !== undefined && connection.isConnected;
-    }
-    /**
-     * Get all connected server names
-     * @returns Array of server names
-     */
-    getConnectedServers() {
-        return Array.from(this.connections.entries())
-            .filter(([, connection]) => connection.isConnected)
-            .map(([name]) => name);
-    }
-    /**
-     * Get the number of active connections
-     * @returns Number of connections
-     */
-    getConnectionCount() {
-        return this.getConnectedServers().length;
-    }
-}