@cuebot/skill 1.0.5 → 1.0.6

package/src/utils/notificationQueue.js

@@ -1,6 +1,7 @@
 /**
  * 可靠通知队列
- * 本地持久化 + 失败重试机制
+ * 优先使用 OpenClaw Queue，本地队列作为 fallback
+ * 支持自动重试和统计
  */
 
 import fs from 'fs-extra';
@@ -10,302 +11,189 @@ import { createLogger } from '../core/logger.js';
 
 const logger = createLogger('NotificationQueue');
 
+const MAX_RETRY = 3;
+const RETRY_DELAYS = [5000, 15000, 60000]; // 重试延迟: 5s, 15s, 60s
+
+/**
+ * 检测是否在 OpenClaw 环境中
+ */
+function isOpenClawEnv() {
+  return process.env.OPENCLAW_MODE === 'gateway' || 
+         process.env.OPENCLAW_GATEWAY_PORT ||
+         process.env.OPENCLAW_HOME;
+}
+
 /**
- * 获取通知队列目录
- * @param {string} chatId 
- * @returns {string}
+ * 获取通知队列目录 (本地 fallback)
  */
-function getQueueDir(chatId) {
+function getLocalQueueDir(chatId) {
   return path.join(getUserDir(chatId), 'notification-queue');
 }
 
 /**
- * 初始化队列目录
- * @param {string} chatId 
+ * 初始化队列目录 (本地 fallback)
  */
 async function initQueue(chatId) {
-  const queueDir = getQueueDir(chatId);
-  await fs.ensureDir(queueDir);
+  if (isOpenClawEnv()) return;
   
-  // 创建子目录
+  const queueDir = getLocalQueueDir(chatId);
+  await fs.ensureDir(queueDir);
   await fs.ensureDir(path.join(queueDir, 'pending'));
   await fs.ensureDir(path.join(queueDir, 'failed'));
   await fs.ensureDir(path.join(queueDir, 'sent'));
+  await fs.ensureDir(path.join(queueDir, 'processing'));
 }
 
-/**
- * 生成通知 ID
- * @returns {string}
- */
 function generateNotificationId() {
   return `notif_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
 }
 
 /**
  * 添加通知到队列
- * @param {Object} notification 
- * @param {string} notification.chatId 
- * @param {string} notification.type - 类型: 'research_complete', 'monitor_trigger', 'progress'
- * @param {Object} notification.data - 通知数据
- * @returns {Promise<string>} 通知 ID
  */
-export async function enqueueNotification({ chatId, type, data }) {
+export async function enqueueNotification(notification) {
+  const { chatId, type, data } = notification;
+  
+  if (isOpenClawEnv()) {
+    try {
+      const { execSync } = await import('child_process');
+      const queueName = `cue-notifications-${chatId}`;
+      execSync(`openclaw queue add ${queueName} "${JSON.stringify(notification).replace(/"/g, '\\"')}"`, {
+        stdio: 'ignore'
+      });
+      logger.info(`Notification enqueued to OpenClaw Queue: ${queueName}`);
+      return generateNotificationId();
+    } catch (err) {
+      logger.warn('OpenClaw Queue failed, using local fallback');
+    }
+  }
+  
+  const queueDir = getLocalQueueDir(chatId);
   await initQueue(chatId);
   
-  const notificationId = generateNotificationId();
-  const notification = {
-    id: notificationId,
-    chat_id: chatId,
+  const notifId = generateNotificationId();
+  const filePath = path.join(queueDir, 'pending', `${notifId}.json`);
+  
+  await fs.writeJson(filePath, {
+    id: notifId,
+    chatId,
     type,
     data,
-    status: 'pending',
     created_at: new Date().toISOString(),
     retry_count: 0,
-    max_retries: 3
-  };
-  
-  const queueDir = getQueueDir(chatId);
-  const filePath = path.join(queueDir, 'pending', `${notificationId}.json`);
-  
-  await fs.writeJson(filePath, notification, { spaces: 2 });
-  await logger.info(`Notification enqueued: ${notificationId} (${type})`);
+    max_retry: MAX_RETRY
+  }, { spaces: 2 });
   
-  return notificationId;
+  logger.info(`Notification enqueued locally: ${notifId}`);
+  return notifId;
 }
 
 /**
- * 获取待发送通知
- * @param {string} chatId 
- * @returns {Promise<Array>}
+ * 获取队列统计
  */
-export async function getPendingNotifications(chatId) {
-  try {
-    const queueDir = getQueueDir(chatId);
-    const pendingDir = path.join(queueDir, 'pending');
-    
-    const files = await fs.readdir(pendingDir);
-    const notifications = [];
-    
-    for (const file of files.filter(f => f.endsWith('.json'))) {
-      try {
-        const notif = await fs.readJson(path.join(pendingDir, file));
-        if (notif.status === 'pending') {
-          notifications.push(notif);
-        }
-      } catch (e) {
-        // 忽略读取错误
-      }
-    }
-    
-    // 按创建时间排序
-    return notifications.sort((a, b) => 
-      new Date(a.created_at) - new Date(b.created_at)
-    );
-  } catch (error) {
-    return [];
+export async function getQueueStats(chatId) {
+  if (isOpenClawEnv()) {
+    try {
+      const { execSync } = await import('child_process');
+      const result = execSync(`openclaw queue status cue-notifications-${chatId}`, {
+        encoding: 'utf-8'
+      });
+      return { source: 'openclaw', stats: result };
+    } catch {}
   }
-}
-
-/**
- * 标记通知为已发送
- * @param {string} chatId 
- * @param {string} notificationId 
- */
-export async function markNotificationSent(chatId, notificationId) {
-  try {
-    const queueDir = getQueueDir(chatId);
-    const pendingPath = path.join(queueDir, 'pending', `${notificationId}.json`);
-    const sentPath = path.join(queueDir, 'sent', `${notificationId}.json`);
-    
-    // 读取并更新状态
-    const notification = await fs.readJson(pendingPath);
-    notification.status = 'sent';
-    notification.sent_at = new Date().toISOString();
-    
-    // 移动到 sent 目录
-    await fs.writeJson(sentPath, notification, { spaces: 2 });
-    await fs.remove(pendingPath);
-    
-    await logger.info(`Notification marked as sent: ${notificationId}`);
-  } catch (error) {
-    await logger.error(`Failed to mark notification as sent: ${notificationId}`, error);
-  }
-}
-
-/**
- * 标记通知为失败
- * @param {string} chatId 
- * @param {string} notificationId 
- * @param {string} error 
- */
-export async function markNotificationFailed(chatId, notificationId, error) {
-  try {
-    const queueDir = getQueueDir(chatId);
-    const pendingPath = path.join(queueDir, 'pending', `${notificationId}.json`);
-    const failedPath = path.join(queueDir, 'failed', `${notificationId}.json`);
-    
-    // 读取通知
-    const notification = await fs.readJson(pendingPath);
-    notification.retry_count++;
-    notification.last_error = error;
-    notification.last_attempt = new Date().toISOString();
-    
-    if (notification.retry_count >= notification.max_retries) {
-      // 超过最大重试次数，移动到失败目录
-      notification.status = 'failed';
-      await fs.writeJson(failedPath, notification, { spaces: 2 });
-      await fs.remove(pendingPath);
-      await logger.warn(`Notification failed permanently: ${notificationId} (${notification.retry_count} retries)`);
-    } else {
-      // 更新重试计数，保留在 pending 目录
-      await fs.writeJson(pendingPath, notification, { spaces: 2 });
-      await logger.info(`Notification retry scheduled: ${notificationId} (attempt ${notification.retry_count})`);
-    }
-  } catch (err) {
-    await logger.error(`Failed to mark notification failed: ${notificationId}`, err);
-  }
-}
-
-/**
- * 获取需要重试的通知
- * @param {string} chatId 
- * @returns {Promise<Array>}
- */
-export async function getNotificationsForRetry(chatId) {
-  const pending = await getPendingNotifications(chatId);
-  const now = Date.now();
   
-  return pending.filter(notif => {
-    if (notif.retry_count === 0) return true;
-    
-    // 指数退避：1分钟, 5分钟, 25分钟
-    const backoffMinutes = Math.pow(5, notif.retry_count - 1);
-    const lastAttempt = new Date(notif.last_attempt || notif.created_at).getTime();
-    const nextRetry = lastAttempt + (backoffMinutes * 60 * 1000);
-    
-    return now >= nextRetry;
-  });
+  const queueDir = getLocalQueueDir(chatId);
+  const pending = await fs.readdir(path.join(queueDir, 'pending')).catch(() => []);
+  const failed = await fs.readdir(path.join(queueDir, 'failed')).catch(() => []);
+  const sent = await fs.readdir(path.join(queueDir, 'sent')).catch(() => []);
+  const processing = await fs.readdir(path.join(queueDir, 'processing')).catch(() => []);
+  
+  // 计算总处理数
+  const totalProcessed = sent.length + failed.length;
+  const successRate = totalProcessed > 0 ? ((sent.length / totalProcessed) * 100).toFixed(1) : 0;
+  
+  return {
+    source: 'local',
+    pending: pending.length,
+    processing: processing.length,
+    failed: failed.length,
+    sent: sent.length,
+    totalProcessed,
+    successRate: `${successRate}%`,
+    lastUpdated: new Date().toISOString()
+  };
 }
 
 /**
- * 获取失败通知列表
- * @param {string} chatId 
- * @param {number} limit 
- * @returns {Promise<Array>}
+ * 处理失败重试
  */
-export async function getFailedNotifications(chatId, limit = 10) {
-  try {
-    const queueDir = getQueueDir(chatId);
-    const failedDir = path.join(queueDir, 'failed');
-    
-    const files = await fs.readdir(failedDir);
-    const notifications = [];
-    
-    for (const file of files.filter(f => f.endsWith('.json')).slice(0, limit)) {
-      try {
-        const notif = await fs.readJson(path.join(failedDir, file));
-        notifications.push(notif);
-      } catch (e) {
-        // 忽略
-      }
-    }
-    
-    return notifications.sort((a, b) => 
-      new Date(b.created_at) - new Date(a.created_at)
-    );
-  } catch (error) {
-    return [];
+async function handleFailed(notif, queueDir) {
+  const filePath = path.join(queueDir, 'failed', `${notif.id}.json`);
+  const failedPath = path.join(queueDir, 'failed', `${notif.id}.json`);
+  
+  // 检查重试次数
+  if (notif.retry_count >= MAX_RETRY) {
+    logger.warn(`Notification ${notif.id} exceeded max retries, moving to dead letter`);
+    await fs.move(failedPath, path.join(queueDir, 'dead', `${notif.id}.json`));
+    return;
   }
+  
+  // 延迟重试
+  const delay = RETRY_DELAYS[notif.retry_count] || RETRY_DELAYS[RETRY_DELAYS.length - 1];
+  notif.retry_count++;
+  notif.next_retry_at = new Date(Date.now() + delay).toISOString();
+  
+  await fs.writeJson(failedPath, notif, { spaces: 2 });
+  logger.info(`Notification ${notif.id} scheduled for retry ${notif.retry_count}/${MAX_RETRY}`);
 }
 
 /**
- * 清理已发送通知（保留最近7天）
- * @param {string} chatId 
+ * 启动通知处理器 - 支持自动重试
  */
-export async function cleanupSentNotifications(chatId) {
-  try {
-    const queueDir = getQueueDir(chatId);
-    const sentDir = path.join(queueDir, 'sent');
-    
-    const files = await fs.readdir(sentDir);
-    const cutoff = Date.now() - (7 * 24 * 60 * 60 * 1000); // 7天前
-    
-    let cleaned = 0;
-    for (const file of files.filter(f => f.endsWith('.json'))) {
-      try {
-        const notif = await fs.readJson(path.join(sentDir, file));
-        const sentAt = new Date(notif.sent_at || notif.created_at).getTime();
-        
-        if (sentAt < cutoff) {
-          await fs.remove(path.join(sentDir, file));
-          cleaned++;
-        }
-      } catch (e) {
-        // 忽略
-      }
-    }
-    
-    if (cleaned > 0) {
-      await logger.info(`Cleaned up ${cleaned} old sent notifications`);
-    }
-  } catch (error) {
-    await logger.error('Failed to cleanup sent notifications', error);
+export async function startNotificationProcessor(chatId, handler) {
+  if (isOpenClawEnv()) {
+    logger.info('Using OpenClaw Queue processor');
+    return;
   }
-}
-
-/**
- * 启动后台通知处理器
- * @param {string} chatId 
- * @param {Function} sendFn - 实际发送函数
- */
-export function startNotificationProcessor(chatId, sendFn) {
-  // 立即处理一次
-  processNotificationQueue(chatId, sendFn);
-  
-  // 每30秒检查一次队列
-  const intervalId = setInterval(() => {
-    processNotificationQueue(chatId, sendFn);
-  }, 30000);
   
-  // 每小时清理一次已发送通知
-  const cleanupInterval = setInterval(() => {
-    cleanupSentNotifications(chatId);
-  }, 60 * 60 * 1000);
+  const queueDir = getLocalQueueDir(chatId);
   
-  return {
-    stop: () => {
-      clearInterval(intervalId);
-      clearInterval(cleanupInterval);
-    }
-  };
-}
-
-/**
- * 处理通知队列
- * @param {string} chatId 
- * @param {Function} sendFn 
- */
-async function processNotificationQueue(chatId, sendFn) {
-  try {
-    const notifications = await getNotificationsForRetry(chatId);
+  const processQueue = async () => {
+    const pending = await fs.readdir(path.join(queueDir, 'pending')).catch(() => []);
     
-    for (const notif of notifications) {
+    for (const file of pending) {
       try {
-        await logger.info(`Processing notification: ${notif.id}`);
+        const filePath = path.join(queueDir, 'pending', file);
+        const notif = await fs.readJson(filePath);
+        
+        // 标记为处理中
+        await fs.move(filePath, path.join(queueDir, 'processing', file));
         
-        // 调用实际发送函数
-        const success = await sendFn(notif);
+        await handler(notif);
         
-        if (success) {
-          await markNotificationSent(chatId, notif.id);
-        } else {
-          await markNotificationFailed(chatId, notif.id, 'Send returned false');
+        // 成功移动到已发送
+        await fs.move(path.join(queueDir, 'processing', file), 
+                      path.join(queueDir, 'sent', file));
+      } catch (err) {
+        logger.error(`Failed to process ${file}:`, err.message);
+        
+        // 处理失败，移至失败队列
+        const procPath = path.join(queueDir, 'processing', file);
+        if (await fs.pathExists(procPath)) {
+          const notif = await fs.readJson(procPath);
+          await handleFailed(notif, queueDir);
         }
-      } catch (error) {
-        await markNotificationFailed(chatId, notif.id, error.message);
       }
     }
-  } catch (error) {
-    await logger.error('Failed to process notification queue', error);
-  }
+  };
+  
+  setInterval(processQueue, 60000);
+  processQueue();
 }
+
+export default {
+  enqueueNotification,
+  getQueueStats,
+  startNotificationProcessor,
+  initQueue
+};

package/src/utils/openclawUtils.js

@@ -26,6 +26,27 @@ export function isOpenClawGateway() {
  * @param {Object} options - 选项
  * @returns {boolean} 是否成功
  */
+/**
+ * 检查 cron 任务是否已存在
+ * @param {string} name - 任务名称
+ * @returns {Promise<boolean>}
+ */
+export async function hasCronTask(name) {
+  if (!isOpenClawGateway()) return false;
+  
+  try {
+    const tasks = listCronTasks();
+    return tasks.some(t => t.name === name);
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 注册 cron 任务（幂等）
+ * @param {Object} options - 选项
+ * @returns {Promise<boolean>} 是否成功（新增或已存在）
+ */
 export async function registerCronTask(options) {
   const { name, message, cron, chatId } = options;
   
@@ -34,13 +55,19 @@ export async function registerCronTask(options) {
     return false;
   }
   
+  // ✅ 幂等检查：先检查是否已存在
+  if (await hasCronTask(name)) {
+    logger.info(`Cron task already exists: ${name}`);
+    return true;
+  }
+  
   try {
     const cmd = [
       'openclaw cron add',
       `--name "${name}"`,
       `--message "${message}"`,
       `--cron "${cron}"`,
-      '--channel feishu',
+      '--channel ${process.env.OPENCLAW_CHANNEL || \'feishu\'}',
       `--to "${chatId}"`,
       '--announce'
     ].join(' ');

package/src/utils/subagentScheduler.js

@@ -0,0 +1,147 @@
+/**
+ * Subagent 调度模块
+ * 支持并行研究和监控后台检查
+ */
+
+import { execSync } from 'child_process';
+import { createLogger } from '../core/logger.js';
+import { isOpenClaw } from './envAdapter.js';
+
+const logger = createLogger('SubagentScheduler');
+
+/**
+ * 启动并行研究任务
+ * @param {Array} topics - 研究主题列表
+ * @returns {Promise<Array>} 任务 ID 列表
+ */
+export async function startParallelResearch(topics) {
+  if (!isOpenClaw()) {
+    logger.warn('Not in OpenClaw environment, cannot start subagent research');
+    return [];
+  }
+  
+  const taskIds = [];
+  
+  for (const topic of topics) {
+    try {
+      const taskId = await startResearchTask(topic);
+      taskIds.push(taskId);
+      logger.info(`Started research task: ${topic} -> ${taskId}`);
+    } catch (error) {
+      logger.error(`Failed to start research for ${topic}:`, error.message);
+    }
+  }
+  
+  return taskIds;
+}
+
+/**
+ * 启动单个研究任务
+ * @param {string} topic - 研究主题
+ * @returns {Promise<string>} 任务 ID
+ */
+async function startResearchTask(topic) {
+  const cmd = [
+    'openclaw agent',
+    '--message', `/cue ${topic}`,
+    '--deliver',
+    '--json'
+  ].join(' ');
+  
+  const output = execSync(cmd, { encoding: 'utf-8' });
+  const result = JSON.parse(output);
+  
+  return result.taskId || result.runId || `research_${Date.now()}`;
+}
+
+/**
+ * 启动监控检查任务
+ * @param {string} chatId - 用户 ID
+ * @returns {Promise<string>} 任务 ID
+ */
+export async function startMonitorCheck(chatId) {
+  if (!isOpenClaw()) {
+    logger.warn('Not in OpenClaw environment, cannot start monitor check');
+    return null;
+  }
+  
+  try {
+    // 使用 sessions_spawn 启动独立检查任务
+    const cmd = [
+      'openclaw sessions spawn',
+      '--label', `monitor_${chatId}`,
+      '--message', `/cm check`,
+      '--timeout', '300'
+    ].join(' ');
+    
+    execSync(cmd, { stdio: 'ignore' });
+    logger.info(`Started monitor check for ${chatId}`);
+    
+    return `monitor_${chatId}_${Date.now()}`;
+  } catch (error) {
+    logger.error('Failed to start monitor check:', error.message);
+    return null;
+  }
+}
+
+/**
+ * 发送消息到 Subagent 会话
+ * @param {string} sessionKey - 会话 key
+ * @param {string} message - 消息
+ * @returns {Promise<boolean>}
+ */
+export async function sendToSession(sessionKey, message) {
+  if (!isOpenClaw()) {
+    return false;
+  }
+  
+  try {
+    const cmd = [
+      'openclaw sessions send',
+      '--session', sessionKey,
+      '--message', message
+    ].join(' ');
+    
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    logger.error(`Failed to send to session ${sessionKey}:`, error.message);
+    return false;
+  }
+}
+
+/**
+ * 列出所有 Subagent 会话
+ * @returns {Promise<Array>}
+ */
+export async function listSessions() {
+  if (!isOpenClaw()) {
+    return [];
+  }
+  
+  try {
+    const output = execSync('openclaw sessions list --json', { encoding: 'utf-8' });
+    return JSON.parse(output || '[]');
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * 终止 Subagent 会话
+ * @param {string} sessionKey - 会话 key
+ * @returns {Promise<boolean>}
+ */
+export async function terminateSession(sessionKey) {
+  if (!isOpenClaw()) {
+    return false;
+  }
+  
+  try {
+    execSync(`openclaw sessions kill ${sessionKey}`, { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    logger.error(`Failed to terminate session ${sessionKey}:`, error.message);
+    return false;
+  }
+}