@reefclaw/connect 0.1.26 → 0.1.27

package/assets/bridge/gateway/gateway-ws-client.d.ts

@@ -1,7 +1,10 @@
 import { type ReconnectConfig as BaseReconnectConfig } from '../utils/reconnect.js';
 import type { GatewayConfig } from './gateway-config.js';
 interface ReconnectConfig extends BaseReconnectConfig {
-    maxAttempts: number;
+    /** Fast-backoff attempts before falling back to the slow retry loop */
+    maxFastAttempts: number;
+    /** Slow retry interval once the fast attempts are exhausted (ms) */
+    slowRetryMs: number;
 }
 /** hello-ok response payload from gateway */
 export interface HelloOkPayload {
@@ -56,6 +59,9 @@ export declare class GatewayWsClient {
     private ws;
     private state;
     private attempt;
+    /** True once the fast burst is spent and we are in the slow retry loop
+     *  (kept so the "switching to slow retry" warning logs once, not per attempt). */
+    private slowRetryActive;
     private reconnectTimer;
     private staleWarnTimer;
     private staleReconnectTimer;

package/assets/bridge/gateway/gateway-ws-client.js

@@ -30,11 +30,23 @@ const MIN_PROTOCOL_VERSION = 3;
 const MAX_PROTOCOL_VERSION = 4;
 const CLIENT_ID = 'openclaw-tui';
 const CLIENT_VERSION = '0.1.0';
+// Mirrors the relay connector's proven shape (see connector.ts DEFAULT_RECONNECT):
+// a bounded fast-backoff burst, then a slow retry that NEVER gives up.
+//
+// This client used to have `maxAttempts: 20` and go terminal ('failed') when it
+// ran out — roughly 9 minutes of budget (2+4+8+16s, then 16 x 30s). On
+// 2026-07-31 an OpenClaw upgrade left the gateway crash-looping for 56 minutes;
+// the bridge burned its 20 attempts in the first 9, gave up permanently, and
+// stayed dark even AFTER the gateway recovered. The dashboard — the operator's
+// window and one of the emergency-control paths — required a manual bridge
+// restart to come back. Any gateway downtime over ~9 min (upgrade, reboot,
+// crash-loop) reproduced it, on every deployment.
 const DEFAULT_RECONNECT = {
     baseDelayMs: 2_000,
     maxDelayMs: 30_000,
-    maxAttempts: 20,
+    maxFastAttempts: 20,
     jitterFactor: 0.3,
+    slowRetryMs: 60_000,
 };
 // ---- Fatal close codes ----
 /** Auth errors — do not reconnect */
@@ -45,6 +57,9 @@ export class GatewayWsClient {
     ws = null;
     state = 'disconnected';
     attempt = 0;
+    /** True once the fast burst is spent and we are in the slow retry loop
+     *  (kept so the "switching to slow retry" warning logs once, not per attempt). */
+    slowRetryActive = false;
     reconnectTimer = null;
     staleWarnTimer = null;
     staleReconnectTimer = null;
@@ -351,6 +366,7 @@ export class GatewayWsClient {
         logger.info(TAG, `Connected to gateway (protocol=${payload.protocol})`);
         this.lastHelloOk = payload;
         this.attempt = 0; // Reset reconnect counter
+        this.slowRetryActive = false; // Back on the fast budget for the next drop
         // Parse policy
         if (payload.policy?.tickIntervalMs) {
             this.tickIntervalMs = payload.policy.tickIntervalMs;
@@ -403,14 +419,21 @@ export class GatewayWsClient {
     // ---- Reconnection ----
     scheduleReconnect() {
         this.attempt++;
-        if (this.attempt > this.reconnectConfig.maxAttempts) {
-            logger.error(TAG, `Max reconnection attempts (${this.reconnectConfig.maxAttempts}) exceeded`);
-            this.setState('failed');
-            this.emit('failed', { reason: 'Max reconnection attempts exceeded' });
-            return;
+        const { maxFastAttempts, slowRetryMs } = this.reconnectConfig;
+        // Exhausting the fast burst is NOT terminal — a gateway that is down for an
+        // hour (upgrade, reboot, crash-loop) must still be picked up when it
+        // returns. Only a fatal close code (4001 auth) ends the client, because a
+        // rejected token will never start working and must not be retried forever.
+        const exhausted = this.attempt > maxFastAttempts;
+        if (exhausted && !this.slowRetryActive) {
+            this.slowRetryActive = true;
+            logger.warn(TAG, `Fast reconnect budget (${maxFastAttempts} attempts) exhausted — switching to slow retry every ` +
+                `${Math.round(slowRetryMs / 1000)}s. Still trying; will reconnect on its own when the gateway returns.`);
         }
-        const delay = computeDelay(this.attempt - 1, this.reconnectConfig);
-        logger.info(TAG, `Reconnecting in ${Math.round(delay)}ms (attempt ${this.attempt}/${this.reconnectConfig.maxAttempts})`);
+        const delay = exhausted ? slowRetryMs : computeDelay(this.attempt - 1, this.reconnectConfig);
+        logger.info(TAG, exhausted
+            ? `Reconnecting in ${Math.round(delay)}ms (slow retry, attempt ${this.attempt})`
+            : `Reconnecting in ${Math.round(delay)}ms (attempt ${this.attempt}/${maxFastAttempts})`);
         this.setState('reconnecting');
         this.emit('reconnecting', { attempt: this.attempt, delayMs: Math.round(delay) });
         this.reconnectTimer = setTimeout(() => {

package/assets/plugin/ingest/position-auto-capture.js

@@ -124,6 +124,25 @@ export async function onCreateOrderFilled(ctx, inputs, order) {
     //             scale-ins with WS-exact data; capturing here would double-post).
     const existing = ctx.stateStore.get(inputs.symbol);
     if (existing) {
+        // ★ SAME-ORDER GUARD — the twin of the dedup in onWsFillObserved (which
+        // returns when `stateEntry.openedFromExchangeTradeId === fill.exchangeOrderId`).
+        // That one covers create_order-then-WS; this covers WS-then-create_order,
+        // which is the ORDINARY ordering for a market order: the WS fill routinely
+        // beats the REST response (measured ~270-415ms on prod).
+        //
+        // Without it the stale probe below decides this case, and it CANNOT: its
+        // test is "does the exchange position equal this fill?", which is equally
+        // true of a genuinely stale mapping AND of the mapping the WS path just
+        // wrote for THIS VERY FILL. It chose 'stale', dropped the fresh mapping and
+        // journaled a second position — 38 duplicate pairs in 9 days (~11/day), each
+        // orphaning the WS row at 0 reviews while the exchange held ONE position.
+        // The twins were undedupable downstream because they key on different ids
+        // (WS = trade id, here = order id).
+        const orderId = typeof order.id === 'string' ? order.id : undefined;
+        if (orderId && existing.openedFromExchangeTradeId === orderId) {
+            logger.info(TAG, `onCreateOrderFilled ${inputs.symbol}: WS fill path already captured this order (${orderId}) — skipping duplicate capture`);
+            return;
+        }
         const probe = await probeStaleStateEntry(ctx, inputs.symbol, filledQty);
         if (probe === 'stale') {
             logger.warn(TAG, `onCreateOrderFilled ${inputs.symbol}: state-store entry (openedAt=${existing.openedAt}) is STALE — ` +

package/assets/plugin/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "reefclaw-paper-trading",
   "name": "ReefClaw Trading",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Supervised trading plugin for the ReefClaw dashboard. It runs on YOUR machine and starts in PAPER mode with no API keys. It cannot trade real funds until you supply exchange credentials and step PAPER→MICRO_LIVE→LIVE yourself from the dashboard — the agent cannot make that change (the tool is refused without operator provenance). Exchange keys stay local, are used only to sign requests to the exchange, and are never transmitted to ReefClaw (asserted by a test in this package). Trading telemetry — positions, fills, decision journal — is sent to ReefClaw to render the dashboard. Every live position carries exchange-native protective stops. Remote updates to the agent's trading instructions are applied only after an Ed25519 signature is verified against a public key pinned in this build.",
   "author": "ReefClaw",
   "activation": {

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "@reefclaw/connect",
-  "version": "0.1.26",
-  "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
-  "type": "module",
-  "bin": {
-    "reefclaw-connect": "dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "assets"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "bundle-assets": "node scripts/bundle-assets.mjs",
-    "build": "tsc && node scripts/bundle-assets.mjs",
-    "test": "vitest",
-    "test:run": "vitest run"
-  },
-  "dependencies": {
-    "json5": "2.2.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20",
-    "typescript": "^5",
-    "vitest": "^4.0.18"
-  },
-  "license": "MIT",
-  "homepage": "https://reefclaw.com"
-}
+{
+  "name": "@reefclaw/connect",
+  "version": "0.1.27",
+  "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
+  "type": "module",
+  "bin": {
+    "reefclaw-connect": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "bundle-assets": "node scripts/bundle-assets.mjs",
+    "build": "tsc && node scripts/bundle-assets.mjs",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "dependencies": {
+    "json5": "2.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "vitest": "^4.0.18"
+  },
+  "license": "MIT",
+  "homepage": "https://reefclaw.com"
+}

package/dist/daemon.js

@@ -1,104 +0,0 @@
-// Keep the bridge running across reboots. Linux/systemd-user is implemented
-// fully; macOS and Windows fall back to printing the manual run command (a
-// launchd/Task-Scheduler unit is a follow-up). The bridge reads its config from
-// ~/.openclaw/openclaw.json, so until the user pastes their connect message the
-// service will start, find no token, and restart — harmless; it connects within
-// seconds of the agent writing the config.
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir, userInfo } from 'node:os';
-import { BRIDGE_DIR } from './paths.js';
-import { run, which } from './exec.js';
-import { step, ok, info, warn } from './ui.js';
-const SERVICE_NAME = 'reefclaw-bridge';
-const NODE = process.execPath; // absolute path to the node running the installer
-/**
- * Build the systemd user-unit text. Pure + exported so the path-quoting is
- * unit-testable. Both `node` (process.execPath) and `bridgeDir` (under the
- * user's home) can contain spaces. Quoting rules differ per directive:
- *  - ExecStart= is parsed with shell-like word splitting, so an unquoted
- *    `ExecStart=/home/a b/node …` reads the binary as `/home/a` — QUOTE both
- *    the binary and the script path.
- *  - WorkingDirectory= takes the raw value after `=` as a single path (no word
- *    splitting) — spaces are safe UNQUOTED, and quotes are treated as literal
- *    characters, failing the unit with "path is not absolute" (verified live
- *    on systemd 255 / Ubuntu 24.04). Do NOT quote it.
- */
-export function buildSystemdUnit(node, bridgeDir) {
-    const indexJs = join(bridgeDir, 'index.js');
-    return `[Unit]
-Description=ReefClaw connector - bridges OpenClaw to the ReefClaw dashboard
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=${bridgeDir}
-ExecStart="${node}" "${indexJs}" --provider gateway --log-level info
-Restart=always
-RestartSec=5s
-
-[Install]
-WantedBy=default.target
-`;
-}
-function manualHint() {
-    warn('Could not set up an auto-start service on this OS yet.');
-    info('Keep the connector running with this command (leave it open / use your own service manager):');
-    info(`  "${NODE}" "${join(BRIDGE_DIR, 'index.js')}" --provider gateway`);
-}
-function installSystemd() {
-    if (!which('systemctl'))
-        return false;
-    const unitDir = join(homedir(), '.config', 'systemd', 'user');
-    mkdirSync(unitDir, { recursive: true });
-    const unit = buildSystemdUnit(NODE, BRIDGE_DIR);
-    writeFileSync(join(unitDir, `${SERVICE_NAME}.service`), unit, 'utf-8');
-    run('systemctl', ['--user', 'daemon-reload']);
-    const enabled = run('systemctl', ['--user', 'enable', '--now', `${SERVICE_NAME}.service`]);
-    if (!enabled.ok) {
-        warn('systemd --user enable/start did not succeed:');
-        if (enabled.stderr.trim())
-            info(enabled.stderr.trim().split('\n').slice(-2).join('\n'));
-        info(`Try:  systemctl --user enable --now ${SERVICE_NAME}.service`);
-        return false;
-    }
-    // `enable --now` can exit 0 while the unit failed to load (e.g. a bad unit
-    // file setting) — verify the unit actually came up before claiming ✓.
-    // 'active' = running; 'activating' = the expected pre-token restart loop
-    // (the bridge exits until the user pastes their connect message, and
-    // Restart=always re-launches it). Anything else (inactive/failed) means the
-    // unit never loaded.
-    const active = run('systemctl', ['--user', 'is-active', `${SERVICE_NAME}.service`]);
-    const state = active.stdout.trim();
-    if (state !== 'active' && state !== 'activating') {
-        warn(`the service did not come up (state: ${state || 'unknown'}).`);
-        info(`Inspect:  systemctl --user status ${SERVICE_NAME}.service`);
-        return false;
-    }
-    // Linger lets the user service run without an active login session (servers).
-    // Best-effort: needs privileges; non-fatal if it fails.
-    const linger = run('loginctl', ['enable-linger', userInfo().username]);
-    if (linger.ok) {
-        info('enabled linger (service survives logout / reboot)');
-    }
-    else {
-        info('note: run `sudo loginctl enable-linger $USER` so the connector survives logout.');
-    }
-    return true;
-}
-export function installDaemon() {
-    step('Starting the connector as a background service');
-    if (process.platform === 'linux') {
-        if (installSystemd()) {
-            ok(`connector running as a systemd user service (${SERVICE_NAME})`);
-            info(`logs:  journalctl --user -u ${SERVICE_NAME} -f`);
-            return true;
-        }
-        manualHint();
-        return false;
-    }
-    // macOS / Windows: manual for now (launchd / Task Scheduler unit is a follow-up).
-    manualHint();
-    return false;
-}