0xray 3.0.12 → 3.0.14

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

@@ -2,50 +2,7 @@
 
 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"})
@@ -53,28 +10,9 @@ def _run_xray(args, timeout=30):
         return json.dumps({"error": str(e)})
 
 
-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 ─────────────────────────────────────
+# ── Tool: strray_validate ─────────────────────────────────────
 
-def xray_validate(args: dict, **kwargs) -> str:
+def strray_validate(args: dict, **kwargs) -> str:
     """Run pre-commit validation on files using the framework.
 
     Uses bridge for real quality gate + processor pipeline.
@@ -103,7 +41,7 @@ def xray_validate(args: dict, **kwargs) -> str:
         })
 
     # Fallback to CLI
-    result = json.loads(_run_xray(["validate"], timeout=30))
+    result = json.loads(_run_strray(["validate"], timeout=30))
     if "error" in result:
         return json.dumps(result)
 
@@ -116,10 +54,10 @@ def xray_validate(args: dict, **kwargs) -> str:
     })
 
 
-# ── Tool: xray_codex_check ──────────────────────────────────
+# ── Tool: strray_codex_check ──────────────────────────────────
 
-def xray_codex_check(args: dict, **kwargs) -> str:
-    """Check code against Xray codex rules.
+def strray_codex_check(args: dict, **kwargs) -> str:
+    """Check code against StringRay codex rules.
 
     Uses bridge for real quality gate codex checks.
     Falls back to CLI if bridge unavailable.
@@ -155,7 +93,7 @@ def xray_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_xray_enforcer_codex_enforcement",
+                   "Full codex validation available via MCP: mcp_strray_enforcer_codex_enforcement",
             "via": "static",
         })
 
@@ -171,7 +109,7 @@ def xray_codex_check(args: dict, **kwargs) -> str:
             "via": "bridge",
         })
 
-    result = json.loads(_run_xray(["health"], timeout=15))
+    result = json.loads(_run_strray(["health"], timeout=15))
     if "error" in result:
         return json.dumps(result)
 
@@ -183,10 +121,10 @@ def xray_codex_check(args: dict, **kwargs) -> str:
     })
 
 
-# ── Tool: xray_health ───────────────────────────────────────
+# ── Tool: strray_health ───────────────────────────────────────
 
-def xray_health(args: dict, **kwargs) -> str:
-    """Check Xray framework health via bridge.
+def strray_health(args: dict, **kwargs) -> str:
+    """Check StringRay framework health via bridge.
 
     Returns framework status, loaded components, version.
     """
@@ -203,13 +141,13 @@ def xray_health(args: dict, **kwargs) -> str:
         })
 
     # Fallback to CLI
-    return _run_xray(["health"], timeout=15)
+    return _run_strray(["health"], timeout=15)
 
 
-# ── Tool: xray_hooks ───────────────────────────────────────
+# ── Tool: strray_hooks ───────────────────────────────────────
 
-def xray_hooks(args: dict, **kwargs) -> str:
-    """Manage Xray git hooks.
+def strray_hooks(args: dict, **kwargs) -> str:
+    """Manage StringRay git hooks.
 
     Actions: install, uninstall, list, status
     Uses bridge for hook management when available.
@@ -236,7 +174,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
 
     # Fallback: direct file-based hook management
     git_hooks_dir = Path(_get_project_root()) / ".git" / "hooks"
-    xray_hooks_dir = Path(_get_project_root()) / "hooks"
+    strray_hooks_dir = Path(_get_project_root()) / "hooks"
 
     if not git_hooks_dir.exists():
         return json.dumps({"error": "Not a git repository", "via": "fallback"})
@@ -245,19 +183,19 @@ def xray_hooks(args: dict, **kwargs) -> str:
         result = {"managed": [], "missing": [], "external": [], "stale": []}
         for hook_name in hooks:
             git_hook = git_hooks_dir / hook_name
-            xray_hook = xray_hooks_dir / hook_name
+            strray_hook = strray_hooks_dir / hook_name
             if not git_hook.exists():
                 result["missing"].append(hook_name)
             else:
                 try:
                     content = git_hook.read_text()[:500]
-                    if "Xray" in content or "StringRay" in content or "xray" in content or "strray" in content or "run-hook.js" in content:
+                    if "StringRay" 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 xray_hook.exists():
+            if not strray_hook.exists():
                 result["stale"].append(hook_name)
         return json.dumps({"status": "ok", "action": action, **result, "via": "fallback"})
 
@@ -265,7 +203,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
         installed = []
         skipped = []
         for hook_name in hooks:
-            src = xray_hooks_dir / hook_name
+            src = strray_hooks_dir / hook_name
             dst = git_hooks_dir / hook_name
             if not src.exists():
                 skipped.append(hook_name)
@@ -274,7 +212,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
                 if dst.exists():
                     try:
                         content = dst.read_text()[:500]
-                        if "Xray" not in content and "StringRay" not in content and "xray" not in content and "strray" not in content:
+                        if "StringRay" not in content and "strray" not in content:
                             dst.rename(dst.with_suffix(".strray-backup"))
                         else:
                             dst.unlink()
@@ -300,8 +238,8 @@ def xray_hooks(args: dict, **kwargs) -> str:
                 continue
             try:
                 content = dst.read_text()[:500]
-                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():
+                is_strray = "StringRay" in content or "strray" in content or "run-hook.js" in content
+                if is_strray 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
 
-Xray integration for OpenClaw - a self-hosted AI gateway that connects messaging platforms to AI coding agents.
+0xray integration for OpenClaw - a self-hosted AI gateway that connects messaging platforms to AI coding agents.
 
 ## Overview
 
-This integration allows Xray to:
+This integration allows 0xray to:
 - Connect to OpenClaw Gateway via WebSocket
-- Expose Xray capabilities through OpenClaw skills
+- Expose 0xray 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 Xray to:
 
 ```
 ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
-│   User       │────▶│  OpenClaw    │────▶│   Xray   │
+│   User       │────▶│  OpenClaw    │────▶│   0xray   │
 │  (WhatsApp,  │     │   Gateway    │     │    Skills    │
 │  Discord,    │     │              │     │              │
 │  Telegram)   │◀────│              │◀────│              │
@@ -37,7 +37,7 @@ npm install ws
 
 ### 2. Configure OpenClaw
 
-Create `.xray/config/openclaw.json`:
+Create `.strray/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:
 
-- `/xray` - Show status
-- `/xray-analyze <file>` - Analyze code
-- `/xray-code <file>` - Code review
-- `/xray-file <file>` - Read file
-- `/xray-exec <command>` - Execute command
+- `/strray` - Show status
+- `/strray-analyze <file>` - Analyze code
+- `/strray-code <file>` - Code review
+- `/strray-file <file>` - Read file
+- `/strray-exec <command>` - Execute command
 
 ## Configuration
 
@@ -113,9 +113,9 @@ The integration exposes a local HTTP API on port 18431:
 
 ## Skills
 
-### stringray-orchestrator
+### 0xray-orchestrator
 
-Main skill providing Xray commands:
+Main skill providing 0xray commands:
 
 ```markdown
 /xray                    - Show status

package/dist/integrations/openclaw/api-server.js

@@ -7,7 +7,6 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
-import { frameworkLogger } from '../../core/framework-logger.js';
 import * as crypto from 'crypto';
 import * as http from 'http';
 /**
@@ -27,6 +26,7 @@ export class XrayAPIServer {
         errors: 0,
     };
     responseTimes = [];
+    logger;
     constructor(config) {
         this.config = {
             port: config.port || 18431,
@@ -38,6 +38,7 @@ export class XrayAPIServer {
                 maxRequests: 100,
             },
         };
+        this.logger = console;
     }
     /**
      * Set the agent invoker
@@ -50,7 +51,7 @@ export class XrayAPIServer {
      */
     async start() {
         if (this.server) {
-            frameworkLogger.log('openclaw-api-server', 'Server already running', 'warning', {});
+            this.logger.warn('[XrayAPIServer] Server already running');
             return;
         }
         return new Promise((resolve, reject) => {
@@ -58,13 +59,13 @@ export class XrayAPIServer {
                 this.handleRequest(req, res);
             });
             this.server.on('error', (error) => {
-                frameworkLogger.log('openclaw-api-server', 'Server error:', '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();
-                frameworkLogger.log('openclaw-api-server', `Listening on http://${this.config.host}:${this.config.port}`, 'info', {});
+                this.logger.info(`[XrayAPIServer] Listening on http://${this.config.host}:${this.config.port}`);
                 resolve();
             });
         });
@@ -76,7 +77,7 @@ export class XrayAPIServer {
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {
-                    frameworkLogger.log('openclaw-api-server', 'Server stopped', 'info', {});
+                    this.logger.info('[XrayAPIServer] Server stopped');
                     this.server = null;
                     resolve();
                 });
@@ -122,7 +123,9 @@ export class XrayAPIServer {
             // 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) {
-                frameworkLogger.log('openclaw-api-server', '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.', 'warning', {});
+                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;
                 if (origin && ['http://localhost', 'http://127.0.0.1', 'http://localhost:3000',
                     'http://127.0.0.1:3000', 'http://localhost:5173', 'http://127.0.0.1:5173'].includes(origin)) {
@@ -200,7 +203,7 @@ export class XrayAPIServer {
             }
         }
         catch (error) {
-            frameworkLogger.log('openclaw-api-server', 'Error handling request:', 'error', { 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,4 +387,3 @@ export class XrayAPIServer {
 export function createXrayAPIServer(config) {
     return new XrayAPIServer(config);
 }
-//# sourceMappingURL=api-server.js.map

package/dist/integrations/openclaw/client.js

@@ -7,7 +7,6 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
-import { frameworkLogger } from '../../core/framework-logger.js';
 import { WebSocket } from 'ws';
 import * as crypto from 'crypto';
 import { isOpenClawResponse, isOpenClawEvent, OpenClawTimeoutError, OpenClawConnectionError, } from './types.js';
@@ -33,6 +32,7 @@ export class OpenClawClient {
         reconnects: 0,
         errors: 0,
     };
+    logger;
     constructor(config) {
         this.config = {
             gatewayUrl: config.gatewayUrl || 'ws://127.0.0.1:18789',
@@ -45,6 +45,8 @@ export class OpenClawClient {
             pingInterval: config.pingInterval ?? 30000,
             requestTimeout: config.requestTimeout ?? 30000,
         };
+        // Use console but can be replaced with proper logger
+        this.logger = console;
     }
     /**
      * Connect to OpenClaw Gateway
@@ -54,7 +56,7 @@ export class OpenClawClient {
     _handshakeTimeout = null;
     async connect() {
         if (this.state === 'connected' || this.state === 'authenticating') {
-            frameworkLogger.log('openclaw-client', 'Already connected or connecting', 'warning', {});
+            this.logger.warn('[OpenClawClient] Already connected or connecting');
             return;
         }
         this.setState('connecting');
@@ -69,7 +71,7 @@ export class OpenClawClient {
             try {
                 this.ws = new WebSocket(this.config.gatewayUrl);
                 this.ws.on('open', () => {
-                    frameworkLogger.log('openclaw-client', 'WebSocket connected, waiting for challenge...', 'info', {});
+                    this.logger.info('[OpenClawClient] WebSocket connected, waiting for challenge...');
                     this.handshakeResolve = resolve;
                     this.handshakeReject = reject;
                 });
@@ -78,21 +80,21 @@ export class OpenClawClient {
                     this.handleMessage(message);
                 });
                 this.ws.on('close', (code, reason) => {
-                    frameworkLogger.log('openclaw-client', `Connection closed: ${code} ${String(reason)}`, 'info', {});
+                    this.logger.info(`[OpenClawClient] Connection closed: ${code} ${String(reason)}`);
                     this.handleDisconnect(Number(code), String(reason));
                 });
                 this.ws.on('error', (error) => {
-                    frameworkLogger.log('openclaw-client', 'WebSocket error:', 'error', { error: error instanceof Error ? error.message : String(error) });
+                    this.logger.error('[OpenClawClient] WebSocket error:', error instanceof Error ? error.message : String(error));
                     this.stats.errors++;
                     if (this.state === 'connecting') {
                         reject(new OpenClawConnectionError(`Failed to connect to ${this.config.gatewayUrl}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined));
                     }
                 });
                 this.ws.on('ping', () => {
-                    frameworkLogger.log('openclaw-client', 'Received ping', 'debug', {});
+                    this.logger.debug('[OpenClawClient] Received ping');
                 });
                 this.ws.on('pong', () => {
-                    frameworkLogger.log('openclaw-client', 'Received pong', 'debug', {});
+                    this.logger.debug('[OpenClawClient] Received pong');
                 });
             }
             catch (error) {
@@ -105,7 +107,7 @@ export class OpenClawClient {
      * Disconnect from OpenClaw Gateway
      */
     disconnect() {
-        frameworkLogger.log('openclaw-client', 'Disconnecting...', 'info', {});
+        this.logger.info('[OpenClawClient] Disconnecting...');
         if (this._handshakeTimeout) {
             clearTimeout(this._handshakeTimeout);
             this._handshakeTimeout = null;
@@ -148,7 +150,7 @@ export class OpenClawClient {
             method,
             params,
         };
-        frameworkLogger.log('openclaw-client', `Sending request: ${method} (${id})`, 'debug', {});
+        this.logger.debug(`[OpenClawClient] Sending request: ${method} (${id})`);
         this.stats.requestsSent++;
         return new Promise((resolve, reject) => {
             // Set timeout
@@ -284,13 +286,13 @@ export class OpenClawClient {
             this.setState('authorized');
             this.startPingInterval();
             if (this.handshakeResolve) {
-                frameworkLogger.log('openclaw-client', 'Handshake complete (connect response ok)', 'info', {});
+                this.logger.info('[OpenClawClient] Handshake complete (connect response ok)');
                 this.handshakeResolve();
                 this.handshakeResolve = null;
                 this.handshakeReject = null;
             }
         }).catch((error) => {
-            frameworkLogger.log('openclaw-client', 'Handshake failed:', 'error', { error });
+            this.logger.error('[OpenClawClient] Handshake failed:', error);
             this.setState('error');
             if (this.handshakeReject) {
                 this.handshakeReject(error);
@@ -313,11 +315,11 @@ export class OpenClawClient {
                 this.handleEvent(frame);
             }
             else {
-                frameworkLogger.log('openclaw-client', 'Unknown frame type:', 'warning', { frame });
+                this.logger.warn('[OpenClawClient] Unknown frame type:', frame);
             }
         }
         catch (error) {
-            frameworkLogger.log('openclaw-client', 'Failed to parse message:', 'error', { error });
+            this.logger.error('[OpenClawClient] Failed to parse message:', error);
             this.stats.errors++;
         }
     }
@@ -338,17 +340,17 @@ export class OpenClawClient {
             }
         }
         else {
-            frameworkLogger.log('openclaw-client', 'Received response for unknown request:', 'warning', { requestId: frame.id });
+            this.logger.warn('[OpenClawClient] Received response for unknown request:', frame.id);
         }
     }
     /**
      * Handle event frame
      */
     handleEvent(frame) {
-        frameworkLogger.log('openclaw-client', 'Event:', 'debug', { event: frame.event });
+        this.logger.debug('[OpenClawClient] Event:', frame.event);
         // Handle specific events
         if (frame.event === 'connect.challenge') {
-            frameworkLogger.log('openclaw-client', 'Received challenge, sending handshake...', 'info', {});
+            this.logger.info('[OpenClawClient] Received challenge, sending handshake...');
             this.sendHandshake();
             return;
         }
@@ -373,7 +375,7 @@ export class OpenClawClient {
                     listener(frame.data);
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-client', 'Event listener error:', 'error', { error });
+                    this.logger.error('[OpenClawClient] Event listener error:', error);
                 }
             }
         }
@@ -385,7 +387,7 @@ export class OpenClawClient {
                     listener(frame.event, frame.data);
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-client', 'All-event listener error:', 'error', { error });
+                    this.logger.error('[OpenClawClient] All-event listener error:', error);
                 }
             }
         }
@@ -420,12 +422,12 @@ export class OpenClawClient {
         const delay = this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
         const maxDelay = 30000;
         const actualDelay = Math.min(delay, maxDelay);
-        frameworkLogger.log('openclaw-client', `Scheduling reconnect attempt ${this.reconnectAttempts}/${this.config.reconnectAttempts} in ${actualDelay}ms`, 'info', {});
+        this.logger.info(`[OpenClawClient] Scheduling reconnect attempt ${this.reconnectAttempts}/${this.config.reconnectAttempts} in ${actualDelay}ms`);
         this.setState('reconnecting');
         this.reconnectTimeout = setTimeout(() => {
             this.reconnectTimeout = null;
             this.connect().catch((error) => {
-                frameworkLogger.log('openclaw-client', 'Reconnection failed:', 'error', { error });
+                this.logger.error('[OpenClawClient] Reconnection failed:', error);
             });
         }, actualDelay);
     }
@@ -446,14 +448,14 @@ export class OpenClawClient {
         const previousState = this.state;
         this.state = newState;
         if (previousState !== newState) {
-            frameworkLogger.log('openclaw-client', `State: ${previousState} → ${newState}`, 'info', {});
+            this.logger.info(`[OpenClawClient] State: ${previousState} → ${newState}`);
             // Notify state listeners
             for (const listener of this.stateListeners) {
                 try {
                     listener(newState, previousState);
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-client', 'State listener error:', 'error', { error });
+                    this.logger.error('[OpenClawClient] State listener error:', error);
                 }
             }
         }
@@ -488,4 +490,3 @@ export class OpenClawClient {
 export function createOpenClawClient(config) {
     return new OpenClawClient(config);
 }
-//# sourceMappingURL=client.js.map

package/dist/integrations/openclaw/config.js

@@ -54,7 +54,7 @@ export class OpenClawConfigLoader {
     loadedAt = 0;
     constructor(configPath) {
         this.configPath = configPath ||
-            path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
+            path.join(process.cwd(), '.strray', 'config', 'openclaw.json');
     }
     /**
      * Load configuration from file with environment variable overrides
@@ -372,4 +372,3 @@ export const configLoader = new OpenClawConfigLoader();
 export function createConfigLoader(configPath) {
     return new OpenClawConfigLoader(configPath);
 }
-//# sourceMappingURL=config.js.map