0xray 2.1.2 → 2.1.4

package/dist/integrations/base/registry.js

@@ -93,7 +93,7 @@ export class IntegrationRegistry extends EventEmitter {
             name,
             version: integration.version,
         });
-        frameworkLogger.log("integration-registry", `Registered integration: ${name} v${integration.version}`, "info", { name, version: integration.version }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Registered integration: ${name} v${integration.version}`, "info", { name, version: integration.version });
     }
     /**
      * Unregister an integration from the registry
@@ -109,12 +109,12 @@ export class IntegrationRegistry extends EventEmitter {
         // If loaded, unload first
         if (this.loadedIntegrations.has(name)) {
             this.unload(name).catch((error) => {
-                frameworkLogger.log("integration-registry", `Error unloading integration '${name}' during unregister: ${error}`, "error", { name, error: String(error) }, this.jobId).catch(() => { });
+                frameworkLogger.log("integration-registry", `Error unloading integration '${name}' during unregister: ${error}`, "error", { name, error: String(error) });
             });
         }
         this.registeredIntegrations.delete(name);
         this.emitEvent("integration-unregistered", { name });
-        frameworkLogger.log("integration-registry", `Unregistered integration: ${name}`, "info", { name }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unregistered integration: ${name}`, "info", { name });
     }
     // ==========================================================================
     // Accessor Methods
@@ -184,7 +184,7 @@ export class IntegrationRegistry extends EventEmitter {
     async load(name, config) {
         // Check if already loaded
         if (this.loadedIntegrations.has(name)) {
-            frameworkLogger.log("integration-registry", `Integration '${name}' already loaded`, "warning", { name }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Integration '${name}' already loaded`, "warning", { name });
             return;
         }
         const integration = this.registeredIntegrations.get(name);
@@ -211,7 +211,7 @@ export class IntegrationRegistry extends EventEmitter {
                 name,
                 version: integration.version,
             });
-            frameworkLogger.log("integration-registry", `Loaded integration: ${name}`, "success", { name, version: integration.version }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Loaded integration: ${name}`, "success", { name, version: integration.version });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -239,7 +239,7 @@ export class IntegrationRegistry extends EventEmitter {
             // Remove from loaded map
             this.loadedIntegrations.delete(name);
             this.emitEvent("integration-unloaded", { name });
-            frameworkLogger.log("integration-registry", `Unloaded integration: ${name}`, "success", { name }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Unloaded integration: ${name}`, "success", { name });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -250,7 +250,7 @@ export class IntegrationRegistry extends EventEmitter {
                 error: errorMessage,
                 phase: "unload",
             }, error instanceof Error ? error : undefined);
-            frameworkLogger.log("integration-registry", `Error unloading integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage }, this.jobId).catch(() => { });
+            frameworkLogger.log("integration-registry", `Error unloading integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage });
         }
     }
     /**
@@ -261,14 +261,14 @@ export class IntegrationRegistry extends EventEmitter {
     async loadAll(config) {
         const entries = Object.entries(config.integrations);
         const enabledEntries = entries.filter(([, entry]) => entry.enabled);
-        frameworkLogger.log("integration-registry", `Loading ${enabledEntries.length} enabled integrations...`, "info", { total: entries.length, enabled: enabledEntries.length }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Loading ${enabledEntries.length} enabled integrations...`, "info", { total: entries.length, enabled: enabledEntries.length });
         const results = [];
         // Load all enabled integrations
         for (const [name, entry] of enabledEntries) {
             try {
                 // Check if registered
                 if (!this.registeredIntegrations.has(name)) {
-                    frameworkLogger.log("integration-registry", `Skipping '${name}': not registered`, "warning", { name }, this.jobId).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Skipping '${name}': not registered`, "warning", { name });
                     results.push({ name, success: false, error: "Not registered" });
                     continue;
                 }
@@ -282,7 +282,7 @@ export class IntegrationRegistry extends EventEmitter {
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 results.push({ name, success: false, error: errorMessage });
-                frameworkLogger.log("integration-registry", `Failed to load integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage }, this.jobId).catch(() => { });
+                frameworkLogger.log("integration-registry", `Failed to load integration '${name}': ${errorMessage}`, "error", { name, error: errorMessage });
             }
         }
         this.emitEvent("load-complete", {
@@ -293,14 +293,14 @@ export class IntegrationRegistry extends EventEmitter {
         });
         const succeeded = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;
-        frameworkLogger.log("integration-registry", `Load complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Load complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed });
     }
     /**
      * Unload all loaded integrations
      */
     async unloadAll() {
         const loadedNames = Array.from(this.loadedIntegrations.keys());
-        frameworkLogger.log("integration-registry", `Unloading ${loadedNames.length} integrations...`, "info", { count: loadedNames.length }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unloading ${loadedNames.length} integrations...`, "info", { count: loadedNames.length });
         const results = [];
         // Unload all loaded integrations
         for (const name of loadedNames) {
@@ -321,7 +321,7 @@ export class IntegrationRegistry extends EventEmitter {
         });
         const succeeded = results.filter((r) => r.success).length;
         const failed = results.filter((r) => !r.success).length;
-        frameworkLogger.log("integration-registry", `Unload complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", `Unload complete: ${succeeded} succeeded, ${failed} failed`, failed > 0 ? "warning" : "success", { succeeded, failed });
     }
     // ==========================================================================
     // Health and Stats Methods
@@ -427,7 +427,7 @@ export class IntegrationRegistry extends EventEmitter {
                 this.registeredIntegrations.delete(name);
             }
         }
-        frameworkLogger.log("integration-registry", "Cleared non-loaded integrations", "info", { cleared: names.length - this.loadedIntegrations.size }, this.jobId).catch(() => { });
+        frameworkLogger.log("integration-registry", "Cleared non-loaded integrations", "info", { cleared: names.length - this.loadedIntegrations.size });
     }
     /**
      * Get registry statistics
@@ -494,7 +494,7 @@ export async function discoverIntegrations(integrationsPath) {
         const path = await import("path");
         // Check if directory exists
         if (!fs.existsSync(integrationsPath)) {
-            frameworkLogger.log("integration-registry", `Integrations directory not found: ${integrationsPath}`, "warning", { path: integrationsPath }).catch(() => { });
+            frameworkLogger.log("integration-registry", `Integrations directory not found: ${integrationsPath}`, "warning", { path: integrationsPath });
             return discovered;
         }
         // Read directory contents
@@ -533,18 +533,18 @@ export async function discoverIntegrations(integrationsPath) {
                         path: indexPath,
                         module,
                     });
-                    frameworkLogger.log("integration-registry", `Discovered integration: ${name}`, "info", { name, path: indexPath }).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Discovered integration: ${name}`, "info", { name, path: indexPath });
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    frameworkLogger.log("integration-registry", `Failed to load integration from ${indexPath}: ${errorMessage}`, "warning", { path: indexPath, error: errorMessage }).catch(() => { });
+                    frameworkLogger.log("integration-registry", `Failed to load integration from ${indexPath}: ${errorMessage}`, "warning", { path: indexPath, error: errorMessage });
                 }
             }
         }
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        frameworkLogger.log("integration-registry", `Error during integration discovery: ${errorMessage}`, "error", { error: errorMessage }).catch(() => { });
+        frameworkLogger.log("integration-registry", `Error during integration discovery: ${errorMessage}`, "error", { error: errorMessage });
     }
     return discovered;
 }
@@ -595,7 +595,7 @@ export async function autoRegisterIntegrations(registry, integrationsPath) {
         catch (error) {
             // Skip integrations that fail to register (already registered, etc.)
             const errorMessage = error instanceof Error ? error.message : String(error);
-            frameworkLogger.log("integration-registry", `Failed to register integration '${d.name}': ${errorMessage}`, "warning", { name: d.name, error: errorMessage }).catch(() => { });
+            frameworkLogger.log("integration-registry", `Failed to register integration '${d.name}': ${errorMessage}`, "warning", { name: d.name, error: errorMessage });
         }
     }
     return registered;

package/dist/integrations/grok/grok-cli.js

@@ -31,50 +31,50 @@ export async function installForGrokCLI(options = {}) {
     ];
     let sourceDir = possibleSources.find(p => fs.existsSync(p));
     if (!sourceDir) {
-        console.error('[Grok] Could not locate the 0xray Grok plugin inside the package.');
+        frameworkLogger.log('grok-cli', 'Could not locate the 0xray Grok plugin inside the package.', 'error', {});
         return;
     }
     if (options.dryRun) {
-        console.log(`[Grok] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
+        frameworkLogger.log('grok-cli', `Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`, 'info', {});
         return;
     }
     try {
         if (fs.existsSync(targetPluginDir) && !options.force) {
-            console.log('[Grok] 0xray Grok plugin is already installed.');
-            console.log('Use --force to reinstall.');
+            frameworkLogger.log('grok-cli', '0xray Grok plugin is already installed.', 'info', {});
+            frameworkLogger.log('grok-cli', 'Use --force to reinstall.', 'info', {});
             return;
         }
         fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
         frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
-        console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
+        frameworkLogger.log('grok-cli', `Copied Grok plugin to ${targetPluginDir}`, 'info', {});
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
-            console.log('\x1b[32m✓ Auto-trusted the 0xray plugin with Grok CLI\x1b[0m');
+            frameworkLogger.log('grok-cli', 'Auto-trusted the 0xray plugin with Grok CLI', 'info', {});
         }
         catch {
-            console.log('\nPlease run this command to fully trust the plugin:');
-            console.log(`  grok plugins trust "${targetPluginDir}"`);
+            frameworkLogger.log('grok-cli', 'Please run this command to fully trust the plugin:', 'info', {});
+            frameworkLogger.log('grok-cli', `  grok plugins trust "${targetPluginDir}"`, 'info', {});
         }
         // Register MCP servers via grok mcp add (most reliable mechanism)
         const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
         const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
         try {
-            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            console.log('\x1b[32m✓ Registered xray MCP servers with Grok CLI\x1b[0m');
+            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "XRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            frameworkLogger.log('grok-cli', 'Registered xray MCP servers with Grok CLI', 'info', {});
         }
         catch {
-            console.log('\nCould not auto-register MCP servers. Run manually:');
-            console.log(`  grok mcp add xray-governance --command node --args "${govMcpPath}"`);
-            console.log(`  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`);
+            frameworkLogger.log('grok-cli', 'Could not auto-register MCP servers. Run manually:', 'info', {});
+            frameworkLogger.log('grok-cli', `  grok mcp add xray-governance --command node --args "${govMcpPath}"`, 'info', {});
+            frameworkLogger.log('grok-cli', `  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`, 'info', {});
         }
-        console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
-        console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
+        frameworkLogger.log('grok-cli', '0xRay is now installed as a first-class Grok CLI plugin!', 'info', {});
+        frameworkLogger.log('grok-cli', 'Restart Grok or run `grok` to load the new hooks and MCP servers.', 'info', {});
     }
     catch (err) {
         frameworkLogger.log('grok-integration', 'install-error', 'error', { error: err.message });
-        console.error('Failed to install Grok plugin:', err.message);
+        frameworkLogger.log('grok-cli', 'Failed to install Grok plugin:', 'error', { error: err.message });
     }
     frameworkLogger.log('grok-integration', 'install-complete', 'info', {});
 }

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -16,7 +16,7 @@ function findGovernanceCore() {
   const here = path.dirname(new URL(import.meta.url).pathname);
 
   // Priority: explicit dev root
-  const devRoot = process.env.STRRAY_ROOT;
+  const devRoot = ;
   if (devRoot) {
     const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
     if (fs.existsSync(devCandidate)) return devCandidate;

package/dist/integrations/hermes-agent/bridge.mjs

@@ -53,7 +53,7 @@ let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
 function findProjectRoot() {
-  const envHome = process.env.STRRAY_HOME;
+  const envHome = process.env.XRAY_HOME;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
   const candidates = [

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

@@ -28,7 +28,6 @@ export declare class XrayAPIServer {
     private apiKey;
     private stats;
     private responseTimes;
-    private logger;
     constructor(config: XrayAPIServerConfig);
     /**
      * Set the agent invoker

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

@@ -7,6 +7,7 @@
  * @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';
 /**
@@ -26,7 +27,6 @@ export class XrayAPIServer {
         errors: 0,
     };
     responseTimes = [];
-    logger;
     constructor(config) {
         this.config = {
             port: config.port || 18431,
@@ -38,7 +38,6 @@ export class XrayAPIServer {
                 maxRequests: 100,
             },
         };
-        this.logger = console;
     }
     /**
      * Set the agent invoker
@@ -51,7 +50,7 @@ export class XrayAPIServer {
      */
     async start() {
         if (this.server) {
-            this.logger.warn('[XrayAPIServer] Server already running');
+            frameworkLogger.log('openclaw-api-server', 'Server already running', 'warning', {});
             return;
         }
         return new Promise((resolve, reject) => {
@@ -59,13 +58,13 @@ export class XrayAPIServer {
                 this.handleRequest(req, res);
             });
             this.server.on('error', (error) => {
-                this.logger.error('[XrayAPIServer] Server error:', error);
+                frameworkLogger.log('openclaw-api-server', 'Server error:', 'error', { error });
                 this.stats.errors++;
                 reject(error);
             });
             this.server.listen(this.config.port, this.config.host, () => {
                 this.stats.startedAt = Date.now();
-                this.logger.info(`[XrayAPIServer] Listening on http://${this.config.host}:${this.config.port}`);
+                frameworkLogger.log('openclaw-api-server', `Listening on http://${this.config.host}:${this.config.port}`, 'info', {});
                 resolve();
             });
         });
@@ -77,7 +76,7 @@ export class XrayAPIServer {
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {
-                    this.logger.info('[XrayAPIServer] Server stopped');
+                    frameworkLogger.log('openclaw-api-server', 'Server stopped', 'info', {});
                     this.server = null;
                     resolve();
                 });
@@ -123,9 +122,7 @@ 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) {
-                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.');
+                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', {});
                 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)) {
@@ -203,7 +200,7 @@ export class XrayAPIServer {
             }
         }
         catch (error) {
-            this.logger.error(`[XrayAPIServer] Error handling request:`, error);
+            frameworkLogger.log('openclaw-api-server', 'Error handling request:', 'error', { error });
             this.stats.errors++;
             const errorMessage = error instanceof Error ? error.message : 'Internal server error';
             this.sendResponse(res, 500, { error: errorMessage });

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

@@ -22,7 +22,6 @@ export declare class OpenClawClient {
     private reconnectTimeout;
     private pingInterval;
     private stats;
-    private logger;
     constructor(config: OpenClawClientConfig);
     /**
      * Connect to OpenClaw Gateway

package/dist/integrations/openclaw/client.js

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

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

@@ -46,7 +46,6 @@ export declare class OpenClawHooksManager {
     private initialized;
     private toolBeforeCallbacks;
     private toolAfterCallbacks;
-    private logger;
     private eventQueue;
     private maxQueueSize;
     private isFlushing;