openclaw-glance-plugin 0.1.15 → 0.1.16

package/README.md

@@ -23,6 +23,7 @@
 - 与 `openclaw-bridge` 建立 WebSocket 长连接
 - 支持请求：`watch.create` / `watch.activate` / `watch.pause` / `watch.delete` / `ticker.query` / `notify.send` / `ping`
 - 支持渠道：`openclaw` / `email` / `call` / `sms` / `dingtalk`
+  - 建议在 `channel_configs.openclaw` 中携带路由字段（如 `channel`、`session_key`、`account_id`、`conversation_id`），便于触发后回推到正确会话
 - 订阅推送：`watch.triggered`
 - 主动发起通知结果推送：`notify.sent`
 - 自动重连 + 心跳
@@ -127,6 +128,7 @@ await adapter.submitWatchDemand({
 
 - `watch_query_ticker`
 - `watch_create`
+- `watch_list`
 - `watch_pause`
 - `watch_activate`
 - `watch_remove`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-glance-plugin",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "OpenClaw plugin client for ticker-monitor openclaw-bridge",
   "type": "module",
   "main": "index.js",

package/skills/glance-watch/SKILL.md

@@ -30,6 +30,7 @@ description: 智能盯盘插件，用于监控A股、港股、比特币等金融
 
 - `watch.query_ticker`
 - `watch.create`
+- `watch.list`
 - `watch.pause`
 - `watch.activate`
 - `watch.remove`
@@ -43,7 +44,8 @@ description: 智能盯盘插件，用于监控A股、港股、比特币等金融
 1. 用户是“查行情”意图：先调用 `watch.query_ticker`
 2. 用户是“盯盘创建”意图：先补齐参数后调用 `watch.create`
 3. 用户是“暂停/恢复/删除”意图：分别调用 `watch.pause` / `watch.activate` / `watch.remove`
-4. 用户是“立即发短信/打电话/发邮件/发钉钉”意图：调用 `notify.sms` / `notify.call` / `notify.email` / `notify.dingtalk`
+4. 用户是“查看策略/查看我的策略/看 active 或 paused 或 completed 策略”意图：调用 `watch.list`
+5. 用户是“立即发短信/打电话/发邮件/发钉钉”意图：调用 `notify.sms` / `notify.call` / `notify.email` / `notify.dingtalk`
 
 禁止跳步：创建盯盘前若缺关键字段必须先追问。
 
@@ -146,6 +148,24 @@ description: 智能盯盘插件，用于监控A股、港股、比特币等金融
 失败处理：
 - 返回失败原因并提示用户确认策略 ID
 
+#### `watch.list`
+
+参数（可选）：
+- `status`：策略状态过滤。可传 `active` / `paused` / `completed` / `failed` / `expired`；不传表示查询该用户全部策略
+- `product_code`（或 `productCode`）：按标的代码过滤
+
+成功判定：
+- 返回 `success = true`
+- `data.total` 为命中策略数，`data.strategies` 为策略列表
+
+失败处理：
+- 返回失败原因，不要静默重试
+- 若筛选条件为空结果，明确告知“当前条件下没有策略”
+
+安全约束（必须）：
+- `watch.list` 只能查询当前连接用户自己的策略
+- 不要尝试通过参数传 `user_id` / `use_id` 越权查询
+
 #### `notify.sms` / `notify.call` / `notify.email` / `notify.dingtalk`
 
 参数：
@@ -188,6 +208,11 @@ description: 智能盯盘插件，用于监控A股、港股、比特币等金融
 回执说明：
 - 直连通知发送完成后，客户端会收到 `notify.sent` 事件（`overall_status/success_count/failed_count/deliveries`）
 
+离线补发识别（`watch.triggered`）：
+- 若事件包含 `delivery_mode = "offline_replay"` 或 `replayed = true`，表示这是用户离线期间触发后补发的消息
+- `trigger_time` 表示原始触发时间，`replayed_at` 表示补发时间
+- 向用户描述时应明确区分：例如“这条是离线期间触发，现已补发到当前会话”
+
 ## 调用判定规则
 
 只有在用户明确表达以下意图时调用插件：

package/src/OpenClawBridgeClient.js

@@ -164,6 +164,10 @@ export class OpenClawBridgeClient extends EventEmitter {
     return this._request('watch.pause', { strategy_id: strategyId });
   }
 
+  async listWatches(payload = {}) {
+    return this._request('watch.list', payload || {});
+  }
+
   async deleteWatch(strategyId) {
     return this._request('watch.delete', { strategy_id: strategyId });
   }

package/src/OpenClawPluginAdapter.js

@@ -150,4 +150,8 @@ export class OpenClawPluginAdapter {
   async remove(strategyId) {
     return this.client.deleteWatch(strategyId);
   }
+
+  async listWatches(params = {}) {
+    return this.client.listWatches(params || {});
+  }
 }

package/src/plugin/index.js

@@ -56,6 +56,52 @@ async function getReadyRuntime(startupPromise) {
   return activeRuntime;
 }
 
+function pickFirstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function deriveOpenclawRouting({ params = {}, context = {} } = {}) {
+  const metadata = context?.event?.metadata || {};
+
+  const channel = pickFirstString(
+    params?.channel,
+    params?.source_channel,
+    metadata?.channel,
+    metadata?.channelId,
+    context?.channel,
+    context?.channelId
+  );
+  const accountId = pickFirstString(params?.account_id, context?.accountId, metadata?.accountId);
+  const sessionKey = pickFirstString(
+    params?.session_key,
+    params?.sessionKey,
+    context?.sessionKey,
+    metadata?.sessionKey
+  );
+  const conversationId = pickFirstString(
+    params?.conversation_id,
+    params?.conversationId,
+    params?.chat_id,
+    params?.chatId,
+    context?.conversationId,
+    metadata?.conversationId,
+    metadata?.chatId,
+    metadata?.groupId
+  );
+
+  const routing = {};
+  if (channel) routing.channel = channel;
+  if (accountId) routing.account_id = accountId;
+  if (sessionKey) routing.session_key = sessionKey;
+  if (conversationId) routing.conversation_id = conversationId;
+  return routing;
+}
+
 function mapDemandToCreatePayload(demand = {}) {
   const channels = Array.isArray(demand.channels)
     ? demand.channels
@@ -101,6 +147,33 @@ function mapDemandToCreatePayload(demand = {}) {
   };
 }
 
+function mergeOpenclawChannelConfig(payload = {}, context = {}) {
+  const merged = { ...(payload || {}) };
+  const channelConfigs = { ...(merged.channel_configs || {}) };
+  const openclawConfig = { ...(channelConfigs.openclaw || {}) };
+  const routing = deriveOpenclawRouting({ params: merged, context });
+
+  if (Object.keys(routing).length === 0) {
+    return merged;
+  }
+
+  channelConfigs.openclaw = {
+    ...openclawConfig,
+    ...routing
+  };
+
+  const channels = Array.isArray(merged.channels)
+    ? merged.channels
+        .filter((x) => typeof x === 'string' && x.trim())
+        .map((x) => x.trim().toLowerCase())
+    : [];
+  if (!channels.includes('openclaw')) channels.unshift('openclaw');
+
+  merged.channels = channels;
+  merged.channel_configs = channelConfigs;
+  return merged;
+}
+
 function buildControlApi(startupPromise) {
   return {
     async queryTickerData(query = {}) {
@@ -117,9 +190,10 @@ function buildControlApi(startupPromise) {
         product_type: productType
       });
     },
-    async createWatch(payload = {}) {
+    async createWatch(payload = {}, context = {}) {
       const runtime = await getReadyRuntime(startupPromise);
-      return runtime.request('watch.create', payload);
+      const normalized = mergeOpenclawChannelConfig(payload, context);
+      return runtime.request('watch.create', normalized);
     },
     async sendNotification(input = {}) {
       const runtime = await getReadyRuntime(startupPromise);
@@ -142,14 +216,19 @@ function buildControlApi(startupPromise) {
     async sendDingtalk(payload = {}) {
       return this.sendNotification({ channel: 'dingtalk', payload });
     },
-    async submitWatchDemand(demand = {}) {
+    async submitWatchDemand(demand = {}, context = {}) {
       const runtime = await getReadyRuntime(startupPromise);
-      return runtime.request('watch.create', mapDemandToCreatePayload(demand));
+      const payload = mapDemandToCreatePayload(demand);
+      return runtime.request('watch.create', mergeOpenclawChannelConfig(payload, context));
     },
     async pauseWatch(strategyId) {
       const runtime = await getReadyRuntime(startupPromise);
       return runtime.request('watch.pause', { strategy_id: strategyId });
     },
+    async listWatches(payload = {}) {
+      const runtime = await getReadyRuntime(startupPromise);
+      return runtime.request('watch.list', payload || {});
+    },
     async activateWatch(strategyId) {
       const runtime = await getReadyRuntime(startupPromise);
       return runtime.request('watch.activate', { strategy_id: strategyId });
@@ -176,7 +255,8 @@ function tryRegisterTool(registerTool, name, description, parameters, handler) {
     parameters: schema,
     inputSchema: schema,
     handler,
-    execute: async (_toolCallId, params) => handler(params || {})
+    execute: async (_toolCallId, params, _onUpdate, context) =>
+      handler(params || {}, { context: context || {} })
   };
   const meta = {
     name,
@@ -289,7 +369,7 @@ function registerControlTools(api, controlApi) {
         channel_configs: { type: 'object' }
       }
     },
-    (args) => controlApi.createWatch(args || {})
+    (args, meta = {}) => controlApi.createWatch(args || {}, meta?.context || {})
   );
 
   const strategySchema = {
@@ -301,6 +381,22 @@ function registerControlTools(api, controlApi) {
     }
   };
 
+  tryRegisterTool(
+    registerTool,
+    'watch_list',
+    'List watch strategies for current user',
+    {
+      type: 'object',
+      additionalProperties: true,
+      properties: {
+        status: { type: 'string' },
+        product_code: { type: 'string' },
+        productCode: { type: 'string' }
+      }
+    },
+    (args) => controlApi.listWatches(args || {})
+  );
+
   tryRegisterTool(
     registerTool,
     'watch_pause',

package/src/runtime/dispatchers/PluginDispatcher.js

@@ -1,3 +1,43 @@
+function pickFirstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function extractRoutingFromTriggeredEvent(event) {
+  const payload = event?.payload || {};
+  const openclaw = payload?.channel_configs?.openclaw || payload?.openclaw || {};
+
+  return {
+    channel: pickFirstString(
+      payload?.channel,
+      payload?.source_channel,
+      openclaw?.channel,
+      openclaw?.source_channel
+    ),
+    accountId: pickFirstString(payload?.account_id, openclaw?.account_id),
+    sessionKey: pickFirstString(
+      payload?.session_key,
+      payload?.sessionKey,
+      openclaw?.session_key,
+      openclaw?.sessionKey
+    ),
+    conversationId: pickFirstString(
+      payload?.conversation_id,
+      payload?.conversationId,
+      payload?.chat_id,
+      payload?.chatId,
+      openclaw?.conversation_id,
+      openclaw?.conversationId,
+      openclaw?.chat_id,
+      openclaw?.chatId
+    )
+  };
+}
+
 export class PluginDispatcher {
   constructor({ runtime }) {
     this.runtime = runtime;
@@ -7,12 +47,22 @@ export class PluginDispatcher {
     if (!this.runtime?.dispatchReply) {
       return;
     }
-    await this.runtime.dispatchReply({
+
+    const routing = extractRoutingFromTriggeredEvent(event);
+    const dispatchPayload = {
       text: event?.payload?.message || '',
       metadata: {
         source: 'watch.triggered',
-        event
+        event,
+        routing
       }
-    });
+    };
+
+    if (routing.channel) dispatchPayload.channel = routing.channel;
+    if (routing.accountId) dispatchPayload.accountId = routing.accountId;
+    if (routing.sessionKey) dispatchPayload.sessionKey = routing.sessionKey;
+    if (routing.conversationId) dispatchPayload.conversationId = routing.conversationId;
+
+    await this.runtime.dispatchReply(dispatchPayload);
   }
 }