0xray 2.0.0 → 2.1.0

package/dist/integrations/hermes-agent/tools.py

@@ -2,7 +2,50 @@
 
 v2.0: Now uses the Node.js bridge for real framework integration.
 Falls back to CLI (npx 0xray) when bridge is unavailable.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+
+# ── Paths ─────────────────────────────────────────────────────
+
+PLUGIN_DIR = Path(__file__).resolve().parent
+BRIDGE_PATH = PLUGIN_DIR / "bridge.mjs"
+
+
+def _get_project_root():
+    """Find the project root by walking up from cwd."""
+    cwd = os.getcwd()
+    home = Path.home()
+    d = Path(cwd).resolve()
+    while True:
+        if (d / "node_modules" / "0xray" / "package.json").exists():
+            return str(d)
+        if (d / ".opencode" / "xray" / "features.json").exists():
+            return str(d)
+        if d != home and (d / "package.json").exists():
+            return str(d)
+        d = d.parent
+        if d == d.parent:
+            break
+    return cwd
+
+
+def _run_xray(args, timeout=30):
+    """Run 0xray CLI command, return JSON string result."""
+    try:
+        result = subprocess.run(
             ["npx", "0xray"] + args,
+            capture_output=True, text=True, timeout=timeout,
+        )
+        if result.returncode == 0:
+            return json.dumps({"status": "ok", "output": result.stdout})
+        return json.dumps({"status": "error", "error": result.stderr[:500]})
+    except FileNotFoundError:
         return json.dumps({"error": "0xray not found. Run: npm install -g 0xray"})
     except subprocess.TimeoutExpired:
         return json.dumps({"error": f"Command timed out after {timeout}s"})
@@ -10,9 +53,28 @@ Falls back to CLI (npx 0xray) when bridge is unavailable.
         return json.dumps({"error": str(e)})
 
 
-# ── Tool: strray_validate ─────────────────────────────────────
+def _bridge_call(command, timeout=30):
+    """Call bridge.mjs with a JSON command, return parsed dict."""
+    try:
+        result = subprocess.run(
+            ["node", str(BRIDGE_PATH), "--cwd", _get_project_root()],
+            input=json.dumps(command),
+            capture_output=True, text=True, timeout=timeout,
+        )
+        if result.returncode != 0:
+            return {"error": result.stderr[:300] if result.stderr else "bridge failed"}
+        return json.loads(result.stdout)
+    except FileNotFoundError:
+        return {"error": "node not found"}
+    except subprocess.TimeoutExpired:
+        return {"error": f"bridge timed out after {timeout}s"}
+    except (json.JSONDecodeError, OSError) as e:
+        return {"error": str(e)}
+
+
+# ── Tool: xray_validate ─────────────────────────────────────
 
-def strray_validate(args: dict, **kwargs) -> str:
+def xray_validate(args: dict, **kwargs) -> str:
     """Run pre-commit validation on files using the framework.
 
     Uses bridge for real quality gate + processor pipeline.
@@ -41,7 +103,7 @@ def strray_validate(args: dict, **kwargs) -> str:
         })
 
     # Fallback to CLI
-    result = json.loads(_run_strray(["validate"], timeout=30))
+    result = json.loads(_run_xray(["validate"], timeout=30))
     if "error" in result:
         return json.dumps(result)
 
@@ -54,10 +116,10 @@ def strray_validate(args: dict, **kwargs) -> str:
     })
 
 
-# ── Tool: strray_codex_check ──────────────────────────────────
+# ── Tool: xray_codex_check ──────────────────────────────────
 
-def strray_codex_check(args: dict, **kwargs) -> str:
-    """Check code against StringRay codex rules.
+def xray_codex_check(args: dict, **kwargs) -> str:
+    """Check code against Xray codex rules.
 
     Uses bridge for real quality gate codex checks.
     Falls back to CLI if bridge unavailable.
@@ -93,7 +155,7 @@ def strray_codex_check(args: dict, **kwargs) -> str:
             "focus_areas": focus_areas or "all",
             "code_length": len(code),
             "note": "Bridge unavailable — basic analysis only. "
-                   "Full codex validation available via MCP: mcp_strray_enforcer_codex_enforcement",
+                   "Full codex validation available via MCP: mcp_xray_enforcer_codex_enforcement",
             "via": "static",
         })
 
@@ -109,7 +171,7 @@ def strray_codex_check(args: dict, **kwargs) -> str:
             "via": "bridge",
         })
 
-    result = json.loads(_run_strray(["health"], timeout=15))
+    result = json.loads(_run_xray(["health"], timeout=15))
     if "error" in result:
         return json.dumps(result)
 
@@ -121,10 +183,10 @@ def strray_codex_check(args: dict, **kwargs) -> str:
     })
 
 
-# ── Tool: strray_health ───────────────────────────────────────
+# ── Tool: xray_health ───────────────────────────────────────
 
-def strray_health(args: dict, **kwargs) -> str:
-    """Check StringRay framework health via bridge.
+def xray_health(args: dict, **kwargs) -> str:
+    """Check Xray framework health via bridge.
 
     Returns framework status, loaded components, version.
     """
@@ -141,13 +203,13 @@ def strray_health(args: dict, **kwargs) -> str:
         })
 
     # Fallback to CLI
-    return _run_strray(["health"], timeout=15)
+    return _run_xray(["health"], timeout=15)
 
 
-# ── Tool: strray_hooks ───────────────────────────────────────
+# ── Tool: xray_hooks ───────────────────────────────────────
 
-def strray_hooks(args: dict, **kwargs) -> str:
-    """Manage StringRay git hooks.
+def xray_hooks(args: dict, **kwargs) -> str:
+    """Manage Xray git hooks.
 
     Actions: install, uninstall, list, status
     Uses bridge for hook management when available.
@@ -174,7 +236,7 @@ def strray_hooks(args: dict, **kwargs) -> str:
 
     # Fallback: direct file-based hook management
     git_hooks_dir = Path(_get_project_root()) / ".git" / "hooks"
-    strray_hooks_dir = Path(_get_project_root()) / "hooks"
+    xray_hooks_dir = Path(_get_project_root()) / "hooks"
 
     if not git_hooks_dir.exists():
         return json.dumps({"error": "Not a git repository", "via": "fallback"})
@@ -183,19 +245,19 @@ def strray_hooks(args: dict, **kwargs) -> str:
         result = {"managed": [], "missing": [], "external": [], "stale": []}
         for hook_name in hooks:
             git_hook = git_hooks_dir / hook_name
-            strray_hook = strray_hooks_dir / hook_name
+            xray_hook = xray_hooks_dir / hook_name
             if not git_hook.exists():
                 result["missing"].append(hook_name)
             else:
                 try:
                     content = git_hook.read_text()[:500]
-                    if "StringRay" in content or "strray" in content or "run-hook.js" in content:
+                    if "Xray" in content or "StringRay" in content or "xray" in content or "strray" in content or "run-hook.js" in content:
                         result["managed"].append(hook_name)
                     else:
                         result["external"].append(hook_name)
                 except OSError:
                     result["external"].append(hook_name)
-            if not strray_hook.exists():
+            if not xray_hook.exists():
                 result["stale"].append(hook_name)
         return json.dumps({"status": "ok", "action": action, **result, "via": "fallback"})
 
@@ -203,7 +265,7 @@ def strray_hooks(args: dict, **kwargs) -> str:
         installed = []
         skipped = []
         for hook_name in hooks:
-            src = strray_hooks_dir / hook_name
+            src = xray_hooks_dir / hook_name
             dst = git_hooks_dir / hook_name
             if not src.exists():
                 skipped.append(hook_name)
@@ -212,7 +274,7 @@ def strray_hooks(args: dict, **kwargs) -> str:
                 if dst.exists():
                     try:
                         content = dst.read_text()[:500]
-                        if "StringRay" not in content and "strray" not in content:
+                        if "Xray" not in content and "StringRay" not in content and "xray" not in content and "strray" not in content:
                             dst.rename(dst.with_suffix(".strray-backup"))
                         else:
                             dst.unlink()
@@ -238,8 +300,8 @@ def strray_hooks(args: dict, **kwargs) -> str:
                 continue
             try:
                 content = dst.read_text()[:500]
-                is_strray = "StringRay" in content or "strray" in content or "run-hook.js" in content
-                if is_strray or dst.is_symlink():
+                is_xray = "Xray" in content or "StringRay" in content or "xray" in content or "strray" in content or "run-hook.js" in content
+                if is_xray or dst.is_symlink():
                     dst.unlink()
                     if backup.exists():
                         shutil.move(str(backup), str(dst))

package/dist/integrations/openclaw/README.md

@@ -1,12 +1,12 @@
 # OpenClaw Integration
 
-StringRay integration for OpenClaw - a self-hosted AI gateway that connects messaging platforms to AI coding agents.
+Xray integration for OpenClaw - a self-hosted AI gateway that connects messaging platforms to AI coding agents.
 
 ## Overview
 
-This integration allows StringRay to:
+This integration allows Xray to:
 - Connect to OpenClaw Gateway via WebSocket
-- Expose StringRay capabilities through OpenClaw skills
+- Expose Xray capabilities through OpenClaw skills
 - Send tool execution events to OpenClaw for real-time tracking
 - Receive commands from OpenClaw channels (WhatsApp, Telegram, Discord, etc.)
 
@@ -14,7 +14,7 @@ This integration allows StringRay to:
 
 ```
 ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
-│   User       │────▶│  OpenClaw    │────▶│   StringRay   │
+│   User       │────▶│  OpenClaw    │────▶│   Xray   │
 │  (WhatsApp,  │     │   Gateway    │     │    Skills    │
 │  Discord,    │     │              │     │              │
 │  Telegram)   │◀────│              │◀────│              │
@@ -37,7 +37,7 @@ npm install ws
 
 ### 2. Configure OpenClaw
 
-Create `.strray/config/openclaw.json`:
+Create `.xray/config/openclaw.json`:
 
 ```json
 {
@@ -82,11 +82,11 @@ const integration = await initializeOpenClawIntegration('/path/to/config.json',
 
 After installation, use these commands in any OpenClaw channel:
 
-- `/strray` - Show status
-- `/strray-analyze <file>` - Analyze code
-- `/strray-code <file>` - Code review
-- `/strray-file <file>` - Read file
-- `/strray-exec <command>` - Execute command
+- `/xray` - Show status
+- `/xray-analyze <file>` - Analyze code
+- `/xray-code <file>` - Code review
+- `/xray-file <file>` - Read file
+- `/xray-exec <command>` - Execute command
 
 ## Configuration
 
@@ -115,14 +115,14 @@ The integration exposes a local HTTP API on port 18431:
 
 ### stringray-orchestrator
 
-Main skill providing StringRay commands:
+Main skill providing Xray commands:
 
 ```markdown
-/strray                    - Show status
-/strray-analyze <file>    - Analyze code
-/strray-code <file>       - Code review
-/strray-file <file>       - Read file
-/strray-exec <command>    - Execute command
+/xray                    - Show status
+/xray-analyze <file>    - Analyze code
+/xray-code <file>       - Code review
+/xray-file <file>       - Read file
+/xray-exec <command>    - Execute command
 ```
 
 ## Documentation

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

@@ -0,0 +1,87 @@
+/**
+ * 0xRay API Server
+ *
+ * HTTP API server that OpenClaw skills call to invoke 0xRay capabilities.
+ * This is the bridge between OpenClaw skills and 0xRay.
+ *
+ * @version 1.0.0
+ * @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/api-server.js

@@ -12,7 +12,7 @@ import * as http from 'http';
 /**
  * 0xRay API Server
  */
-export class StringRayAPIServer {
+export class XrayAPIServer {
     server = null;
     config;
     agentInvoker = null;
@@ -51,7 +51,7 @@ export class StringRayAPIServer {
      */
     async start() {
         if (this.server) {
-            this.logger.warn('[StringRayAPIServer] Server already running');
+            this.logger.warn('[XrayAPIServer] Server already running');
             return;
         }
         return new Promise((resolve, reject) => {
@@ -59,13 +59,13 @@ export class StringRayAPIServer {
                 this.handleRequest(req, res);
             });
             this.server.on('error', (error) => {
-                this.logger.error('[StringRayAPIServer] Server error:', error);
+                this.logger.error('[XrayAPIServer] Server error:', error);
                 this.stats.errors++;
                 reject(error);
             });
             this.server.listen(this.config.port, this.config.host, () => {
                 this.stats.startedAt = Date.now();
-                this.logger.info(`[StringRayAPIServer] Listening on http://${this.config.host}:${this.config.port}`);
+                this.logger.info(`[XrayAPIServer] Listening on http://${this.config.host}:${this.config.port}`);
                 resolve();
             });
         });
@@ -77,7 +77,7 @@ export class StringRayAPIServer {
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {
-                    this.logger.info('[StringRayAPIServer] Server stopped');
+                    this.logger.info('[XrayAPIServer] Server stopped');
                     this.server = null;
                     resolve();
                 });
@@ -123,7 +123,7 @@ export class StringRayAPIServer {
             // to prevent cross-origin attacks where a malicious site could make
             // authenticated requests using the API key from a victim's browser.
             if (this.config.apiKey) {
-                this.logger.warn('[StringRayAPIServer] Security: API key is set with CORS enabled. ' +
+                this.logger.warn('[XrayAPIServer] Security: API key is set with CORS enabled. ' +
                     'Restricting Access-Control-Allow-Origin to localhost only. ' +
                     'Configure explicit allowed origins if cross-origin access is needed.');
                 const origin = req.headers.origin;
@@ -203,7 +203,7 @@ export class StringRayAPIServer {
             }
         }
         catch (error) {
-            this.logger.error(`[StringRayAPIServer] Error handling request:`, error);
+            this.logger.error(`[XrayAPIServer] Error handling request:`, error);
             this.stats.errors++;
             const errorMessage = error instanceof Error ? error.message : 'Internal server error';
             this.sendResponse(res, 500, { error: errorMessage });
@@ -384,6 +384,6 @@ export class StringRayAPIServer {
 /**
  * Factory function to create API server
  */
-export function createStringRayAPIServer(config) {
-    return new StringRayAPIServer(config);
+export function createXrayAPIServer(config) {
+    return new XrayAPIServer(config);
 }

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

@@ -0,0 +1,122 @@
+/**
+ * OpenClaw WebSocket Client
+ *
+ * Implements OpenClaw Gateway Protocol v3 with proper request/response handling,
+ * reconnection logic, and event management.
+ *
+ * @version 1.0.0
+ * @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,96 @@
+/**
+ * OpenClaw Configuration Loader
+ *
+ * Handles loading, validation, and management of OpenClaw integration configuration.
+ *
+ * @version 1.0.0
+ * @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/config.js

@@ -54,7 +54,7 @@ export class OpenClawConfigLoader {
     loadedAt = 0;
     constructor(configPath) {
         this.configPath = configPath ||
-            path.join(process.cwd(), '.strray', 'config', 'openclaw.json');
+            path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
     }
     /**
      * Load configuration from file with environment variable overrides