@reefclaw/connect 0.1.9 → 0.1.10

package/assets/shared/signals/indicators.js

@@ -0,0 +1,107 @@
+// Shared indicator computation helpers.
+// Used by both regime feature engineering and signal condition evaluation.
+export function computeEMA(data, period) {
+    if (data.length < period)
+        return data[data.length - 1] ?? 0;
+    const k = 2 / (period + 1);
+    let ema = mean(data.slice(0, period));
+    for (let i = period; i < data.length; i++) {
+        ema = data[i] * k + ema * (1 - k);
+    }
+    return ema;
+}
+export function computeATR(highs, lows, closes, period) {
+    const series = computeATRSeries(highs, lows, closes, period);
+    return series[series.length - 1] ?? 0;
+}
+export function computeATRSeries(highs, lows, closes, period) {
+    if (highs.length < 2)
+        return [];
+    const tr = [];
+    for (let i = 1; i < highs.length; i++) {
+        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
+    }
+    const atr = [];
+    atr[0] = mean(tr.slice(0, period));
+    for (let i = 1; i < tr.length; i++) {
+        atr[i] = (atr[i - 1] * (period - 1) + tr[i]) / period;
+    }
+    return atr;
+}
+export function computeRSI(closes, period) {
+    if (closes.length < period + 1)
+        return 50;
+    const changes = [];
+    for (let i = 1; i < closes.length; i++) {
+        changes.push(closes[i] - closes[i - 1]);
+    }
+    let avgGain = 0;
+    let avgLoss = 0;
+    for (let i = 0; i < period; i++) {
+        if (changes[i] > 0)
+            avgGain += changes[i];
+        else
+            avgLoss -= changes[i];
+    }
+    avgGain /= period;
+    avgLoss /= period;
+    for (let i = period; i < changes.length; i++) {
+        const gain = changes[i] > 0 ? changes[i] : 0;
+        const loss = changes[i] < 0 ? -changes[i] : 0;
+        avgGain = (avgGain * (period - 1) + gain) / period;
+        avgLoss = (avgLoss * (period - 1) + loss) / period;
+    }
+    if (avgLoss === 0)
+        return 100;
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+export function linearSlope(y, x) {
+    const n = y.length;
+    if (n < 2)
+        return 0;
+    const xs = x ?? Array.from({ length: n }, (_, i) => i);
+    const mx = mean(xs);
+    const my = mean(y);
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+        num += (xs[i] - mx) * (y[i] - my);
+        den += (xs[i] - mx) ** 2;
+    }
+    return den > 0 ? num / den : 0;
+}
+export function computeStd(data) {
+    if (data.length < 2)
+        return 0;
+    const avg = mean(data);
+    const variance = data.reduce((s, v) => s + (v - avg) ** 2, 0) / (data.length - 1);
+    return Math.sqrt(variance);
+}
+export function mean(data) {
+    if (data.length === 0)
+        return 0;
+    return data.reduce((s, v) => s + v, 0) / data.length;
+}
+/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
+export function findSwingPoints(bars, lookback = 5) {
+    const highs = [];
+    const lows = [];
+    for (let i = lookback; i < bars.length - lookback; i++) {
+        let isHigh = true;
+        let isLow = true;
+        for (let j = i - lookback; j <= i + lookback; j++) {
+            if (j === i)
+                continue;
+            if (bars[j].high >= bars[i].high)
+                isHigh = false;
+            if (bars[j].low <= bars[i].low)
+                isLow = false;
+        }
+        if (isHigh)
+            highs.push(bars[i].high);
+        if (isLow)
+            lows.push(bars[i].low);
+    }
+    return { highs, lows };
+}

package/dist/daemon.js

@@ -0,0 +1,104 @@
+// 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/connect",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
   "type": "module",
   "bin": {