openclaw-glance-plugin 0.1.2 → 0.1.4

package/skills/glance-watch/references/markets.md

@@ -0,0 +1,56 @@
+# 盯盘插件参考文档
+
+## 环境配置
+
+```bash
+# 基础配置（桥接地址固定为 wss://glanceup-pre.100credit.cn）
+export OPENCLAW_WS_TOKEN="<token>"
+
+# Token 申请：在网页上申请 OPENCLAW_WS_TOKEN
+```
+
+## 市场类型与产品代码
+
+| 市场 | productType | productCode 示例 | 行情频率 |
+|------|-------------|-----------------|----------|
+| A股个股 | stock | 000001 | 约每 3 秒 |
+| A股指数 | index | 000300 | 约每 3 秒 |
+| 港股 | hk_stock | 00700 | 延迟约 15 分钟 |
+| 比特币 | crypto | BTCUSDT | 约每 10 秒 |
+
+## 条件表达式
+
+### 可用变量
+
+- 通用: `price`, `volume`, `change_percent`
+- A股/港股额外: `turnover_rate`
+- 比特币: 不支持 `turnover_rate`
+
+### 示例条件
+
+```javascript
+// 单一条件
+'price >= threshold'
+
+// 多条件
+'price >= threshold and change_percent >= cp_threshold'
+
+// A股专用
+'price >= threshold and turnover_rate >= tr_threshold'
+```
+
+## 产品代码速查
+
+### A股主要指数
+- 沪深300: 000300
+- 上证指数: 000001
+- 创业板指: 399006
+
+### 热门港股
+- 腾讯控股: 00700
+- 阿里巴巴: 09988
+- 美团: 03690
+- 比亚迪股份: 01211
+
+### 主流加密货币
+- 比特币: BTCUSDT

package/src/OpenClawBridgeClient.js

@@ -141,6 +141,10 @@ export class OpenClawBridgeClient extends EventEmitter {
     return this._request('ping', {});
   }
 
+  async queryTickerData(payload) {
+    return this._request('ticker.query', payload || {});
+  }
+
   async waitUntilConnected(timeoutMs = this.waitConnectTimeoutMs) {
     if (this.connected && this.ws && this.ws.readyState === WebSocket.OPEN) {
       return true;

package/src/OpenClawPluginAdapter.js

@@ -94,6 +94,10 @@ export class OpenClawPluginAdapter {
       channelConfigs.call = demand.callConfig;
       if (!channels.includes('call')) channels.push('call');
     }
+    if (demand.smsConfig) {
+      channelConfigs.sms = demand.smsConfig;
+      if (!channels.includes('sms')) channels.push('sms');
+    }
     if (!channels.includes('openclaw')) channels.unshift('openclaw');
     if (!channelConfigs.openclaw) channelConfigs.openclaw = {};
 
@@ -112,6 +116,25 @@ export class OpenClawPluginAdapter {
     return this.client.createWatch(payload);
   }
 
+  /**
+   * 查询标的实时行情（透传到 bridge 的 ticker.query）。
+   */
+  async queryTickerData(query) {
+    const stockCode = query?.stockCode || query?.productCode || query?.stock_code || '';
+    const productType = query?.productType || query?.product_type || '';
+    let market = query?.market;
+
+    if (market == null && String(productType).toLowerCase() === 'crypto') {
+      market = '';
+    }
+
+    return this.client.queryTickerData({
+      stock_code: stockCode,
+      market: market == null ? '' : String(market),
+      product_type: productType
+    });
+  }
+
   async pause(strategyId) {
     return this.client.pauseWatch(strategyId);
   }

package/src/config/runtime-config.js

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import process from 'node:process';
+
+import { ProcessLock } from '../runtime/lock/ProcessLock.js';
+
+const DEFAULT_BASE_WS_URL = 'wss://glanceup-pre.100credit.cn';
+
+function pick(source, keys, fallback = undefined) {
+  for (const key of keys) {
+    const value = source?.[key];
+    if (value !== undefined && value !== null && String(value).trim() !== '') {
+      return value;
+    }
+  }
+  return fallback;
+}
+
+export function resolveRuntimeConfig({ env = process.env, pluginConfig = {} } = {}) {
+  const baseWsUrl = String(
+    pick(pluginConfig, ['baseWsUrl', 'base_ws_url'], pick(env, ['OPENCLAW_BASE_WS_URL'], DEFAULT_BASE_WS_URL))
+  );
+  const token = String(pick(pluginConfig, ['token'], pick(env, ['OPENCLAW_WS_TOKEN'], '')));
+  const lockDir = String(
+    pick(pluginConfig, ['lockDir', 'lock_dir'], pick(env, ['OPENCLAW_LOCK_DIR'], path.join(process.cwd(), '.openclaw-locks')))
+  );
+  const lockKey = ProcessLock.buildLockKey(baseWsUrl, token);
+  if (!token) {
+    throw new Error('token is required');
+  }
+  try {
+    const parsed = new URL(baseWsUrl);
+    if (!parsed.protocol || !parsed.host) {
+      throw new Error('invalid baseWsUrl');
+    }
+    if (parsed.protocol !== 'ws:' && parsed.protocol !== 'wss:') {
+      throw new Error(`invalid baseWsUrl protocol: ${parsed.protocol}`);
+    }
+  } catch (_err) {
+    if (String(_err?.message || '').toLowerCase().includes('protocol')) {
+      throw _err;
+    }
+    throw new Error(`invalid baseWsUrl: ${baseWsUrl}`);
+  }
+  return {
+    baseWsUrl,
+    token,
+    lockDir,
+    lockKey
+  };
+}

package/src/index.js

@@ -1,2 +1,11 @@
 export { OpenClawBridgeClient, getGlobalClient, getInstance, resetGlobalClient } from './OpenClawBridgeClient.js';
-export { OpenClawPluginAdapter, getGlobalAdapter, getAdapter, resetGlobalAdapter } from './OpenClawPluginAdapter.js';
+export { OpenClawPluginAdapter, getGlobalAdapter, getAdapter, resetGlobalAdapter } from './OpenClawPluginAdapter.js';
+export { BridgeRuntime } from './runtime/BridgeRuntime.js';
+export { ProcessLock, SingleActiveConflictError } from './runtime/lock/ProcessLock.js';
+export { PluginDispatcher } from './runtime/dispatchers/PluginDispatcher.js';
+export { resolveRuntimeConfig } from './config/runtime-config.js';
+export {
+  startPluginRuntime,
+  stopPluginRuntime,
+  getActivePluginRuntime
+} from './plugin/index.js';

package/src/plugin/index.js

@@ -0,0 +1,228 @@
+import { resolveRuntimeConfig } from '../config/runtime-config.js';
+import { BridgeRuntime } from '../runtime/BridgeRuntime.js';
+import { PluginDispatcher } from '../runtime/dispatchers/PluginDispatcher.js';
+import { ProcessLock } from '../runtime/lock/ProcessLock.js';
+
+let activeRuntime = null;
+
+function installProcessShutdown(runtime) {
+  const stop = async () => {
+    if (!runtime) return;
+    await runtime.stop().catch(() => {});
+    process.exit(0);
+  };
+  process.once('SIGINT', stop);
+  process.once('SIGTERM', stop);
+}
+
+export function getActivePluginRuntime() {
+  return activeRuntime;
+}
+
+export async function startPluginRuntime({ runtime, pluginConfig } = {}) {
+  if (activeRuntime) {
+    return activeRuntime;
+  }
+  const config = resolveRuntimeConfig({ pluginConfig });
+  const lock = new ProcessLock({
+    lockDir: config.lockDir,
+    key: config.lockKey
+  });
+  const dispatcher = new PluginDispatcher({ runtime });
+  activeRuntime = new BridgeRuntime({
+    baseWsUrl: config.baseWsUrl,
+    token: config.token,
+    dispatcher,
+    lock
+  });
+  await activeRuntime.start();
+  return activeRuntime;
+}
+
+export async function stopPluginRuntime() {
+  if (!activeRuntime) return;
+  await activeRuntime.stop();
+  activeRuntime = null;
+}
+
+async function getReadyRuntime(startupPromise) {
+  await startupPromise;
+  if (!activeRuntime) {
+    throw new Error('plugin runtime is not active');
+  }
+  return activeRuntime;
+}
+
+function mapDemandToCreatePayload(demand = {}) {
+  const channels = Array.isArray(demand.channels)
+    ? demand.channels
+        .filter((x) => typeof x === 'string' && x.trim())
+        .map((x) => x.trim().toLowerCase())
+    : [];
+  const channelConfigs = { ...(demand.channelConfigs || {}) };
+
+  if (demand.openclawConfig) {
+    channelConfigs.openclaw = demand.openclawConfig;
+    if (!channels.includes('openclaw')) channels.push('openclaw');
+  }
+  if (demand.emailConfig) {
+    channelConfigs.email = demand.emailConfig;
+    if (!channels.includes('email')) channels.push('email');
+  }
+  if (demand.callConfig) {
+    channelConfigs.call = demand.callConfig;
+    if (!channels.includes('call')) channels.push('call');
+  }
+  if (demand.smsConfig) {
+    channelConfigs.sms = demand.smsConfig;
+    if (!channels.includes('sms')) channels.push('sms');
+  }
+  if (!channels.includes('openclaw')) channels.unshift('openclaw');
+  if (!channelConfigs.openclaw) channelConfigs.openclaw = {};
+
+  return {
+    product_code: demand.productCode || demand.product_code,
+    product_type: demand.productType || demand.product_type || 'stock',
+    operator_type: 'rule',
+    operator_parameters: {
+      condition: demand.condition,
+      variables: demand.variables || {},
+      message_template: demand.messageTemplate || demand.message_template
+    },
+    channels,
+    channel_configs: channelConfigs
+  };
+}
+
+function buildControlApi(startupPromise) {
+  return {
+    async queryTickerData(query = {}) {
+      const runtime = await getReadyRuntime(startupPromise);
+      const stockCode = query.stockCode || query.productCode || query.stock_code || '';
+      const productType = query.productType || query.product_type || '';
+      let market = query.market;
+      if (market == null && String(productType).toLowerCase() === 'crypto') {
+        market = '';
+      }
+      return runtime.request('ticker.query', {
+        stock_code: stockCode,
+        market: market == null ? '' : String(market),
+        product_type: productType
+      });
+    },
+    async createWatch(payload = {}) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.create', payload);
+    },
+    async submitWatchDemand(demand = {}) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.create', mapDemandToCreatePayload(demand));
+    },
+    async pauseWatch(strategyId) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.pause', { strategy_id: strategyId });
+    },
+    async activateWatch(strategyId) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.activate', { strategy_id: strategyId });
+    },
+    async deleteWatch(strategyId) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.delete', { strategy_id: strategyId });
+    }
+  };
+}
+
+function tryRegisterTool(registerTool, name, description, handler) {
+  if (typeof registerTool !== 'function') return;
+  const def = {
+    name,
+    description,
+    handler,
+    execute: async (_toolCallId, params) => handler(params || {})
+  };
+  const meta = {
+    name,
+    description
+  };
+
+  // OpenClaw-style: registerTool(def, meta)
+  try {
+    registerTool(def, meta);
+    return;
+  } catch (_err) {
+    // try one-arg object signature
+  }
+
+  try {
+    registerTool(def);
+    return;
+  } catch (_err) {
+    // try alternate host signature: (name, handler)
+  }
+
+  try {
+    registerTool(name, handler);
+  } catch (_err) {
+    // ignore host differences
+  }
+}
+
+function registerControlTools(api, controlApi) {
+  const registerTool = api?.registerTool || api?.runtime?.registerTool;
+  tryRegisterTool(registerTool, 'watch.query_ticker', 'Query ticker data', (args) =>
+    controlApi.queryTickerData(args || {})
+  );
+  tryRegisterTool(registerTool, 'watch.create', 'Create watch strategy', (args) =>
+    controlApi.createWatch(args || {})
+  );
+  tryRegisterTool(registerTool, 'watch.pause', 'Pause watch strategy', (args) =>
+    controlApi.pauseWatch(args?.strategyId || args?.strategy_id)
+  );
+  tryRegisterTool(registerTool, 'watch.activate', 'Activate watch strategy', (args) =>
+    controlApi.activateWatch(args?.strategyId || args?.strategy_id)
+  );
+  tryRegisterTool(registerTool, 'watch.remove', 'Delete watch strategy', (args) =>
+    controlApi.deleteWatch(args?.strategyId || args?.strategy_id)
+  );
+}
+
+const plugin = {
+  id: 'glance-bridge',
+  name: 'Glance Bridge Channel',
+  description: 'OpenClaw bridge long connection plugin',
+  register(api) {
+    const pluginConfig =
+      api?.config?.channels?.['glance-bridge'] ||
+      api?.config?.channels?.glanceBridge ||
+      api?.config?.glanceBridge ||
+      {};
+
+    const startupPromise = startPluginRuntime({
+      runtime: api?.runtime,
+      pluginConfig
+    });
+    startupPromise.catch((err) => {
+      api?.runtime?.logger?.error?.(`[glance-bridge] runtime start failed: ${err.message}`);
+    });
+
+    const controlApi = buildControlApi(startupPromise);
+    api.glanceBridge = controlApi;
+    registerControlTools(api, controlApi);
+
+    if (typeof api?.onShutdown === 'function') {
+      api.onShutdown(async () => {
+        await startupPromise.catch(() => {});
+        await stopPluginRuntime();
+      });
+    } else {
+      startupPromise
+        .then((runtime) => {
+          installProcessShutdown(runtime);
+        })
+        .catch(() => {});
+    }
+  }
+};
+
+export default plugin;

package/src/runtime/BridgeRuntime.js

@@ -0,0 +1,254 @@
+import EventEmitter from 'node:events';
+import WebSocket from 'ws';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function makeRequestId() {
+  return `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export class BridgeRuntime extends EventEmitter {
+  constructor({
+    baseWsUrl,
+    token,
+    dispatcher,
+    lock,
+    heartbeatMs = 15000,
+    requestTimeoutMs = 10000,
+    reconnect = true,
+    reconnectBaseMs = 1000,
+    reconnectMaxMs = 15000,
+    enqueueIfDisconnected = true,
+    maxQueueSize = 200
+  }) {
+    super();
+    if (!baseWsUrl) throw new Error('baseWsUrl is required');
+    if (!token) throw new Error('token is required');
+    this.baseWsUrl = baseWsUrl.replace(/\/$/, '');
+    this.token = token;
+    this.dispatcher = dispatcher;
+    this.lock = lock;
+
+    this.heartbeatMs = heartbeatMs;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.reconnect = reconnect;
+    this.reconnectBaseMs = reconnectBaseMs;
+    this.reconnectMaxMs = reconnectMaxMs;
+    this.enqueueIfDisconnected = enqueueIfDisconnected;
+    this.maxQueueSize = maxQueueSize;
+
+    this.ws = null;
+    this.connected = false;
+    this.stopped = false;
+    this.reconnectAttempt = 0;
+    this.heartbeatTimer = null;
+    this.pending = new Map();
+    this.requestQueue = [];
+  }
+
+  get wsUrl() {
+    const url = new URL('/openclaw/ws', this.baseWsUrl);
+    return url.toString();
+  }
+
+  async start() {
+    this.stopped = false;
+    await this.lock?.acquire();
+    try {
+      await this._connectOnce();
+    } catch (err) {
+      await this.lock?.release().catch(() => {});
+      throw err;
+    }
+  }
+
+  async stop() {
+    this.stopped = true;
+    this.connected = false;
+    this._clearHeartbeat();
+    for (const [requestId, waiter] of this.pending.entries()) {
+      clearTimeout(waiter.timer);
+      waiter.reject(new Error(`connection closed before response: ${requestId}`));
+    }
+    this.pending.clear();
+    for (const queued of this.requestQueue) {
+      queued.reject(new Error(`connection closed before request sent: ${queued.requestId}`));
+    }
+    this.requestQueue = [];
+
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch (_err) {
+        // ignore
+      }
+    }
+    await this.lock?.release().catch(() => {});
+  }
+
+  async request(type, payload = {}) {
+    const requestId = makeRequestId();
+    const msg = { type, request_id: requestId, payload };
+    const { promise, resolve, reject } = this._buildWaiter();
+
+    if (!this.connected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      if (!this.enqueueIfDisconnected) {
+        reject(new Error('websocket not connected'));
+        return promise;
+      }
+      if (this.requestQueue.length >= this.maxQueueSize) {
+        reject(new Error(`request queue overflow (max=${this.maxQueueSize})`));
+        return promise;
+      }
+      this.requestQueue.push({ msg, requestId, resolve, reject });
+      return promise;
+    }
+    this._sendWithTimeout({ msg, requestId, resolve, reject });
+    return promise;
+  }
+
+  _buildWaiter() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+
+  _sendWithTimeout({ msg, requestId, resolve, reject }) {
+    const timer = setTimeout(() => {
+      this.pending.delete(requestId);
+      reject(new Error(`request timeout: ${msg.type} (${requestId})`));
+    }, this.requestTimeoutMs);
+
+    this.pending.set(requestId, { resolve, reject, timer });
+    try {
+      this.ws.send(JSON.stringify(msg));
+    } catch (err) {
+      clearTimeout(timer);
+      this.pending.delete(requestId);
+      reject(err);
+    }
+  }
+
+  async _connectOnce() {
+    const ws = new WebSocket(this.wsUrl, {
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const cleanup = () => {
+        ws.off('open', onOpen);
+        ws.off('error', onError);
+      };
+      ws.on('open', onOpen);
+      ws.on('error', onError);
+    });
+
+    this.ws = ws;
+    this.connected = true;
+    this.reconnectAttempt = 0;
+    this.emit('connected');
+    this._startHeartbeat();
+    this._flushQueue();
+
+    ws.on('message', (raw) => {
+      this._onMessage(raw.toString());
+    });
+    ws.on('close', (code, reason) => {
+      void this._onClose(code, reason?.toString());
+    });
+    ws.on('error', (err) => {
+      this.emit('error', err);
+    });
+  }
+
+  _onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch (_err) {
+      this.emit('warning', new Error(`invalid json from bridge: ${raw}`));
+      return;
+    }
+    const requestId = msg.request_id;
+    if (requestId && this.pending.has(requestId)) {
+      const waiter = this.pending.get(requestId);
+      this.pending.delete(requestId);
+      clearTimeout(waiter.timer);
+      waiter.resolve(msg);
+      return;
+    }
+    if (msg.type === 'watch.triggered') {
+      this.dispatcher?.onTriggered?.(msg).catch((err) => this.emit('error', err));
+      this.emit('triggered', msg);
+      return;
+    }
+    this.emit('message', msg);
+  }
+
+  async _onClose(code, reason) {
+    this.connected = false;
+    this._clearHeartbeat();
+    this.emit('disconnected', { code, reason });
+    if (this.stopped || !this.reconnect) {
+      return;
+    }
+    while (!this.stopped) {
+      this.reconnectAttempt += 1;
+      const backoff = Math.min(
+        this.reconnectBaseMs * Math.min(this.reconnectAttempt, 10),
+        this.reconnectMaxMs
+      );
+      this.emit('reconnecting', { attempt: this.reconnectAttempt, backoffMs: backoff });
+      await sleep(backoff);
+      if (this.stopped) return;
+      try {
+        await this._connectOnce();
+        this.emit('reconnected', { attempt: this.reconnectAttempt });
+        return;
+      } catch (err) {
+        this.emit('warning', err);
+      }
+    }
+  }
+
+  _startHeartbeat() {
+    this._clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.connected) return;
+      this.request('ping', {}).catch(() => {});
+    }, this.heartbeatMs);
+  }
+
+  _clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  _flushQueue() {
+    if (!this.connected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    const queued = this.requestQueue.splice(0, this.requestQueue.length);
+    for (const item of queued) {
+      this._sendWithTimeout(item);
+    }
+  }
+}

package/src/runtime/dispatchers/PluginDispatcher.js

@@ -0,0 +1,18 @@
+export class PluginDispatcher {
+  constructor({ runtime }) {
+    this.runtime = runtime;
+  }
+
+  async onTriggered(event) {
+    if (!this.runtime?.dispatchReply) {
+      return;
+    }
+    await this.runtime.dispatchReply({
+      text: event?.payload?.message || '',
+      metadata: {
+        source: 'watch.triggered',
+        event
+      }
+    });
+  }
+}