0xray 3.4.2 → 3.4.3

package/dist/integrations/openclaw/api-server.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 0xRay API Server
+ *
+ * HTTP API server that OpenClaw skills call to invoke 0xRay capabilities.
+ * This is the bridge between OpenClaw skills and 0xRay.
+ *
+ * @since 2026-03-14
+ */
+import { XrayAPIServerConfig, AgentInvokeRequest, AgentInvokeResponse, APIServerStatistics } from './types.js';
+/**
+ * Agent invoker interface - implemented by 0xRay
+ */
+export interface AgentInvoker {
+    invoke(request: AgentInvokeRequest): Promise<AgentInvokeResponse>;
+    getStatus?(): Promise<{
+        healthy: boolean;
+        version: string;
+    }>;
+}
+/**
+ * 0xRay API Server
+ */
+export declare class XrayAPIServer {
+    private server;
+    private config;
+    private agentInvoker;
+    private apiKey;
+    private stats;
+    private responseTimes;
+    private logger;
+    constructor(config: XrayAPIServerConfig);
+    /**
+     * Set the agent invoker
+     */
+    setAgentInvoker(invoker: AgentInvoker): void;
+    /**
+     * Start the API server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the API server
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get server statistics
+     */
+    getStats(): APIServerStatistics;
+    /**
+     * Handle incoming HTTP request
+     */
+    private handleRequest;
+    /**
+     * Handle health check request
+     */
+    private handleHealth;
+    /**
+     * Handle agent invoke request
+     */
+    private handleAgentInvoke;
+    /**
+     * Handle agent status request
+     */
+    private handleAgentStatus;
+    private handleGovern;
+    private handleApply;
+    /**
+     * Validate API key using constant-time comparison to prevent timing attacks
+     */
+    private validateApiKey;
+    /**
+     * Read request body
+     */
+    private readBody;
+    /**
+     * Send JSON response
+     */
+    private sendResponse;
+}
+/**
+ * Factory function to create API server
+ */
+export declare function createXrayAPIServer(config: XrayAPIServerConfig): XrayAPIServer;

package/dist/integrations/openclaw/client.d.ts

@@ -0,0 +1,121 @@
+/**
+ * OpenClaw WebSocket Client
+ *
+ * Implements OpenClaw Gateway Protocol v3 with proper request/response handling,
+ * reconnection logic, and event management.
+ *
+ * @since 2026-03-14
+ */
+import { OpenClawClientConfig, OpenClawClientState, ClientStatistics } from './types.js';
+/**
+ * OpenClaw WebSocket Client
+ */
+export declare class OpenClawClient {
+    private ws;
+    private config;
+    private state;
+    private pendingRequests;
+    private eventListeners;
+    private stateListeners;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private stats;
+    private logger;
+    constructor(config: OpenClawClientConfig);
+    /**
+     * Connect to OpenClaw Gateway
+     */
+    private handshakeResolve;
+    private handshakeReject;
+    private _handshakeTimeout;
+    connect(): Promise<void>;
+    /**
+     * Disconnect from OpenClaw Gateway
+     */
+    disconnect(): void;
+    /**
+     * Send request and wait for response
+     */
+    sendRequest<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    /**
+     * Subscribe to events
+     */
+    subscribeToEvents(events: string[]): Promise<void>;
+    /**
+     * Get current state
+     */
+    getState(): OpenClawClientState;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get statistics
+     */
+    getStats(): ClientStatistics;
+    /**
+     * Add event listener
+     */
+    on(event: string, listener: Function): void;
+    /**
+     * Remove event listener
+     */
+    off(event: string, listener: Function): void;
+    /**
+     * Add state change listener
+     */
+    onStateChange(listener: Function): void;
+    /**
+     * Remove state change listener
+     */
+    offStateChange(listener: Function): void;
+    /**
+     * Send handshake on connect
+     */
+    private sendHandshake;
+    /**
+     * Handle incoming WebSocket message
+     */
+    private handleMessage;
+    /**
+     * Handle response frame
+     */
+    private handleResponse;
+    /**
+     * Handle event frame
+     */
+    private handleEvent;
+    /**
+     * Handle disconnection
+     */
+    private handleDisconnect;
+    /**
+     * Schedule reconnection
+     */
+    private scheduleReconnect;
+    /**
+     * Start ping interval for connection health
+     */
+    private startPingInterval;
+    /**
+     * Set client state
+     */
+    private setState;
+    /**
+     * Generate unique ID for requests
+     */
+    private generateId;
+    /**
+     * Generate nonce for device pairing
+     */
+    private generateNonce;
+    /**
+     * Sign device challenge
+     */
+    private signDeviceChallenge;
+}
+/**
+ * Factory function to create client
+ */
+export declare function createOpenClawClient(config: OpenClawClientConfig): OpenClawClient;

package/dist/integrations/openclaw/config.d.ts

@@ -0,0 +1,95 @@
+/**
+ * OpenClaw Configuration Loader
+ *
+ * Handles loading, validation, and management of OpenClaw integration configuration.
+ *
+ * @since 2026-03-14
+ */
+import { OpenClawIntegrationConfig, ConfigValidationResult } from './types.js';
+/**
+ * Configuration loader class
+ */
+export declare class OpenClawConfigLoader {
+    private config;
+    private configPath;
+    private loadedAt;
+    constructor(configPath?: string);
+    /**
+     * Load configuration from file with environment variable overrides
+     */
+    load(): OpenClawIntegrationConfig;
+    /**
+     * Reload configuration from file
+     */
+    reload(): OpenClawIntegrationConfig;
+    /**
+     * Get current configuration
+     */
+    getConfig(): OpenClawIntegrationConfig;
+    /**
+     * Get configuration age in milliseconds
+     */
+    getConfigAge(): number;
+    /**
+     * Check if configuration needs reload
+     */
+    needsReload(maxAgeMs?: number): boolean;
+    /**
+     * Apply environment variable overrides
+     */
+    private applyEnvironmentOverrides;
+    /**
+     * Merge user config with defaults
+     */
+    private mergeWithDefaults;
+    /**
+     * Validate configuration
+     */
+    validateConfig(config: OpenClawIntegrationConfig): ConfigValidationResult;
+    /**
+     * Get configuration file path
+     */
+    getConfigPath(): string;
+    /**
+     * Check if configuration file exists
+     */
+    configExists(): boolean;
+    /**
+     * Create sample configuration file
+     */
+    createSampleConfig(): void;
+    /**
+     * Get config for API server only
+     */
+    getAPIServerConfig(): {
+        enabled: boolean;
+        port: number;
+        host?: string;
+        apiKey?: string;
+    };
+    /**
+     * Get config for hooks only
+     */
+    getHooksConfig(): {
+        enabled: boolean;
+        toolBefore: boolean;
+        toolAfter: boolean;
+        includeArgs: boolean;
+        includeResult: boolean;
+        toolFilter?: string[];
+    };
+    /**
+     * Check if integration is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if API server is enabled
+     */
+    isAPIServerEnabled(): boolean;
+    /**
+     * Check if hooks are enabled
+     */
+    areHooksEnabled(): boolean;
+}
+export declare const configLoader: OpenClawConfigLoader;
+export declare function createConfigLoader(configPath?: string): OpenClawConfigLoader;

package/dist/integrations/openclaw/hooks/xray-hooks.d.ts

@@ -0,0 +1,123 @@
+/**
+ * OpenClaw 0xRay Hooks Integration
+ *
+ * Integrates OpenClaw with 0xRay's tool.before and tool.after hooks
+ * to send tool execution events to OpenClaw Gateway.
+ *
+ * @since 2026-03-14
+ */
+import { OpenClawClient } from '../client.js';
+/**
+ * Hooks configuration
+ */
+export interface OpenClawHooksConfig {
+    enabled: boolean;
+    toolBefore: boolean;
+    toolAfter: boolean;
+    includeArgs: boolean;
+    includeResult: boolean;
+    toolFilter?: string[];
+}
+/**
+ * 0xRay tool event
+ */
+export interface XrayToolEvent {
+    toolName: string;
+    toolId: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    duration: number;
+    timestamp: number;
+    sessionId?: string;
+    agent?: string;
+}
+/**
+ * Hook event callback type
+ */
+export type ToolEventCallback = (event: XrayToolEvent) => void | Promise<void>;
+/**
+ * OpenClaw Hooks Manager
+ */
+export declare class OpenClawHooksManager {
+    private client;
+    private config;
+    private initialized;
+    private toolBeforeCallbacks;
+    private toolAfterCallbacks;
+    private logger;
+    private eventQueue;
+    private maxQueueSize;
+    private isFlushing;
+    constructor(config: OpenClawHooksConfig);
+    /**
+     * Set the OpenClaw client
+     */
+    setClient(client: OpenClawClient): void;
+    /**
+     * Initialize hooks - registers with 0xRay's event system
+     */
+    initialize(): Promise<void>;
+    /**
+     * Register a callback for tool.before events
+     * Call this to connect to 0xRay's tool.before event system
+     */
+    registerToolBefore(callback: ToolEventCallback): void;
+    /**
+     * Unregister a tool.before callback
+     */
+    unregisterToolBefore(callback: ToolEventCallback): void;
+    /**
+     * Register a callback for tool.after events
+     * Call this to connect to 0xRay's tool.after event system
+     */
+    registerToolAfter(callback: ToolEventCallback): void;
+    /**
+     * Unregister a tool.after callback
+     */
+    unregisterToolAfter(callback: ToolEventCallback): void;
+    /**
+     * Handle tool.before event from 0xRay
+     */
+    onToolBefore(event: XrayToolEvent): Promise<void>;
+    /**
+     * Handle tool.after event from 0xRay
+     */
+    onToolAfter(event: XrayToolEvent): Promise<void>;
+    /**
+     * Queue an event for later delivery when connection is restored
+     */
+    private queueEvent;
+    /**
+     * Flush queued events to OpenClaw Gateway
+     */
+    private flushEventQueue;
+    /**
+     * Get the current queue size
+     */
+    getQueueSize(): number;
+    /**
+     * Called when client reconnects - flush the event queue
+     */
+    handleReconnect(): Promise<void>;
+    /**
+     * Shutdown hooks
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if hooks are initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<OpenClawHooksConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): OpenClawHooksConfig;
+}
+/**
+ * Factory function to create hooks manager
+ */
+export declare function createOpenClawHooksManager(config: OpenClawHooksConfig): OpenClawHooksManager;

package/dist/integrations/openclaw/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * OpenClaw Integration - Main Module
+ *
+ * Combines all OpenClaw integration components into a single interface.
+ *
+ * @since 2026-03-14
+ */
+import { BaseIntegration } from '../base/index.js';
+import type { OpenClawIntegrationConfig, IntegrationStatistics } from './types.js';
+import { OpenClawClient } from './client.js';
+import { XrayAPIServer } from './api-server.js';
+import { OpenClawHooksManager } from './hooks/xray-hooks.js';
+import type { AgentInvoker } from './api-server.js';
+/**
+ * Main OpenClaw Integration class
+ * Extends BaseIntegration for consistent lifecycle management
+ */
+export declare class OpenClawIntegration extends BaseIntegration {
+    private configLoader;
+    private client;
+    private apiServer;
+    private hooksManager;
+    private agentInvoker;
+    private mcpToolBeforeUnsubscribe;
+    private mcpToolAfterUnsubscribe;
+    constructor(configPath?: string);
+    /**
+     * Set the agent invoker for the API server
+     */
+    setAgentInvoker(invoker: AgentInvoker): void;
+    /**
+     * Perform integration-specific initialization
+     * Called by BaseIntegration.initialize() after base setup
+     */
+    protected performInitialization(): Promise<void>;
+    /**
+     * Wire OpenClaw hooks to MCPClient tool events
+     */
+    private wireHooksToMCP;
+    /**
+     * Perform integration-specific shutdown
+     * Called by BaseIntegration.shutdown() for cleanup
+     */
+    protected performShutdown(): Promise<void>;
+    /**
+     * Perform integration-specific health check
+     */
+    protected performHealthCheck(): Promise<{
+        healthy: boolean;
+        message: string;
+        details?: Record<string, unknown>;
+    }>;
+    /**
+     * Get statistics including client, API server, and base stats
+     */
+    getStatistics(): IntegrationStatistics;
+    /**
+     * Get the API server instance
+     */
+    getAPIServer(): XrayAPIServer | null;
+    /**
+     * Get the client instance
+     */
+    getClient(): OpenClawClient | null;
+    /**
+     * Get the hooks manager
+     */
+    getHooksManager(): OpenClawHooksManager | null;
+    /**
+     * Get OpenClaw-specific configuration
+     */
+    getOpenClawConfig(): OpenClawIntegrationConfig;
+    /**
+     * Reload configuration
+     */
+    reloadConfig(): void;
+    /**
+     * Get the agent invoker
+     */
+    getAgentInvoker(): AgentInvoker | null;
+    private getDefaultClientStats;
+    private getDefaultAPIServerStats;
+}
+/**
+ * Initialize the global integration
+ */
+export declare function initializeOpenClawIntegration(configPath?: string, agentInvoker?: AgentInvoker): Promise<OpenClawIntegration>;
+/**
+ * Get the global integration
+ */
+export declare function getOpenClawIntegration(): OpenClawIntegration | null;
+/**
+ * Shutdown the global integration
+ */
+export declare function shutdownOpenClawIntegration(): Promise<void>;
+export * from './types.js';
+export * from './config.js';
+export * from './client.js';
+export * from './api-server.js';
+export { OpenClawHooksManager } from './hooks/xray-hooks.js';