simmer-reactor 0.1.0

package/dist/dispatcher.d.ts

@@ -0,0 +1,24 @@
+import type { PluginConfig, PluginLogger, PluginRuntime, WhaleEvent } from "./types.js";
+export declare class Dispatcher {
+    private config;
+    private runtime;
+    private logger;
+    private buffer;
+    private syncQueue;
+    private consecutiveFailures;
+    private autoReactPaused;
+    private executing;
+    constructor(config: PluginConfig, runtime: PluginRuntime, logger: PluginLogger);
+    handleEvent(event: WhaleEvent): Promise<void>;
+    private addToBuffer;
+    private executeAutoReact;
+    private onFailure;
+    getPromptInjection(): string | null;
+    /** Drain the sync queue (for API POST). Returns events and clears the queue. */
+    drainSyncQueue(): WhaleEvent[];
+    getRecentEvents(n: number): WhaleEvent[];
+    get isAutoReactPaused(): boolean;
+    get failureCount(): number;
+    resumeAutoReact(): void;
+    updateConfig(config: PluginConfig): void;
+}

package/dist/dispatcher.js

@@ -0,0 +1,121 @@
+const SKILL_TIMEOUT_MS = 60_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const SYNC_QUEUE_CAP = 500;
+export class Dispatcher {
+    config;
+    runtime;
+    logger;
+    buffer = [];
+    syncQueue = []; // separate queue for API sync (not cleared by prompt injection)
+    consecutiveFailures = 0;
+    autoReactPaused = false;
+    executing = false;
+    constructor(config, runtime, logger) {
+        this.config = config;
+        this.runtime = runtime;
+        this.logger = logger;
+    }
+    async handleEvent(event) {
+        this.addToBuffer(event);
+        this.syncQueue.push(event);
+        while (this.syncQueue.length > SYNC_QUEUE_CAP) {
+            this.syncQueue.shift();
+        }
+        if (this.config.dispatch_mode === "autoReact" && !this.autoReactPaused) {
+            await this.executeAutoReact(event);
+        }
+    }
+    addToBuffer(event) {
+        this.buffer.push(event);
+        while (this.buffer.length > this.config.buffer_max) {
+            this.buffer.shift();
+        }
+    }
+    async executeAutoReact(event) {
+        if (this.executing) {
+            this.logger.info("[reactor] autoReact already executing, skipping");
+            return;
+        }
+        this.executing = true;
+        try {
+            const argv = [
+                "npx", "clawhub", "run", this.config.autoReact_skill,
+                "--wallets", event.whale_wallet,
+                "--live",
+            ];
+            this.logger.info(`[reactor] autoReact: running ${this.config.autoReact_skill} for ${event.whale_label || event.whale_wallet} ${event.side} $${event.size}`);
+            const result = await this.runtime.system.runCommandWithTimeout(argv, {
+                timeoutMs: SKILL_TIMEOUT_MS,
+                env: {
+                    ...process.env,
+                    REACTOR_EVENT_WALLET: event.whale_wallet,
+                    REACTOR_EVENT_MARKET_SLUG: event.market_slug || "",
+                    REACTOR_EVENT_SIDE: event.side,
+                    REACTOR_EVENT_SIZE: String(event.size),
+                    REACTOR_EVENT_PRICE: String(event.price),
+                    REACTOR_MAX_USD: String(this.config.autoReact_max_usd),
+                },
+            });
+            if (result.code === 0) {
+                this.logger.info(`[reactor] autoReact: skill completed successfully`);
+                this.consecutiveFailures = 0;
+            }
+            else {
+                this.logger.warn(`[reactor] autoReact: skill failed (code=${result.code}, termination=${result.termination})`);
+                this.onFailure();
+            }
+        }
+        catch (e) {
+            this.logger.error(`[reactor] autoReact: execution error: ${e}`);
+            this.onFailure();
+        }
+        finally {
+            this.executing = false;
+        }
+    }
+    onFailure() {
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+            this.logger.warn(`[reactor] autoReact paused after ${this.consecutiveFailures} consecutive failures — falling back to passive`);
+            this.autoReactPaused = true;
+        }
+    }
+    getPromptInjection() {
+        if (this.buffer.length === 0)
+            return null;
+        const lines = this.buffer.map((e) => {
+            const label = e.whale_label ? ` (${e.whale_label})` : "";
+            const market = e.market_title || e.market_slug || "unknown market";
+            return `- ${e.whale_wallet.slice(0, 8)}...${label} ${e.side} $${e.size.toLocaleString()} on "${market}" @ ${e.price}`;
+        });
+        const header = `🐋 Reactor: ${this.buffer.length} whale event${this.buffer.length === 1 ? "" : "s"} since last cycle`;
+        const body = lines.join("\n");
+        const skills = `\nYour installed skills can act on these events (e.g., polymarket-copytrading).`;
+        const footer = `\nReact or ignore?`;
+        this.buffer = [];
+        return `${header}\n${body}${skills}${footer}`;
+    }
+    /** Drain the sync queue (for API POST). Returns events and clears the queue. */
+    drainSyncQueue() {
+        const events = [...this.syncQueue];
+        this.syncQueue = [];
+        return events;
+    }
+    getRecentEvents(n) {
+        return this.buffer.slice(-n);
+    }
+    get isAutoReactPaused() {
+        return this.autoReactPaused;
+    }
+    get failureCount() {
+        return this.consecutiveFailures;
+    }
+    resumeAutoReact() {
+        this.autoReactPaused = false;
+        this.consecutiveFailures = 0;
+        this.logger.info("[reactor] autoReact resumed");
+    }
+    updateConfig(config) {
+        this.config = config;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { PluginApi } from "./types.js";
+export default function register(pluginApi: PluginApi): void;

package/dist/index.js

@@ -0,0 +1,232 @@
+import { DEFAULT_CONFIG } from "./types.js";
+const EVENT_SYNC_INTERVAL_MS = 30_000;
+import { PolyNodeWsClient } from "./websocket.js";
+import { Dispatcher } from "./dispatcher.js";
+// ---- State ----
+let pluginConfig = { ...DEFAULT_CONFIG };
+let reactorConfig = { polynode_api_key: null, watchlist: [] };
+let status = "unconfigured";
+let wsClient = null;
+let dispatcher = null;
+let configRefreshTimer = null;
+let eventSyncTimer = null;
+let totalEventsReceived = 0;
+let lastEventTime = null;
+// ---- Config ----
+function loadPluginConfig(raw) {
+    if (!raw)
+        return;
+    if (raw.dispatch_mode === "autoReact" || raw.dispatch_mode === "passive") {
+        pluginConfig.dispatch_mode = raw.dispatch_mode;
+    }
+    if (typeof raw.autoReact_skill === "string")
+        pluginConfig.autoReact_skill = raw.autoReact_skill;
+    if (typeof raw.autoReact_max_usd === "number")
+        pluginConfig.autoReact_max_usd = raw.autoReact_max_usd;
+    if (typeof raw.buffer_max === "number")
+        pluginConfig.buffer_max = raw.buffer_max;
+    if (typeof raw.reconnect_interval_ms === "number")
+        pluginConfig.reconnect_interval_ms = raw.reconnect_interval_ms;
+    if (typeof raw.config_refresh_interval_ms === "number")
+        pluginConfig.config_refresh_interval_ms = raw.config_refresh_interval_ms;
+}
+async function fetchReactorConfig(logger) {
+    const apiKey = process.env.SIMMER_API_KEY;
+    const apiUrl = process.env.SIMMER_API_URL || "https://api.simmer.markets";
+    if (!apiKey) {
+        logger.warn("[reactor] SIMMER_API_KEY not set — cannot fetch config");
+        return false;
+    }
+    try {
+        const res = await fetch(`${apiUrl}/api/sdk/reactor/config`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!res.ok) {
+            logger.warn(`[reactor] Config fetch failed: ${res.status}`);
+            return false;
+        }
+        const data = (await res.json());
+        reactorConfig = data;
+        return true;
+    }
+    catch (e) {
+        logger.error(`[reactor] Config fetch error: ${e}`);
+        return false;
+    }
+}
+async function syncEventsToApi(events, logger) {
+    const apiKey = process.env.SIMMER_API_KEY;
+    const apiUrl = process.env.SIMMER_API_URL || "https://api.simmer.markets";
+    if (!apiKey || events.length === 0)
+        return;
+    try {
+        await fetch(`${apiUrl}/api/sdk/reactor/events`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ events }),
+        });
+    }
+    catch (e) {
+        logger.warn(`[reactor] Event sync failed: ${e}`);
+    }
+}
+// ---- WS Lifecycle ----
+function startWs(runtime, logger) {
+    if (!reactorConfig.polynode_api_key || reactorConfig.watchlist.length === 0) {
+        status = "unconfigured";
+        logger.info("[reactor] No API key or empty watchlist — status: unconfigured");
+        return;
+    }
+    // Stop existing WS if any (prevents leaking connections on re-init)
+    if (wsClient) {
+        wsClient.stop();
+        wsClient = null;
+    }
+    status = "connecting";
+    if (!dispatcher) {
+        dispatcher = new Dispatcher(pluginConfig, runtime, logger);
+    }
+    wsClient = new PolyNodeWsClient({
+        apiKey: reactorConfig.polynode_api_key,
+        watchlist: reactorConfig.watchlist,
+        reconnectStartMs: pluginConfig.reconnect_interval_ms,
+        onEvent: (event) => {
+            if (status === "connecting")
+                status = "connected";
+            if (status === "paused")
+                return;
+            totalEventsReceived++;
+            lastEventTime = event.timestamp;
+            dispatcher?.handleEvent(event);
+        },
+        logger,
+    });
+    wsClient.connect();
+}
+function stopWs(logger) {
+    if (wsClient) {
+        wsClient.stop();
+        wsClient = null;
+    }
+    status = "unconfigured";
+    logger.info("[reactor] WS stopped");
+}
+// ---- Plugin Registration ----
+export default function register(pluginApi) {
+    loadPluginConfig(pluginApi.pluginConfig);
+    const logger = pluginApi.logger;
+    const runtime = pluginApi.runtime;
+    // ---- Service ----
+    pluginApi.registerService({
+        id: "reactor-ws",
+        start: async (ctx) => {
+            logger.info("[reactor] Service starting");
+            const ok = await fetchReactorConfig(logger);
+            if (ok) {
+                startWs(runtime, logger);
+            }
+            else {
+                status = "unconfigured";
+                logger.info("[reactor] No config — waiting for user to configure in dashboard");
+            }
+            configRefreshTimer = setInterval(async () => {
+                const refreshed = await fetchReactorConfig(logger);
+                if (refreshed && status === "unconfigured") {
+                    startWs(runtime, logger);
+                }
+                else if (refreshed && wsClient) {
+                    wsClient.updateWatchlist(reactorConfig.watchlist);
+                    dispatcher?.updateConfig(pluginConfig);
+                }
+            }, pluginConfig.config_refresh_interval_ms);
+            eventSyncTimer = setInterval(() => {
+                if (dispatcher) {
+                    const events = dispatcher.drainSyncQueue();
+                    if (events.length > 0) {
+                        syncEventsToApi(events, logger);
+                    }
+                }
+            }, EVENT_SYNC_INTERVAL_MS);
+        },
+        stop: async (ctx) => {
+            logger.info("[reactor] Service stopping");
+            if (configRefreshTimer) {
+                clearInterval(configRefreshTimer);
+                configRefreshTimer = null;
+            }
+            if (eventSyncTimer) {
+                clearInterval(eventSyncTimer);
+                eventSyncTimer = null;
+            }
+            if (dispatcher) {
+                const events = dispatcher.drainSyncQueue();
+                if (events.length > 0) {
+                    await syncEventsToApi(events, logger);
+                }
+            }
+            stopWs(logger);
+            dispatcher = null;
+        },
+    });
+    // ---- Prompt Hook (passive mode) ----
+    pluginApi.on("before_prompt_build", async () => {
+        if (!dispatcher)
+            return {};
+        const injection = dispatcher.getPromptInjection();
+        if (!injection)
+            return {};
+        return { prependContext: injection };
+    });
+    // ---- Commands ----
+    pluginApi.registerCommand({
+        name: "reactor",
+        description: "Whale activity reactor — status, pause, resume, events",
+        acceptsArgs: true,
+        handler: async (ctx) => {
+            const parts = (ctx.args || "").trim().split(/\s+/);
+            const sub = parts[0] || "status";
+            if (sub === "status") {
+                const lines = [
+                    `**Reactor Status:** ${status}`,
+                    `**Mode:** ${pluginConfig.dispatch_mode}`,
+                    `**Watchlist:** ${reactorConfig.watchlist.length} wallets`,
+                    `**Events received:** ${totalEventsReceived}`,
+                    `**Last event:** ${lastEventTime || "none"}`,
+                ];
+                if (dispatcher?.isAutoReactPaused) {
+                    lines.push(`⚠️ **autoReact paused** (${dispatcher.failureCount} consecutive failures)`);
+                }
+                return { text: lines.join("\n") };
+            }
+            if (sub === "pause") {
+                status = "paused";
+                return { text: "Reactor paused. WS stays connected but events are suppressed. Use `/reactor resume` to resume." };
+            }
+            if (sub === "resume") {
+                if (status === "paused") {
+                    status = "connected";
+                }
+                if (dispatcher?.isAutoReactPaused) {
+                    dispatcher.resumeAutoReact();
+                }
+                return { text: "Reactor resumed." };
+            }
+            if (sub === "events") {
+                const n = parseInt(parts[1] || "10", 10);
+                const events = dispatcher?.getRecentEvents(n) || [];
+                if (events.length === 0)
+                    return { text: "No recent events." };
+                const lines = events.map((e) => {
+                    const label = e.whale_label ? ` (${e.whale_label})` : "";
+                    return `${e.timestamp} | ${e.whale_wallet.slice(0, 8)}...${label} ${e.side} $${e.size} on "${e.market_title || e.market_slug || "?"}"`;
+                });
+                return { text: lines.join("\n") };
+            }
+            return { text: "Usage: `/reactor status|pause|resume|events [n]`" };
+        },
+    });
+    logger.info("[reactor] Plugin registered");
+}

package/dist/types.d.ts

@@ -0,0 +1,83 @@
+export interface PluginLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+export interface SpawnResult {
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    killed: boolean;
+    termination: "exit" | "timeout" | "no-output-timeout" | "signal";
+}
+export interface PluginRuntime {
+    system: {
+        runCommandWithTimeout: (argv: string[], opts: {
+            timeoutMs: number;
+            cwd?: string;
+            env?: NodeJS.ProcessEnv;
+        }) => Promise<SpawnResult>;
+    };
+}
+export interface ServiceCtx {
+    config: Record<string, unknown>;
+    workspaceDir?: string;
+    stateDir: string;
+    logger: PluginLogger;
+}
+export interface CommandCtx {
+    args?: string;
+}
+export interface PluginApi {
+    pluginConfig?: Record<string, unknown>;
+    logger: PluginLogger;
+    runtime: PluginRuntime;
+    on: (hookName: string, handler: (...args: unknown[]) => unknown, opts?: {
+        priority?: number;
+    }) => void;
+    registerService: (service: {
+        id: string;
+        start: (ctx: ServiceCtx) => void | Promise<void>;
+        stop?: (ctx: ServiceCtx) => void | Promise<void>;
+    }) => void;
+    registerCommand: (cmd: {
+        name: string;
+        description: string;
+        acceptsArgs?: boolean;
+        handler: (ctx: CommandCtx) => Promise<{
+            text: string;
+        }>;
+    }) => void;
+}
+export interface WatchlistEntry {
+    wallet: string;
+    label: string | null;
+    min_size: number;
+}
+export interface ReactorConfig {
+    polynode_api_key: string | null;
+    watchlist: WatchlistEntry[];
+}
+export interface WhaleEvent {
+    id: string;
+    timestamp: string;
+    market_title: string | null;
+    market_slug: string | null;
+    market_id: string | null;
+    whale_wallet: string;
+    whale_label: string | null;
+    side: string;
+    size: number;
+    price: number;
+}
+export interface PluginConfig {
+    dispatch_mode: "passive" | "autoReact";
+    autoReact_skill: string;
+    autoReact_max_usd: number;
+    buffer_max: number;
+    reconnect_interval_ms: number;
+    config_refresh_interval_ms: number;
+}
+export declare const DEFAULT_CONFIG: PluginConfig;
+export type PluginStatus = "unconfigured" | "connecting" | "connected" | "paused" | "error";

package/dist/types.js

@@ -0,0 +1,9 @@
+// ---- OpenClaw Plugin API types (subset we use) ----
+export const DEFAULT_CONFIG = {
+    dispatch_mode: "passive",
+    autoReact_skill: "polymarket-copytrading",
+    autoReact_max_usd: 50,
+    buffer_max: 100,
+    reconnect_interval_ms: 5000,
+    config_refresh_interval_ms: 300_000,
+};

package/dist/websocket.d.ts

@@ -0,0 +1,23 @@
+import type { PluginLogger, WatchlistEntry, WhaleEvent } from "./types.js";
+export interface WsClientOptions {
+    apiKey: string;
+    watchlist: WatchlistEntry[];
+    reconnectStartMs: number;
+    onEvent: (event: WhaleEvent) => void;
+    logger: PluginLogger;
+}
+export declare class PolyNodeWsClient {
+    private ws;
+    private options;
+    private reconnectMs;
+    private reconnectTimer;
+    private seenIds;
+    private stopped;
+    constructor(options: WsClientOptions);
+    connect(): void;
+    private subscribe;
+    private handleMessage;
+    private scheduleReconnect;
+    updateWatchlist(watchlist: WatchlistEntry[]): void;
+    stop(): void;
+}

package/dist/websocket.js

@@ -0,0 +1,117 @@
+import WebSocket from "ws";
+const MAX_RECONNECT_MS = 60_000;
+const SEEN_IDS_CAP = 10_000;
+export class PolyNodeWsClient {
+    ws = null;
+    options;
+    reconnectMs;
+    reconnectTimer = null;
+    seenIds = new Set();
+    stopped = false;
+    constructor(options) {
+        this.options = options;
+        this.reconnectMs = options.reconnectStartMs;
+    }
+    connect() {
+        this.stopped = false;
+        const url = `wss://ws.polynode.dev/ws?key=${this.options.apiKey}`;
+        this.options.logger.info(`[reactor] Connecting to PolyNode WS`);
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+            this.options.logger.info("[reactor] WS connected");
+            this.reconnectMs = this.options.reconnectStartMs; // reset backoff
+            this.subscribe();
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                this.handleMessage(msg);
+            }
+            catch (e) {
+                this.options.logger.warn(`[reactor] Failed to parse WS message: ${e}`);
+            }
+        });
+        this.ws.on("close", (code, reason) => {
+            this.options.logger.warn(`[reactor] WS closed: ${code} ${reason.toString()}`);
+            this.scheduleReconnect();
+        });
+        this.ws.on("error", (err) => {
+            this.options.logger.error(`[reactor] WS error: ${err.message}`);
+        });
+    }
+    subscribe() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const wallets = this.options.watchlist.map((w) => w.wallet);
+        const minSize = Math.min(...this.options.watchlist.map((w) => w.min_size));
+        this.ws.send(JSON.stringify({
+            action: "subscribe",
+            params: {
+                channel: "fills",
+                filters: { wallets, min_size: minSize },
+            },
+        }));
+        this.options.logger.info(`[reactor] Subscribed to ${wallets.length} wallets`);
+    }
+    handleMessage(msg) {
+        if (msg.type !== "fill" && msg.channel !== "fills")
+            return;
+        const data = msg.data;
+        if (!data)
+            return;
+        const eventId = String(data.id || `${data.timestamp}-${data.taker_wallet}-${data.size}`);
+        if (this.seenIds.has(eventId))
+            return;
+        this.seenIds.add(eventId);
+        if (this.seenIds.size > SEEN_IDS_CAP) {
+            const first = this.seenIds.values().next().value;
+            if (first !== undefined)
+                this.seenIds.delete(first);
+        }
+        const takerWallet = String(data.taker_wallet || "");
+        const entry = this.options.watchlist.find((w) => w.wallet.toLowerCase() === takerWallet.toLowerCase());
+        if (!entry)
+            return;
+        const size = Number(data.size || 0);
+        if (size < entry.min_size)
+            return;
+        const event = {
+            id: eventId,
+            timestamp: String(data.timestamp || new Date().toISOString()),
+            market_title: data.market_title || null,
+            market_slug: data.market_slug || null,
+            market_id: data.market_id || null,
+            whale_wallet: takerWallet,
+            whale_label: entry.label,
+            side: String(data.side || "unknown"),
+            size,
+            price: Number(data.price || 0),
+        };
+        this.options.onEvent(event);
+    }
+    scheduleReconnect() {
+        if (this.stopped)
+            return;
+        this.options.logger.info(`[reactor] Reconnecting in ${this.reconnectMs}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, this.reconnectMs);
+        this.reconnectMs = Math.min(this.reconnectMs * 2, MAX_RECONNECT_MS);
+    }
+    updateWatchlist(watchlist) {
+        this.options.watchlist = watchlist;
+        this.subscribe();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.options.logger.info("[reactor] WS client stopped");
+    }
+}

package/openclaw.plugin.json

@@ -0,0 +1,42 @@
+{
+  "name": "simmer-reactor",
+  "version": "0.1.0",
+  "description": "Real-time whale activity monitor and trade reactor",
+  "main": "dist/index.js",
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "dispatch_mode": {
+        "type": "string",
+        "enum": ["passive", "autoReact"],
+        "default": "passive",
+        "description": "passive = buffer events for LLM; autoReact = execute skill directly"
+      },
+      "autoReact_skill": {
+        "type": "string",
+        "default": "polymarket-copytrading",
+        "description": "Skill slug to invoke in autoReact mode"
+      },
+      "autoReact_max_usd": {
+        "type": "number",
+        "default": 50,
+        "description": "Max trade size per autoReact execution"
+      },
+      "buffer_max": {
+        "type": "number",
+        "default": 100,
+        "description": "Max events buffered for passive injection"
+      },
+      "reconnect_interval_ms": {
+        "type": "number",
+        "default": 5000,
+        "description": "WebSocket reconnect backoff start (ms)"
+      },
+      "config_refresh_interval_ms": {
+        "type": "number",
+        "default": 300000,
+        "description": "How often to re-fetch config from dashboard API (ms)"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "simmer-reactor",
+  "version": "0.1.0",
+  "description": "Real-time whale activity monitor and trade reactor for OpenClaw",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "files": ["dist/", "openclaw.plugin.json"],
+  "keywords": ["openclaw", "simmer", "polymarket", "whale", "reactor"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SpartanLabsXyz/simmer"
+  },
+  "openclaw": {
+    "extensions": ["./dist/index.js"]
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.4.0"
+  }
+}