0xray 2.0.0 → 2.0.1

package/dist/integrations/governance/types.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Inference Governance Integration Types
+ *
+ * Type definitions for the chrono-warp-drive Dynamo governance endpoint integration.
+ * Provides external governance checking for inference-driven proposals.
+ *
+ * @version 1.0.0
+ * @since 2026-05-11
+ */
+import type { InferenceProposal } from '../../inference/inference-cycle.js';
+/**
+ * Governance check request payload
+ * Matches the Dynamo /governance endpoint format
+ */
+export interface GovernanceCheckRequest {
+    proposalId: string;
+    proposalText: string;
+    codeDiff?: string;
+    agentReviews: string[];
+    historicalSignalIds?: string[];
+}
+/**
+ * Governance check response from Dynamo endpoint
+ */
+export interface GovernanceCheckResponse {
+    success: boolean;
+    proposalId: string;
+    governanceIsotopeId: string;
+    resonanceScore: number;
+    isotopicRatio: number;
+    vortexVolume: number;
+    historicalCoherence: number;
+    recommendation: 'PASS' | 'NEEDS_REVISION' | 'REJECT';
+    confidence: number;
+    voteWeight: number;
+    reasons: string[];
+}
+/**
+ * Governance integration configuration
+ */
+export interface GovernanceIntegrationConfig {
+    /** Whether the integration is enabled */
+    enabled: boolean;
+    /** Governance endpoint URL */
+    endpointUrl: string;
+    /** Request timeout in milliseconds */
+    requestTimeoutMs: number;
+    /** Minimum confidence threshold for proposals */
+    minConfidenceThreshold: number;
+    /** Decision logic configuration */
+    decisionLogic: {
+        /** Minimum confidence for PASS recommendation */
+        passConfidenceMin: number;
+        /** Maximum confidence for NEEDS_REVISION (below this is PASS, above is REJECT) */
+        revisionConfidenceMax: number;
+        /** Multiplier for vote weight from governance */
+        voteWeightMultiplier: number;
+    };
+}
+/**
+ * Default governance configuration
+ */
+export declare const DEFAULT_GOVERNANCE_CONFIG: GovernanceIntegrationConfig;
+/**
+ * Solar activity levels from NOAA GOES data
+ */
+export type SolarActivityLevel = 'quiet' | 'moderate' | 'active' | 'storm';
+/**
+ * Solar context returned by govern_with_solar
+ */
+export interface SolarContext {
+    /** Current solar activity level */
+    solarActivityLevel: SolarActivityLevel;
+    /** Solar isotopic resonance score (0-1) — canonical field */
+    solarIsotopicResonance: number;
+    /** Alias for backward compatibility */
+    solarResonance?: number;
+    /** Modifier applied to vote weight based on solar activity */
+    solarActivityModifier: number;
+    /** Human-readable recommendation based on solar conditions */
+    recommendation: string;
+}
+/**
+ * Solar-enhanced governance check request
+ */
+export interface SolarGovernanceCheckRequest {
+    /** The proposal text to evaluate */
+    proposal: string;
+    /** Starting vote weight (0.5 - 1.5) */
+    baseVoteWeight?: number;
+    /** Whether to share the governance result publicly */
+    sharePublicly?: boolean;
+    /** Spectral quality score for resonance analysis */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced governance check response
+ */
+export interface SolarGovernanceCheckResponse {
+    /** Original recommendation before solar adjustments */
+    originalRecommendation: string;
+    /** Real-time solar context from NOAA GOES */
+    solarContext: SolarContext;
+    /** Vote weight after solar adjustment */
+    adjustedVoteWeight: number;
+    /** Final recommendation with solar warning appended if applicable */
+    finalRecommendation: string;
+    /** Confidence adjustment applied due to solar activity */
+    confidenceAdjustment: number;
+    /** Trinitarium Moral Overlay — moral alignment score (0-1) */
+    trinitariumMoralScore?: number | undefined;
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    trinitariumGematriaFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+    /** Server-side authoritative recommendation */
+    recommendation?: string;
+    /** Confidence score from governance */
+    confidence?: number;
+    /** Resonance score */
+    resonanceScore?: number;
+    /** Structural resonance metric */
+    structuralResonance?: number;
+    /** Proximity metric */
+    proximity?: number;
+    /** Phase alignment metric */
+    phaseAlignment?: number;
+    /** Vortex alignment metric */
+    vortexAlignment?: number;
+    /** Synchronization metric */
+    synchronization?: number;
+    /** Signal timing indicator */
+    signalTiming?: string;
+    /** Human-readable hammer reason */
+    hammerReason?: string;
+    /** Whether neural context was used */
+    neuralContextUsed?: boolean;
+    /** Spectral quality score */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced vote result — extends standard vote with solar context
+ */
+export interface SolarGovernanceVoteResult extends GovernanceVoteResult {
+    /** Solar context that influenced the decision */
+    solarContext: SolarContext;
+    /** Confidence adjustment from solar activity */
+    solarConfidenceAdjustment: number;
+}
+/**
+ * Governance vote result after applying decision logic
+ */
+export interface GovernanceVoteResult {
+    /** Final vote decision */
+    vote: 'YES' | 'NO' | 'ABSTAIN';
+    /** Vote weight (affected by governance confidence) */
+    weight: number;
+    /** Human-readable reason for the vote */
+    reason: string;
+    /** Raw governance response for audit trail */
+    governanceResponse: GovernanceCheckResponse;
+    /** Whether the proposal passed governance */
+    passed: boolean;
+    /** Moral-Numerological Tension from Trinitarium Moral Overlay */
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    moralScore?: number | undefined;
+    moralFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+}
+/**
+ * Batch governance check for multiple proposals
+ */
+export interface BatchGovernanceCheck {
+    proposals: InferenceProposal[];
+    results: GovernanceVoteResult[];
+    batchId: string;
+    timestamp: number;
+}
+/**
+ * HTTP client configuration
+ */
+export interface GovernanceClientConfig {
+    baseUrl: string;
+    timeoutMs: number;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Client statistics
+ */
+export interface GovernanceClientStats {
+    requestsTotal: number;
+    requestsSucceeded: number;
+    requestsFailed: number;
+    averageResponseTimeMs: number;
+    lastRequestAt?: number;
+    errors: number;
+}
+/**
+ * Governance error codes
+ */
+export declare enum GovernanceErrorCode {
+    REQUEST_FAILED = "REQUEST_FAILED",
+    TIMEOUT = "TIMEOUT",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONFIG_INVALID = "CONFIG_INVALID",
+    NOT_INITIALIZED = "NOT_INITIALIZED"
+}
+/**
+ * Base governance error
+ */
+export declare class GovernanceError extends Error {
+    code: GovernanceErrorCode;
+    recoverable: boolean;
+    context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: GovernanceErrorCode, recoverable: boolean, context?: Record<string, unknown> | undefined);
+}
+/**
+ * Request timeout error
+ */
+export declare class GovernanceTimeoutError extends GovernanceError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Network error
+ */
+export declare class GovernanceNetworkError extends GovernanceError {
+    constructor(url: string, originalError: Error);
+}
+/**
+ * Type guard for valid governance response
+ */
+export declare function isValidGovernanceResponse(response: unknown): response is GovernanceCheckResponse;
+/**
+ * Type guard for governance error
+ */
+export declare function isGovernanceError(error: unknown): error is GovernanceError;

package/dist/integrations/grok/grok-cli.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Grok CLI Integration for StringRay / 0xRay
+ *
+ * This module provides the integration points for using 0xRay with the official Grok CLI.
+ *
+ * Primary mechanism: MCP (Model Context Protocol)
+ * Grok CLI can consume MCP servers. By registering the 0xRay MCP servers,
+ * users get access to Governance, skills, and other capabilities directly inside Grok conversations.
+ *
+ * Recommended registration (via npx or Grok's tooling):
+ *   npx 0xray grok install
+ *
+ * This will help configure the user's Grok CLI to include the following MCP servers:
+ * - governance (Dynamo Solar SSOT + real skill deliberation)
+ * - All knowledge-skill MCP servers (code-review, security-audit, researcher, etc.)
+ */
+export interface GrokInstallOptions {
+    force?: boolean;
+    dryRun?: boolean;
+}
+export declare function installForGrokCLI(options?: GrokInstallOptions): Promise<void>;
+declare const _default: {
+    installForGrokCLI: typeof installForGrokCLI;
+};
+export default _default;

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

@@ -524,7 +524,7 @@ def _record_tool_outcome(tool_name: str, args: dict, success: bool):
 # ── Inference tuning (auto-calibration) ────────────────────────
 
 def _run_inference_tune():
-    """Shell out to strray-ai inference:tuner --run-once.
+    """Shell out to 0xray inference:tuner --run-once.
 
     Runs in a background thread so it doesn't block the tool call pipeline.
     The tuner reads routing outcomes, runs the analytics pipeline, and

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 { StringRayAPIServerConfig, 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 StringRayAPIServer {
+    private server;
+    private config;
+    private agentInvoker;
+    private apiKey;
+    private stats;
+    private responseTimes;
+    private logger;
+    constructor(config: StringRayAPIServerConfig);
+    /**
+     * 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 createStringRayAPIServer(config: StringRayAPIServerConfig): StringRayAPIServer;

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/hooks/strray-hooks.d.ts

@@ -0,0 +1,124 @@
+/**
+ * OpenClaw 0xRay Hooks Integration
+ *
+ * Integrates OpenClaw with 0xRay's tool.before and tool.after hooks
+ * to send tool execution events to OpenClaw Gateway.
+ *
+ * @version 1.0.0
+ * @since 2026-03-14
+ */
+import { OpenClawClient } from '../client.js';
+/**
+ * Hooks configuration
+ */
+export interface OpenClawHooksConfig {
+    enabled: boolean;
+    toolBefore: boolean;
+    toolAfter: boolean;
+    includeArgs: boolean;
+    includeResult: boolean;
+    toolFilter?: string[];
+}
+/**
+ * 0xRay tool event
+ */
+export interface StringRayToolEvent {
+    toolName: string;
+    toolId: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    duration: number;
+    timestamp: number;
+    sessionId?: string;
+    agent?: string;
+}
+/**
+ * Hook event callback type
+ */
+export type ToolEventCallback = (event: StringRayToolEvent) => void | Promise<void>;
+/**
+ * OpenClaw Hooks Manager
+ */
+export declare class OpenClawHooksManager {
+    private client;
+    private config;
+    private initialized;
+    private toolBeforeCallbacks;
+    private toolAfterCallbacks;
+    private logger;
+    private eventQueue;
+    private maxQueueSize;
+    private isFlushing;
+    constructor(config: OpenClawHooksConfig);
+    /**
+     * Set the OpenClaw client
+     */
+    setClient(client: OpenClawClient): void;
+    /**
+     * Initialize hooks - registers with 0xRay's event system
+     */
+    initialize(): Promise<void>;
+    /**
+     * Register a callback for tool.before events
+     * Call this to connect to 0xRay's tool.before event system
+     */
+    registerToolBefore(callback: ToolEventCallback): void;
+    /**
+     * Unregister a tool.before callback
+     */
+    unregisterToolBefore(callback: ToolEventCallback): void;
+    /**
+     * Register a callback for tool.after events
+     * Call this to connect to 0xRay's tool.after event system
+     */
+    registerToolAfter(callback: ToolEventCallback): void;
+    /**
+     * Unregister a tool.after callback
+     */
+    unregisterToolAfter(callback: ToolEventCallback): void;
+    /**
+     * Handle tool.before event from 0xRay
+     */
+    onToolBefore(event: StringRayToolEvent): Promise<void>;
+    /**
+     * Handle tool.after event from 0xRay
+     */
+    onToolAfter(event: StringRayToolEvent): Promise<void>;
+    /**
+     * Queue an event for later delivery when connection is restored
+     */
+    private queueEvent;
+    /**
+     * Flush queued events to OpenClaw Gateway
+     */
+    private flushEventQueue;
+    /**
+     * Get the current queue size
+     */
+    getQueueSize(): number;
+    /**
+     * Called when client reconnects - flush the event queue
+     */
+    handleReconnect(): Promise<void>;
+    /**
+     * Shutdown hooks
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if hooks are initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<OpenClawHooksConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): OpenClawHooksConfig;
+}
+/**
+ * Factory function to create hooks manager
+ */
+export declare function createOpenClawHooksManager(config: OpenClawHooksConfig): OpenClawHooksManager;