@reefclaw/openclaw-plugin 0.1.0

package/bridge/providers/mock.d.ts

@@ -0,0 +1,37 @@
+import type { OpenClawProvider, ProviderEvents, ProviderEventName } from '../provider.js';
+import type { EmergencyAction, ReconciliationSnapshot } from '../types.js';
+export declare class MockProvider implements OpenClawProvider {
+    private btcPrice;
+    private position;
+    private orderSeq;
+    private riskCycle;
+    private agentMode;
+    private startTime;
+    private marketInterval;
+    private agentInterval;
+    private readonly listeners;
+    private readonly RISK_LIMITS;
+    start(): void;
+    stop(): void;
+    executeEmergency(action: EmergencyAction): Promise<{
+        action: string;
+        executed: boolean;
+        timestamp: string;
+    }>;
+    handleChat(content: string): Promise<{
+        received: boolean;
+    }>;
+    closePosition(symbol: string): Promise<{
+        closed: boolean;
+        symbol: string;
+        error?: string;
+    }>;
+    getSnapshot(): Promise<ReconciliationSnapshot>;
+    on<E extends ProviderEventName>(event: E, listener: ProviderEvents[E]): void;
+    off<E extends ProviderEventName>(event: E, listener: ProviderEvents[E]): void;
+    private fire;
+    private simulateMarketTick;
+    private simulateRandomTrade;
+    private emitAgentState;
+    private emitRiskUpdate;
+}

package/bridge/providers/mock.js

@@ -0,0 +1,385 @@
+// MockProvider — simulates an OpenClaw agent for standalone testing.
+// Extracted from relay/scripts/mock-skill.ts into the provider interface.
+import { logger } from '../logger.js';
+import { redactTokens } from '@reefclaw/shared';
+const TAG = 'mock';
+export class MockProvider {
+    // ---- Simulated market state ----
+    btcPrice = 65_000;
+    position = null;
+    orderSeq = 0;
+    riskCycle = 0;
+    agentMode = 'ACTIVE';
+    startTime = Date.now();
+    // ---- Timers ----
+    marketInterval = null;
+    agentInterval = null;
+    // ---- Event listeners ----
+    listeners = {
+        ticker: new Set(),
+        candle: new Set(),
+        orderUpdate: new Set(),
+        agentState: new Set(),
+        riskUpdate: new Set(),
+        chatMessage: new Set(),
+        chatMessageStart: new Set(),
+        chatMessageChunk: new Set(),
+        chatMessageEnd: new Set(),
+        chatStreamingKeepAlive: new Set(),
+        marketStructure: new Set(),
+        cryptoMetrics: new Set(),
+        volumeAnalysis: new Set(),
+        tradeJournal: new Set(),
+        regimeUpdate: new Set(),
+        signalUpdate: new Set(),
+        missionUpdate: new Set(),
+        analyticsUpdate: new Set(),
+        fillError: new Set(),
+        shadowComparison: new Set(),
+        tradingModeUpdate: new Set(),
+        decisionTraceUpdate: new Set(),
+    };
+    // ---- Risk limits ----
+    RISK_LIMITS = {
+        position: {
+            maxPositionSize: 10_000,
+            maxOpenPositions: 5,
+            maxGrossExposure: 1.5,
+            maxNetExposure: 1.5,
+        },
+        loss: {
+            maxDailyDrawdown: -0.03,
+            maxPerTradeLoss: -500,
+            maxDailyLoss: -2000,
+        },
+        rate: { maxOrdersPerMinute: 60, maxCancelsPerMinute: 30 },
+    };
+    // ---- Provider interface ----
+    start() {
+        logger.info(TAG, 'Starting mock provider');
+        this.startTime = Date.now();
+        // Emit initial state immediately
+        this.emitAgentState();
+        this.emitRiskUpdate();
+        // Market data every 500ms
+        this.marketInterval = setInterval(() => {
+            this.simulateMarketTick();
+            this.simulateRandomTrade();
+        }, 500);
+        // Agent state + risk every 5s
+        this.agentInterval = setInterval(() => {
+            this.emitAgentState();
+            this.emitRiskUpdate();
+        }, 5_000);
+    }
+    stop() {
+        logger.info(TAG, 'Stopping mock provider');
+        if (this.marketInterval)
+            clearInterval(this.marketInterval);
+        if (this.agentInterval)
+            clearInterval(this.agentInterval);
+        this.marketInterval = null;
+        this.agentInterval = null;
+    }
+    async executeEmergency(action) {
+        logger.info(TAG, `Emergency ${action} executed`);
+        switch (action) {
+            case 'kill':
+                this.agentMode = 'STOPPED';
+                this.position = null;
+                break;
+            case 'flatten':
+                this.position = null;
+                break;
+            case 'pause':
+                this.agentMode = 'PAUSED';
+                break;
+            case 'resume':
+                this.agentMode = 'ACTIVE';
+                break;
+        }
+        // Emit updated state immediately
+        this.emitAgentState();
+        return {
+            action,
+            executed: true,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    async handleChat(content) {
+        // Mirror the bridge's redaction: never log a raw rc_* token, even in mock
+        // mode. If the redactor changed the string, surface that — mock mode is
+        // sometimes used for end-to-end QA where a real token might land here.
+        const safeForLog = redactTokens(content);
+        if (safeForLog !== content) {
+            logger.warn(TAG, 'Chat contained a connection token — mock provider does not auto-revoke.');
+        }
+        logger.info(TAG, `Chat: "${safeForLog}"`);
+        // Echo back a mock response after a short delay. Use the redacted form so
+        // the synthesized agent reply doesn't contain a raw token either.
+        setTimeout(() => {
+            const responses = [
+                `Understood. Monitoring market conditions for "${safeForLog}".`,
+                `Acknowledged. Current BTC price is ${this.btcPrice.toFixed(2)}.`,
+                `Roger that. Strategy MockScalper v1.0.0 is active.`,
+                `Processing your instruction. All systems nominal.`,
+            ];
+            this.fire('chatMessage', {
+                message: {
+                    id: `agent-msg-${Date.now()}`,
+                    role: 'agent',
+                    content: responses[Math.floor(Math.random() * responses.length)],
+                    timestamp: new Date().toISOString(),
+                },
+            });
+        }, 500 + Math.random() * 1000);
+        return { received: true };
+    }
+    async closePosition(symbol) {
+        logger.info(TAG, `Close position: ${symbol}`);
+        if (this.position) {
+            this.position = null;
+            return { closed: true, symbol };
+        }
+        return { closed: false, symbol, error: 'No position to close' };
+    }
+    async getSnapshot() {
+        logger.info(TAG, 'Reconciliation snapshot requested');
+        const posSize = this.position ? this.position.qty * this.btcPrice : 0;
+        return {
+            positions: this.position
+                ? [
+                    {
+                        symbol: 'BTC/USDT',
+                        side: this.position.side,
+                        quantity: this.position.qty,
+                        entryPrice: this.position.entry,
+                        currentPrice: this.btcPrice,
+                        unrealizedPnl: 0,
+                        unrealizedPnlPercent: 0,
+                        portfolioPercent: 100,
+                    },
+                ]
+                : [],
+            balance: {
+                currency: 'USDT',
+                total: 10_000,
+                available: 8_000,
+                locked: 2_000,
+            },
+            openOrders: [],
+            agentState: {
+                mode: this.agentMode,
+                strategy: { name: 'MockScalper', version: '1.0.0' },
+                health: {
+                    uptime: Math.floor((Date.now() - this.startTime) / 1000),
+                    lastDecision: new Date().toISOString(),
+                    lastTrade: null,
+                    errorRate: 0,
+                    thinkingInterval: 30,
+                },
+            },
+            riskMetrics: {
+                limits: this.RISK_LIMITS,
+                utilization: {
+                    currentPositionSize: posSize > 0 ? { 'BTC/USDT': +posSize.toFixed(2) } : {},
+                    openPositionCount: this.position ? 1 : 0,
+                    grossExposure: 0,
+                    netExposure: 0,
+                    dailyDrawdown: 0,
+                    dailyLoss: 0,
+                    ordersPerMinute: 0,
+                    cancelsPerMinute: 0,
+                },
+                activeBreaches: [],
+            },
+            gapFill: [],
+            sessionStartNav: 10_000,
+        };
+    }
+    on(event, listener) {
+        this.listeners[event].add(listener);
+    }
+    off(event, listener) {
+        this.listeners[event].delete(listener);
+    }
+    // ---- Simulation logic ----
+    fire(event, ...args) {
+        for (const listener of this.listeners[event]) {
+            listener(...args);
+        }
+    }
+    simulateMarketTick() {
+        // Random walk
+        this.btcPrice += (Math.random() - 0.5) * 50;
+        this.btcPrice = Math.max(60_000, Math.min(70_000, this.btcPrice));
+        // Ticker
+        this.fire('ticker', {
+            symbol: 'BTC/USDT',
+            lastPrice: +this.btcPrice.toFixed(2),
+            bidPrice: +(this.btcPrice - 0.5).toFixed(2),
+            askPrice: +(this.btcPrice + 0.5).toFixed(2),
+            volume24h: 12345.67,
+            change24h: +(this.btcPrice - 65_000).toFixed(2),
+            change24hPercent: +(((this.btcPrice - 65_000) / 65_000) * 100).toFixed(4),
+            timestamp: new Date().toISOString(),
+        });
+        // Candle (1s candles for demo)
+        const now = Math.floor(Date.now() / 1000);
+        this.fire('candle', {
+            symbol: 'BTC/USDT',
+            candle: {
+                time: now,
+                open: +(this.btcPrice - 5).toFixed(2),
+                high: +(this.btcPrice + 10).toFixed(2),
+                low: +(this.btcPrice - 10).toFixed(2),
+                close: +this.btcPrice.toFixed(2),
+                volume: +(Math.random() * 10).toFixed(4),
+            },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    simulateRandomTrade() {
+        if (this.agentMode !== 'ACTIVE')
+            return;
+        if (Math.random() > 0.05)
+            return; // ~5% chance per tick
+        const orderId = `mock-order-${++this.orderSeq}`;
+        if (!this.position) {
+            // Open a position
+            const side = Math.random() > 0.5 ? 'BUY' : 'SELL';
+            const qty = +(Math.random() * 0.1 + 0.01).toFixed(4);
+            this.fire('orderUpdate', {
+                orderId,
+                status: 'FILLED',
+                order: {
+                    id: orderId,
+                    symbol: 'BTC/USDT',
+                    side,
+                    type: 'MARKET',
+                    status: 'FILLED',
+                    quantity: qty,
+                    filledQuantity: qty,
+                    averageFillPrice: this.btcPrice,
+                    timeInForce: 'IOC',
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                },
+                fill: {
+                    id: `fill-${this.orderSeq}`,
+                    orderId,
+                    symbol: 'BTC/USDT',
+                    side,
+                    quantity: qty,
+                    price: this.btcPrice,
+                    expectedPrice: this.btcPrice,
+                    slippage: 0,
+                    slippageBps: 0,
+                    fee: +(qty * this.btcPrice * 0.001).toFixed(4),
+                    feeCurrency: 'USDT',
+                    timestamp: new Date().toISOString(),
+                },
+                timestamp: new Date().toISOString(),
+            });
+            this.position = {
+                side: side === 'BUY' ? 'LONG' : 'SHORT',
+                qty,
+                entry: this.btcPrice,
+            };
+            logger.info(TAG, `Opened ${this.position.side} ${qty} BTC @ ${this.btcPrice.toFixed(2)}`);
+        }
+        else {
+            // Close the position
+            const closeSide = this.position.side === 'LONG' ? 'SELL' : 'BUY';
+            const slippage = +(Math.random() * 2 - 1).toFixed(2);
+            this.fire('orderUpdate', {
+                orderId,
+                status: 'FILLED',
+                order: {
+                    id: orderId,
+                    symbol: 'BTC/USDT',
+                    side: closeSide,
+                    type: 'MARKET',
+                    status: 'FILLED',
+                    quantity: this.position.qty,
+                    filledQuantity: this.position.qty,
+                    averageFillPrice: this.btcPrice + slippage,
+                    timeInForce: 'IOC',
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                },
+                fill: {
+                    id: `fill-${this.orderSeq}`,
+                    orderId,
+                    symbol: 'BTC/USDT',
+                    side: closeSide,
+                    quantity: this.position.qty,
+                    price: this.btcPrice + slippage,
+                    expectedPrice: this.btcPrice,
+                    slippage,
+                    slippageBps: +((slippage / this.btcPrice) * 10000).toFixed(2),
+                    fee: +(this.position.qty * this.btcPrice * 0.001).toFixed(4),
+                    feeCurrency: 'USDT',
+                    timestamp: new Date().toISOString(),
+                },
+                timestamp: new Date().toISOString(),
+            });
+            const pnl = this.position.side === 'LONG'
+                ? (this.btcPrice - this.position.entry) * this.position.qty
+                : (this.position.entry - this.btcPrice) * this.position.qty;
+            logger.info(TAG, `Closed ${this.position.side} ${this.position.qty} BTC @ ${this.btcPrice.toFixed(2)} (PnL: ${pnl.toFixed(2)})`);
+            this.position = null;
+        }
+    }
+    emitAgentState() {
+        this.fire('agentState', {
+            state: {
+                mode: this.agentMode,
+                strategy: { name: 'MockScalper', version: '1.0.0' },
+                health: {
+                    uptime: Math.floor((Date.now() - this.startTime) / 1000),
+                    lastDecision: new Date().toISOString(),
+                    lastTrade: new Date().toISOString(),
+                    errorRate: 0,
+                    thinkingInterval: 30,
+                },
+            },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    emitRiskUpdate() {
+        const phase = this.riskCycle % 12;
+        const t = phase < 8 ? phase / 8 : 1 - (phase - 8) / 4;
+        this.riskCycle++;
+        const posSize = this.position ? this.position.qty * this.btcPrice : 0;
+        const activeBreaches = [];
+        if (phase === 7) {
+            activeBreaches.push({
+                metric: 'dailyDrawdown',
+                limit: -0.03,
+                current: -(t * 0.035),
+                level: 'CRITICAL',
+                action: 'AUTO_PAUSE',
+                timestamp: new Date().toISOString(),
+            });
+        }
+        this.fire('riskUpdate', {
+            event: 'risk_update',
+            metrics: {
+                limits: this.RISK_LIMITS,
+                utilization: {
+                    currentPositionSize: posSize > 0 ? { 'BTC/USDT': +posSize.toFixed(2) } : {},
+                    openPositionCount: this.position ? 1 : 0,
+                    grossExposure: +(t * 1.2).toFixed(3),
+                    netExposure: +(t * 0.35).toFixed(3),
+                    dailyDrawdown: -(t * 0.025),
+                    dailyLoss: -(t * 1500),
+                    ordersPerMinute: Math.round(t * 45),
+                    cancelsPerMinute: Math.round(t * 20),
+                },
+                activeBreaches,
+            },
+            timestamp: new Date().toISOString(),
+        });
+    }
+}

package/bridge/providers/onboarding-commands.d.ts

@@ -0,0 +1,83 @@
+import type { GatewayHttpClient } from '../gateway/gateway-http-client.js';
+import type { ToolMap } from '../gateway/tool-discovery.js';
+import type { TradingMode } from '@reefclaw/shared';
+export interface SetTradingModeOutcome {
+    ok: boolean;
+    message: string;
+    previousMode: TradingMode;
+    mode: TradingMode;
+    readiness: string;
+    reason?: string;
+}
+export interface SetExchangeCredentialsOutcome {
+    ok: boolean;
+    message: string;
+    fingerprint: string;
+    reconnected: boolean;
+    mode: TradingMode;
+    readiness: string;
+}
+export interface TestExchangeCredentialsOutcome {
+    ok: boolean;
+    message: string;
+    fingerprint: string;
+    canReadBalance: boolean;
+    canReadPositions: boolean;
+    balanceUSDT: number | null;
+    testnet: boolean;
+    errors: string[];
+}
+export interface ClearExchangeCredentialsOutcome {
+    ok: boolean;
+    message: string;
+    modeBefore: TradingMode;
+    mode: TradingMode;
+    rolledBackToPaper: boolean;
+    readiness: string;
+}
+export interface OnboardingContext {
+    http: GatewayHttpClient | null;
+    toolMap: ToolMap;
+}
+export type BracketMode = 'off' | 'observe' | 'enforce';
+export type BracketRequirementFlag = 'requireStopLoss' | 'requireTakeProfit';
+export interface GetBracketConfigOutcome {
+    ok: boolean;
+    message?: string;
+    mode: BracketMode;
+    requireStopLoss: boolean;
+    requireTakeProfit: boolean;
+}
+export interface SetBracketRequirementOutcome {
+    ok: boolean;
+    flag: BracketRequirementFlag;
+    previousValue: boolean;
+    value: boolean;
+    warning?: string;
+    error?: string;
+    message?: string;
+}
+/** Forward a set_trading_mode invocation to the plugin via HTTP. */
+export declare function executeSetTradingMode(ctx: OnboardingContext, mode: TradingMode, acknowledged: boolean | undefined): Promise<SetTradingModeOutcome>;
+/** Forward a test_exchange_credentials invocation to the plugin. The plugin
+ *  does a throwaway read-only call to verify permissions without persisting
+ *  the keys. Error messages are scrubbed of the raw secret before logging
+ *  (same approach as the set path). */
+export declare function executeTestExchangeCredentials(ctx: OnboardingContext, apiKey: string, secret: string, testnet: boolean | undefined): Promise<TestExchangeCredentialsOutcome>;
+/** Forward a clear_exchange_credentials invocation to the plugin. Sends
+ *  `confirm: true` unconditionally — the skill RPC only accepts the call
+ *  at all when the bridge has decided it's legitimate, so the plugin-side
+ *  safety gate is always satisfied when we reach this function. */
+export declare function executeClearExchangeCredentials(ctx: OnboardingContext): Promise<ClearExchangeCredentialsOutcome>;
+/** Forward a get_bracket_config invocation to the plugin. Returns safe
+ *  defaults if the tool isn't available (bracket feature not enabled or
+ *  plugin is older than v2.7) so the dashboard can still render. */
+export declare function executeGetBracketConfig(ctx: OnboardingContext): Promise<GetBracketConfigOutcome>;
+/** Forward a set_bracket_requirement invocation to the plugin. The plugin
+ *  side enforces flag + boolean validation; the skill layer just forwards. */
+export declare function executeSetBracketRequirement(ctx: OnboardingContext, flag: BracketRequirementFlag, value: boolean): Promise<SetBracketRequirementOutcome>;
+/** Forward a set_exchange_credentials invocation to the plugin via HTTP.
+ *  The raw secret is sent once over TLS and never retained here — no
+ *  caching, no log lines with the raw value. Errors are scrubbed of the
+ *  secret before logging in case it ever appears in an error chain. */
+export declare function executeSetExchangeCredentials(ctx: OnboardingContext, apiKey: string, secret: string, testnet: boolean | undefined): Promise<SetExchangeCredentialsOutcome>;