0xray 4.0.11 → 4.0.13

package/dist/integrations/openclaw/config.js

@@ -1,372 +0,0 @@
-/**
- * OpenClaw Configuration Loader
- *
- * Handles loading, validation, and management of OpenClaw integration configuration.
- *
- * @since 2026-03-14
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-/**
- * Default configuration values
- */
-const DEFAULT_CONFIG = {
-    gatewayUrl: 'ws://127.0.0.1:18789',
-    autoReconnect: true,
-    maxReconnectAttempts: 5,
-    reconnectDelay: 1000,
-    apiServer: {
-        enabled: true,
-        port: 18431,
-        host: '127.0.0.1',
-    },
-    hooks: {
-        enabled: true,
-        toolBefore: true,
-        toolAfter: true,
-        includeArgs: true,
-        includeResult: true,
-    },
-    enabled: true,
-    debug: false,
-    logLevel: 'info',
-};
-/**
- * Environment variable mappings
- */
-const ENV_MAPPINGS = {
-    OPENCLAW_GATEWAY_URL: 'gatewayUrl',
-    OPENCLAW_AUTH_TOKEN: 'authToken',
-    OPENCLAW_DEVICE_ID: 'deviceId',
-    OPENCLAW_API_KEY: 'apiServer.apiKey',
-    OPENCLAW_API_PORT: 'apiServer.port',
-    OPENCLAW_ENABLED: 'enabled',
-    OPENCLAW_DEBUG: 'debug',
-};
-/**
- * Configuration loader class
- */
-export class OpenClawConfigLoader {
-    config = null;
-    configPath;
-    loadedAt = 0;
-    constructor(configPath) {
-        this.configPath = configPath ||
-            path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
-    }
-    /**
-     * Load configuration from file with environment variable overrides
-     */
-    load() {
-        try {
-            // Load from file if exists
-            let userConfig = {};
-            if (fs.existsSync(this.configPath)) {
-                const configContent = fs.readFileSync(this.configPath, 'utf-8');
-                userConfig = JSON.parse(configContent);
-            }
-            // Apply environment variable overrides
-            userConfig = this.applyEnvironmentOverrides(userConfig);
-            // Merge with defaults
-            this.config = this.mergeWithDefaults(userConfig);
-            // Validate configuration
-            const validation = this.validateConfig(this.config);
-            if (!validation.valid) {
-                throw new Error(`Configuration validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
-            }
-            this.loadedAt = Date.now();
-            return this.config;
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new Error(`Failed to load OpenClaw configuration: ${error.message}`);
-            }
-            throw new Error('Failed to load OpenClaw configuration: Unknown error');
-        }
-    }
-    /**
-     * Reload configuration from file
-     */
-    reload() {
-        this.config = null;
-        this.loadedAt = 0;
-        return this.load();
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        if (!this.config) {
-            return this.load();
-        }
-        return this.config;
-    }
-    /**
-     * Get configuration age in milliseconds
-     */
-    getConfigAge() {
-        if (!this.loadedAt)
-            return 0;
-        return Date.now() - this.loadedAt;
-    }
-    /**
-     * Check if configuration needs reload
-     */
-    needsReload(maxAgeMs = 60000) {
-        return this.getConfigAge() > maxAgeMs;
-    }
-    /**
-     * Apply environment variable overrides
-     */
-    applyEnvironmentOverrides(config) {
-        const result = { ...config };
-        for (const [envVar, configPath] of Object.entries(ENV_MAPPINGS)) {
-            const envValue = process.env[envVar];
-            if (envValue !== undefined) {
-                // Parse value based on expected type
-                let parsedValue = envValue;
-                // Handle boolean values
-                if (envValue.toLowerCase() === 'true') {
-                    parsedValue = true;
-                }
-                else if (envValue.toLowerCase() === 'false') {
-                    parsedValue = false;
-                }
-                // Handle numeric values
-                else if (/^\d+$/.test(envValue)) {
-                    parsedValue = parseInt(envValue, 10);
-                }
-                // Set nested value
-                const keys = configPath.split('.');
-                let current = result;
-                for (let i = 0; i < keys.length - 1; i++) {
-                    const key = keys[i];
-                    if (!current[key]) {
-                        current[key] = {};
-                    }
-                    current = current[key];
-                }
-                current[keys[keys.length - 1]] = parsedValue;
-            }
-        }
-        return result;
-    }
-    /**
-     * Merge user config with defaults
-     */
-    mergeWithDefaults(userConfig) {
-        // Handle nested defaults
-        const apiServerDefaults = DEFAULT_CONFIG.apiServer || { enabled: true, port: 18431, host: '127.0.0.1' };
-        const hooksDefaults = DEFAULT_CONFIG.hooks || { enabled: true, toolBefore: true, toolAfter: true, includeArgs: true, includeResult: true };
-        const result = {
-            gatewayUrl: userConfig.gatewayUrl || DEFAULT_CONFIG.gatewayUrl || 'ws://127.0.0.1:18789',
-            autoReconnect: userConfig.autoReconnect ?? DEFAULT_CONFIG.autoReconnect ?? true,
-            maxReconnectAttempts: userConfig.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts ?? 5,
-            reconnectDelay: userConfig.reconnectDelay ?? DEFAULT_CONFIG.reconnectDelay ?? 1000,
-            apiServer: {
-                enabled: userConfig.apiServer?.enabled ?? apiServerDefaults.enabled ?? true,
-                port: userConfig.apiServer?.port ?? apiServerDefaults.port ?? 18431,
-                host: userConfig.apiServer?.host ?? apiServerDefaults.host ?? '127.0.0.1',
-                ...(userConfig.apiServer?.apiKey !== undefined ? { apiKey: userConfig.apiServer.apiKey } : {}),
-            },
-            hooks: {
-                enabled: userConfig.hooks?.enabled ?? hooksDefaults.enabled ?? true,
-                toolBefore: userConfig.hooks?.toolBefore ?? hooksDefaults.toolBefore ?? true,
-                toolAfter: userConfig.hooks?.toolAfter ?? hooksDefaults.toolAfter ?? true,
-                includeArgs: userConfig.hooks?.includeArgs ?? hooksDefaults.includeArgs ?? true,
-                includeResult: userConfig.hooks?.includeResult ?? hooksDefaults.includeResult ?? true,
-            },
-            enabled: userConfig.enabled ?? DEFAULT_CONFIG.enabled ?? true,
-            debug: userConfig.debug ?? DEFAULT_CONFIG.debug ?? false,
-            logLevel: userConfig.logLevel ?? DEFAULT_CONFIG.logLevel ?? 'info',
-        };
-        if (userConfig.authToken !== undefined)
-            result.authToken = userConfig.authToken;
-        if (userConfig.deviceId !== undefined)
-            result.deviceId = userConfig.deviceId;
-        if (userConfig.deviceKeyPair !== undefined)
-            result.deviceKeyPair = userConfig.deviceKeyPair;
-        return result;
-    }
-    /**
-     * Validate configuration
-     */
-    validateConfig(config) {
-        const errors = [];
-        const warnings = [];
-        // Validate gateway URL
-        if (!config.gatewayUrl) {
-            errors.push({
-                field: 'gatewayUrl',
-                message: 'gatewayUrl is required',
-                code: 'MISSING_REQUIRED',
-            });
-        }
-        else {
-            try {
-                const url = new URL(config.gatewayUrl);
-                if (!['ws:', 'wss:'].includes(url.protocol)) {
-                    errors.push({
-                        field: 'gatewayUrl',
-                        message: 'gatewayUrl must be a WebSocket URL (ws:// or wss://)',
-                        code: 'INVALID_PROTOCOL',
-                    });
-                }
-            }
-            catch {
-                errors.push({
-                    field: 'gatewayUrl',
-                    message: 'gatewayUrl is not a valid URL',
-                    code: 'INVALID_URL',
-                });
-            }
-        }
-        // Validate API server port
-        if (config.apiServer?.enabled) {
-            if (!config.apiServer.port || config.apiServer.port < 1 || config.apiServer.port > 65535) {
-                errors.push({
-                    field: 'apiServer.port',
-                    message: 'apiServer.port must be between 1 and 65535',
-                    code: 'INVALID_PORT',
-                });
-            }
-            // Warn if binding to non-localhost
-            if (config.apiServer.host && !['localhost', '127.0.0.1', '::1'].includes(config.apiServer.host)) {
-                warnings.push({
-                    field: 'apiServer.host',
-                    message: 'Binding API server to non-localhost address may expose API externally',
-                });
-            }
-        }
-        // Validate reconnection settings
-        if (config.maxReconnectAttempts < 0) {
-            errors.push({
-                field: 'maxReconnectAttempts',
-                message: 'maxReconnectAttempts must be non-negative',
-                code: 'INVALID_VALUE',
-            });
-        }
-        if (config.reconnectDelay < 0) {
-            errors.push({
-                field: 'reconnectDelay',
-                message: 'reconnectDelay must be non-negative',
-                code: 'INVALID_VALUE',
-            });
-        }
-        // Validate log level
-        const validLogLevels = ['error', 'warn', 'info', 'debug'];
-        if (config.logLevel && !validLogLevels.includes(config.logLevel)) {
-            errors.push({
-                field: 'logLevel',
-                message: `logLevel must be one of: ${validLogLevels.join(', ')}`,
-                code: 'INVALID_VALUE',
-            });
-        }
-        // Warnings for potentially problematic configs
-        if (config.apiServer?.enabled && !config.apiServer.apiKey) {
-            warnings.push({
-                field: 'apiServer.apiKey',
-                message: 'API server is enabled without an API key - consider adding one for security',
-            });
-        }
-        if (config.autoReconnect && config.maxReconnectAttempts === 0) {
-            warnings.push({
-                field: 'autoReconnect',
-                message: 'autoReconnect is true but maxReconnectAttempts is 0',
-            });
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings,
-        };
-    }
-    /**
-     * Get configuration file path
-     */
-    getConfigPath() {
-        return this.configPath;
-    }
-    /**
-     * Check if configuration file exists
-     */
-    configExists() {
-        return fs.existsSync(this.configPath);
-    }
-    /**
-     * Create sample configuration file
-     */
-    createSampleConfig() {
-        const configDir = path.dirname(this.configPath);
-        // Create directory if it doesn't exist
-        if (!fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true });
-        }
-        const sampleConfig = {
-            gatewayUrl: 'ws://127.0.0.1:18789',
-            // SECURITY WARNING: authToken MUST be configured before use.
-            // Leaving this empty will prevent authenticated connections.
-            authToken: process.env.OPENCLAW_AUTH_TOKEN || '',
-            autoReconnect: true,
-            maxReconnectAttempts: 5,
-            reconnectDelay: 1000,
-            apiServer: {
-                enabled: true,
-                port: 18431,
-                host: '127.0.0.1',
-                ...(process.env.OPENCLAW_API_KEY ? { apiKey: process.env.OPENCLAW_API_KEY } : {}),
-            },
-            hooks: {
-                enabled: true,
-                toolBefore: true,
-                toolAfter: true,
-                includeArgs: true,
-                includeResult: true,
-            },
-            enabled: true, // Disabled by default until configured
-            debug: false,
-            logLevel: 'info',
-        };
-        fs.writeFileSync(this.configPath, JSON.stringify(sampleConfig, null, 2) + os.EOL, 'utf-8');
-    }
-    /**
-     * Get config for API server only
-     */
-    getAPIServerConfig() {
-        const config = this.getConfig();
-        return config.apiServer;
-    }
-    /**
-     * Get config for hooks only
-     */
-    getHooksConfig() {
-        const config = this.getConfig();
-        return config.hooks;
-    }
-    /**
-     * Check if integration is enabled
-     */
-    isEnabled() {
-        return this.getConfig().enabled;
-    }
-    /**
-     * Check if API server is enabled
-     */
-    isAPIServerEnabled() {
-        return this.getConfig().apiServer?.enabled ?? false;
-    }
-    /**
-     * Check if hooks are enabled
-     */
-    areHooksEnabled() {
-        const config = this.getConfig();
-        return config.hooks?.enabled ?? false;
-    }
-}
-// Export singleton instance
-export const configLoader = new OpenClawConfigLoader();
-// Export factory function
-export function createConfigLoader(configPath) {
-    return new OpenClawConfigLoader(configPath);
-}

package/dist/integrations/openclaw/hooks/pre-tool-gate-runtime.mjs

@@ -1,102 +0,0 @@
-#!/usr/bin/env node
-/**
- * OpenClaw host PreToolUse runtime — stdin JSON → stdout { action: block|allow }.
- * Installed to ~/.openclaw/hooks/xray-pre-tool.mjs by `0xray openclaw install`.
- */
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { stdin } from 'node:process';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-function resolveGate() {
-  const envRoot = process.env.XRAY_AI_PATH || process.env.XRAY_ROOT || '';
-  const candidates = [
-    envRoot ? join(envRoot, 'dist/nucleus/delegation-gate.js') : '',
-    join(__dirname, '../../../nucleus/delegation-gate.js'),
-    join(__dirname, '../../../../dist/nucleus/delegation-gate.js'),
-    join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
-    join(process.cwd(), 'dist/nucleus/delegation-gate.js'),
-  ].filter(Boolean);
-  const found = candidates.find((p) => existsSync(p));
-  if (!found) {
-    throw new Error('delegation-gate.js missing — build 0xray or npm install 0xray');
-  }
-  return require(found);
-}
-
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stdin.setEncoding('utf8');
-    stdin.on('data', (c) => chunks.push(c));
-    stdin.on('end', () => {
-      const raw = chunks.join('').trim();
-      if (!raw) {
-        resolve({});
-        return;
-      }
-      try {
-        resolve(JSON.parse(raw));
-      } catch (err) {
-        reject(err);
-      }
-    });
-    stdin.on('error', reject);
-  });
-}
-
-function decide(event, gate) {
-  const projectRoot =
-    event.cwd || event.workspaceRoot || event.projectRoot || process.cwd();
-  const sessionId = event.sessionId || event.session_id || 'openclaw';
-  const toolName = event.tool || event.toolName || event.name || 'unknown';
-  const args = event.args || event.toolInput || event.input || {};
-  const features = gate.loadDelegationGateFeatures(projectRoot, 'openclaw');
-  const outcome = gate.evaluatePreToolGate(toolName, args, {
-    projectRoot,
-    sessionId,
-    features,
-    host: 'openclaw',
-  });
-  if (!outcome.allow) {
-    return {
-      action: 'block',
-      allow: false,
-      reason: outcome.reason,
-      gate: outcome.gate,
-    };
-  }
-  return {
-    action: 'allow',
-    allow: true,
-    reason: outcome.reason,
-    gate: outcome.gate,
-    warn: Boolean(outcome.reason),
-  };
-}
-
-async function main() {
-  try {
-    const event = await readStdin();
-    const gate = resolveGate();
-    const decision = decide(event, gate);
-    console.log(JSON.stringify(decision));
-    process.exit(decision.action === 'block' ? 2 : 0);
-  } catch (err) {
-    console.log(
-      JSON.stringify({
-        action: 'block',
-        allow: false,
-        gate: 'openclaw-pre-tool-error',
-        reason: err instanceof Error ? err.message : String(err),
-      }),
-    );
-    process.exit(2);
-  }
-}
-
-main();

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

@@ -1,123 +0,0 @@
-/**
- * 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;