0xray 3.0.12 → 3.1.0

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,25 +10,6 @@ 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 ─────────────────────────────────────
 
 def xray_validate(args: dict, **kwargs) -> str:
@@ -251,7 +189,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
             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 "Xray" 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)
@@ -274,8 +212,8 @@ 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:
-                            dst.rename(dst.with_suffix(".strray-backup"))
+                        if "Xray" not in content and "xray" not in content and "strray" not in content:
+                            dst.rename(dst.with_suffix(".xray-backup"))
                         else:
                             dst.unlink()
                     except OSError:
@@ -295,12 +233,12 @@ def xray_hooks(args: dict, **kwargs) -> str:
         restored = []
         for hook_name in hooks:
             dst = git_hooks_dir / hook_name
-            backup = dst.with_suffix(".strray-backup")
+            backup = dst.with_suffix(".xray-backup")
             if not dst.exists():
                 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
+                is_xray = "Xray" 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():

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

package/dist/integrations/openclaw/hooks/{xray-hooks.js → strray-hooks.js}

@@ -7,7 +7,6 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
-import { frameworkLogger } from '../../../core/framework-logger.js';
 /**
  * OpenClaw Hooks Manager
  */
@@ -17,6 +16,7 @@ export class OpenClawHooksManager {
     initialized = false;
     toolBeforeCallbacks = new Set();
     toolAfterCallbacks = new Set();
+    logger;
     // Offline event buffering
     eventQueue = [];
     maxQueueSize = 100;
@@ -30,6 +30,7 @@ export class OpenClawHooksManager {
             includeResult: config.includeResult ?? true,
             ...(config.toolFilter ? { toolFilter: config.toolFilter } : {}),
         };
+        this.logger = console;
     }
     /**
      * Set the OpenClaw client
@@ -42,19 +43,19 @@ export class OpenClawHooksManager {
      */
     async initialize() {
         if (this.initialized) {
-            frameworkLogger.log('openclaw-hooks', 'Already initialized', 'warning', {});
+            this.logger.warn('[OpenClawHooks] Already initialized');
             return;
         }
         if (!this.config.enabled) {
-            frameworkLogger.log('openclaw-hooks', 'Hooks disabled in configuration', 'info', {});
+            this.logger.info('[OpenClawHooks] Hooks disabled in configuration');
             return;
         }
-        frameworkLogger.log('openclaw-hooks', 'Initializing 0xRay tool hooks...', 'info', {});
+        this.logger.info('[OpenClawHooks] Initializing 0xRay tool hooks...');
         // Register with 0xRay's event system
         // The integration should call registerToolBefore and registerToolAfter
         // to connect to 0xRay's actual tool execution events
         this.initialized = true;
-        frameworkLogger.log('openclaw-hooks', 'Hooks initialized successfully', 'info', {});
+        this.logger.info('[OpenClawHooks] Hooks initialized successfully');
     }
     /**
      * Register a callback for tool.before events
@@ -120,13 +121,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.before:', 'error', { error });
+                    this.logger.error('[OpenClawHooks] Callback error in tool.before:', error);
                 }
             }
-            frameworkLogger.log('openclaw-hooks', `tool.before: ${event.toolName}`, 'debug', {});
+            this.logger.debug(`[OpenClawHooks] tool.before: ${event.toolName}`);
         }
         catch (error) {
-            frameworkLogger.log('openclaw-hooks', 'Error handling tool.before:', 'error', { error });
+            this.logger.error('[OpenClawHooks] Error handling tool.before:', error);
         }
     }
     /**
@@ -170,13 +171,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.after:', 'error', { error });
+                    this.logger.error('[OpenClawHooks] Callback error in tool.after:', error);
                 }
             }
-            frameworkLogger.log('openclaw-hooks', `tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`, 'debug', {});
+            this.logger.debug(`[OpenClawHooks] tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`);
         }
         catch (error) {
-            frameworkLogger.log('openclaw-hooks', 'Error handling tool.after:', 'error', { error });
+            this.logger.error('[OpenClawHooks] Error handling tool.after:', error);
         }
     }
     /**
@@ -186,10 +187,10 @@ export class OpenClawHooksManager {
         if (this.eventQueue.length >= this.maxQueueSize) {
             // Remove oldest event to make room
             this.eventQueue.shift();
-            frameworkLogger.log('openclaw-hooks', 'Event queue full, dropping oldest event', 'warning', {});
+            this.logger.warn('[OpenClawHooks] Event queue full, dropping oldest event');
         }
         this.eventQueue.push({ type, event });
-        frameworkLogger.log('openclaw-hooks', `Queued ${type} event (queue size: ${this.eventQueue.length})`, 'debug', {});
+        this.logger.debug(`[OpenClawHooks] Queued ${type} event (queue size: ${this.eventQueue.length})`);
     }
     /**
      * Flush queued events to OpenClaw Gateway
@@ -212,12 +213,12 @@ export class OpenClawHooksManager {
                     }
                 }
                 catch (error) {
-                    frameworkLogger.log('openclaw-hooks', `Failed to send queued ${item.type} event:`, 'error', { error });
+                    this.logger.error(`[OpenClawHooks] Failed to send queued ${item.type} event:`, error);
                     // Re-queue failed events
                     this.eventQueue.push(item);
                 }
             }
-            frameworkLogger.log('openclaw-hooks', `Flushed ${queue.length} queued events`, 'info', {});
+            this.logger.info(`[OpenClawHooks] Flushed ${queue.length} queued events`);
         }
         finally {
             this.isFlushing = false;
@@ -234,7 +235,7 @@ export class OpenClawHooksManager {
      */
     async handleReconnect() {
         if (this.eventQueue.length > 0) {
-            frameworkLogger.log('openclaw-hooks', `Client reconnected, flushing ${this.eventQueue.length} queued events...`, 'info', {});
+            this.logger.info(`[OpenClawHooks] Client reconnected, flushing ${this.eventQueue.length} queued events...`);
             await this.flushEventQueue();
         }
     }
@@ -247,7 +248,7 @@ export class OpenClawHooksManager {
         this.eventQueue.length = 0;
         this.initialized = false;
         this.client = null;
-        frameworkLogger.log('openclaw-hooks', `Hooks shutdown complete (${queuedCount} queued events dropped)`, 'info', {});
+        this.logger.info(`[OpenClawHooks] Hooks shutdown complete (${queuedCount} queued events dropped)`);
     }
     /**
      * Check if hooks are initialized
@@ -277,4 +278,3 @@ export class OpenClawHooksManager {
 export function createOpenClawHooksManager(config) {
     return new OpenClawHooksManager(config);
 }
-//# sourceMappingURL=xray-hooks.js.map

package/dist/integrations/openclaw/index.js

@@ -12,9 +12,8 @@ import { OpenClawClient } from './client.js';
 import { XrayAPIServer } from './api-server.js';
 import { initializeGovernanceIntegration } from '../governance/index.js';
 import { featuresConfigLoader } from '../../core/features-config.js';
-import { OpenClawHooksManager } from './hooks/xray-hooks.js';
+import { OpenClawHooksManager } from './hooks/strray-hooks.js';
 import { mcpClientManager } from '../../mcps/mcp-client.js';
-import { beforeToolHook, afterToolHook } from '../enforcement-gate.js';
 /**
  * Main OpenClaw Integration class
  * Extends BaseIntegration for consistent lifecycle management
@@ -125,12 +124,6 @@ export class OpenClawIntegration extends BaseIntegration {
         this.mcpToolBeforeUnsubscribe = await mcpClientManager.onToolEvent('tool.before', async (event) => {
             const toolEvent = event;
             try {
-                // Run enforcement gate
-                const gateResult = await beforeToolHook(toolEvent.toolName, toolEvent.args);
-                if (gateResult.blocked) {
-                    await this.log('warning', `Enforcement blocked: ${toolEvent.toolName} (${gateResult.violations.length} violations)`);
-                }
-                // Forward to OpenClaw hook manager (existing behavior)
                 await this.hooksManager.onToolBefore({
                     toolName: toolEvent.toolName,
                     toolId: `${toolEvent.serverName}:${toolEvent.toolName}`,
@@ -138,13 +131,6 @@ export class OpenClawIntegration extends BaseIntegration {
                     duration: 0,
                     timestamp: toolEvent.timestamp,
                     agent: toolEvent.serverName,
-                    enforcement: {
-                        allowed: gateResult.allowed,
-                        blocked: gateResult.blocked,
-                        violations: gateResult.violations,
-                        processed: false,
-                        governanceTriggered: false,
-                    },
                 });
             }
             catch (error) {
@@ -155,8 +141,6 @@ export class OpenClawIntegration extends BaseIntegration {
         this.mcpToolAfterUnsubscribe = await mcpClientManager.onToolEvent('tool.after', async (event) => {
             const toolEvent = event;
             try {
-                // Run enforcement after-hook
-                const afterResult = await afterToolHook(toolEvent.toolName, toolEvent.args, toolEvent.result, toolEvent.error || null);
                 const afterEvent = {
                     toolName: toolEvent.toolName,
                     toolId: `${toolEvent.serverName}:${toolEvent.toolName}`,
@@ -169,13 +153,6 @@ export class OpenClawIntegration extends BaseIntegration {
                     afterEvent.result = toolEvent.result;
                 if (toolEvent.error !== undefined)
                     afterEvent.error = toolEvent.error;
-                afterEvent.enforcement = {
-                    allowed: !afterResult.governanceTriggered || true,
-                    blocked: false,
-                    violations: afterResult.violations,
-                    processed: afterResult.processed,
-                    governanceTriggered: afterResult.governanceTriggered,
-                };
                 await this.hooksManager.onToolAfter(afterEvent);
             }
             catch (error) {
@@ -371,5 +348,4 @@ export * from './types.js';
 export * from './config.js';
 export * from './client.js';
 export * from './api-server.js';
-export { OpenClawHooksManager } from './hooks/xray-hooks.js';
-//# sourceMappingURL=index.js.map
+export { OpenClawHooksManager } from './hooks/strray-hooks.js';