foliko 1.1.93 → 2.0.1

package/plugins/{scheduler-plugin.js → core/scheduler/index.js}

@@ -4,14 +4,13 @@
  * 任务触发时自动唤醒 Agent 发送消息
  */
 
-const { Plugin } = require('../src/core/plugin-base')
-const { logger } = require('../src/utils/logger')
+const { Plugin } = require('../../../src/plugin/base')
+const { logger } = require('../../../src/common/logger')
 const log = logger.child('Scheduler')
 const { z } = require('zod')
 const fs = require('fs')
 const path = require('path')
 
-// 尝试加载 node-schedule
 let schedule = null
 try {
   schedule = require('node-schedule')
@@ -19,9 +18,6 @@ try {
   log.warn(' node-schedule not installed, cron tasks will not work')
 }
 
-// ============================================================================
-// TaskStore - 持久化任务到 .foliko/data/scheduler/tasks.json
-// ============================================================================
 class TaskStore {
   constructor(persistencePath) {
     this._persistencePath = persistencePath
@@ -40,7 +36,6 @@ class TaskStore {
 
   saveTasks(tasks) {
     try {
-      // 序列化时移除不可保存的字段（timer, cronTask）
       const serializable = tasks.map(t => ({
         id: t.id,
         name: t.name,
@@ -54,10 +49,10 @@ class TaskStore {
         cronExpression: t.cronExpression,
         sessionId: t.sessionId,
         llm: t.llm,
-        persistDelay: t.persistDelay,  // 相对时间的延迟毫秒数
-        persistNextRun: t.persistNextRun,  // 下次执行时间
-        notify: t.notify,  // 是否发送通知
-        shell: t.shell  // Shell 命令
+        persistDelay: t.persistDelay,
+        persistNextRun: t.persistNextRun,
+        notify: t.notify,
+        shell: t.shell
       }))
       fs.writeFileSync(this._getTasksPath(), JSON.stringify(serializable, null, 2))
     } catch (err) {
@@ -79,7 +74,6 @@ class TaskStore {
   }
 }
 
-// 时间解析辅助函数
 function parseDelay(delayStr) {
   const match = delayStr.match(/^(\d+)\s*(second|minute|hour|day|week)s?$/i)
   if (!match) return null
@@ -97,7 +91,6 @@ function parseDelay(delayStr) {
 
 function parseAtTime(timeStr) {
   const now = new Date()
-  // 简单时间格式 "12:00"
   const timeMatch = timeStr.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/)
   if (timeMatch) {
     const date = new Date(now)
@@ -110,9 +103,6 @@ function parseAtTime(timeStr) {
   return new Date(timeStr)
 }
 
-/**
- * 生成唯一 ID
- */
 function generateId() {
   if (require('crypto').randomUUID) {
     return require('crypto').randomUUID()
@@ -129,7 +119,7 @@ class SchedulerPlugin extends Plugin {
     this.priority = 15
     this.system = true
     this.config = {
-      checkInterval: config.checkInterval || 1000,  // 每秒检查一次
+      checkInterval: config.checkInterval || 1000,
       persistencePath: config.persistencePath || '.foliko/data/scheduler'
     }
 
@@ -148,14 +138,10 @@ class SchedulerPlugin extends Plugin {
 
   install(framework) {
     this._framework = framework
-    // 初始化任务存储
     this._taskStore = new TaskStore(this.config.persistencePath)
     return this
   }
 
-  /**
-   * 获取 Agent 实例
-   */
   _getAgent() {
     if (this._agent) return this._agent
     if (this._framework._mainAgent) {
@@ -168,10 +154,8 @@ class SchedulerPlugin extends Plugin {
   }
 
   start(framework) {
-    // 获取 Agent 实例
     this._agent = this._getAgent()
 
-    // 注册调度工具
     framework.registerTool({
       name: 'schedule_task',
       description: '设置定时提醒任务。支持多种时间格式：相对时间(1 minute, 2 hours)、具体时间(12:00)、Cron表达式(* * * * *)。系统会自动判断任务是否需要 LLM 处理。',
@@ -194,7 +178,6 @@ class SchedulerPlugin extends Plugin {
             return { success: false, error: 'Agent not available' }
           }
 
-          // 如果指定了 shell 命令，创建 Shell 任务
           if (shell) {
             const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
             const isCron = /^[\d*,\/-\s]+$/.test(scheduleTime) && scheduleTime.split(' ').length >= 5
@@ -240,7 +223,6 @@ class SchedulerPlugin extends Plugin {
                 }
               }
             } else {
-              // 一次性 Shell 任务
               const delayMs = parseDelay(scheduleTime)
               if (!delayMs && !scheduleTime.includes(':')) {
                 return { success: false, error: '无效的时间格式' }
@@ -293,7 +275,6 @@ class SchedulerPlugin extends Plugin {
             }
           }
 
-          // 如果没有指定 sessionId，优先从执行上下文获取（来自 WeChat 等消息源）
           let targetSessionId = sessionId
           if (!targetSessionId) {
             const ctx = this._framework.getExecutionContext()
@@ -301,21 +282,17 @@ class SchedulerPlugin extends Plugin {
               targetSessionId = ctx.sessionId
             }
           }
-          // 如果执行上下文也没有，从 sessionPlugin 获取最近活跃会话
           if (!targetSessionId) {
             const sessionPlugin = this._framework.pluginManager.get('session')
             if (sessionPlugin) {
               const sessions = sessionPlugin.listSessions()
-              // 获取最近的活跃会话
               if (sessions.length > 0) {
-                // 按 lastActive 排序，取最新的
                 sessions.sort((a, b) => {
                   const aTime = a.lastActive ? new Date(a.lastActive).getTime() : 0
                   const bTime = b.lastActive ? new Date(b.lastActive).getTime() : 0
                   return bTime - aTime
                 })
                 targetSessionId = sessions[0].id
-                //log.info(` Auto-detected active session: ${targetSessionId}`)
               }
             }
           }
@@ -323,7 +300,6 @@ class SchedulerPlugin extends Plugin {
           const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
           let task
 
-          // 自动检测是否需要 LLM 处理
           const LLM_KEYWORDS = [
             '分析', '查询', '查看', '检查', '总结', '搜索', '获取',
             'list', 'get', 'check', 'search', 'find', 'fetch',
@@ -336,11 +312,9 @@ class SchedulerPlugin extends Plugin {
           )
           const llmMode = needsLLM
 
-          // 检测是否像 Cron 表达式
           const isCron = /^[\d*,\/-\s]+$/.test(scheduleTime) && scheduleTime.split(' ').length >= 5
 
           if (isCron || repeat) {
-            // Cron 任务
             if (!schedule) {
               return { success: false, error: 'node-schedule not installed' }
             }
@@ -358,15 +332,13 @@ class SchedulerPlugin extends Plugin {
               cronTask: null,
               sessionId: targetSessionId || null,
               llm: llmMode,
-              notify: args.notify !== false  // 默认发送通知
+              notify: args.notify !== false
             }
 
-            // 使用 node-schedule 调度
             task.cronTask = schedule.scheduleJob(task.cronExpression, async () => {
               await this._executeTask(task)
             })
           } else if (scheduleTime.includes(':')) {
-            // 具体时间
             const runAt = parseAtTime(scheduleTime)
             task = {
               id: taskId,
@@ -387,7 +359,6 @@ class SchedulerPlugin extends Plugin {
               await this._executeTask(task)
             }, runAt.getTime() - Date.now())
           } else {
-            // 相对时间
             const delayMs = parseDelay(scheduleTime)
             if (!delayMs) {
               return { success: false, error: '无效的时间格式' }
@@ -406,7 +377,7 @@ class SchedulerPlugin extends Plugin {
               timer: null,
               sessionId: targetSessionId || null,
               llm: llmMode,
-              persistDelay: delayMs,  // 保存延迟毫秒数用于持久化
+              persistDelay: delayMs,
               notify: args.notify !== false
             }
             task.timer = setTimeout(async () => {
@@ -416,9 +387,8 @@ class SchedulerPlugin extends Plugin {
 
           this._tasks.set(task.id, task)
           this._taskStats.total++
-          this._saveTasks()  // 持久化
+          this._saveTasks()
 
-          // 发送任务创建事件
           this._framework.emit('scheduler:task_created', {
             taskId: task.id,
             taskName: task.name,
@@ -489,9 +459,8 @@ class SchedulerPlugin extends Plugin {
 
         const taskName = task.name
         this._cancelTask(task)
-        this._saveTasks()  // 持久化
+        this._saveTasks()
 
-        // 发送任务取消通知
         this._framework.emit('notification', {
           title: '任务已取消',
           message: `定时任务 "${taskName}" 已取消`,
@@ -528,18 +497,13 @@ class SchedulerPlugin extends Plugin {
       }
     })
 
-    // 启动调度循环（用于检查一次性任务）
     this._startScheduler()
 
-    // 加载持久化的任务
     this._loadPersistedTasks()
 
     return this
   }
 
-  /**
-   * 启动调度循环
-   */
   _startScheduler() {
     if (this._timer) {
       clearInterval(this._timer)
@@ -550,46 +514,31 @@ class SchedulerPlugin extends Plugin {
     }, this.config.checkInterval)
   }
 
-  /**
-   * 检查任务状态（主要用于更新 stats）
-   */
   _checkTasks() {
     for (const [id, task] of this._tasks) {
       if (!task.enabled) continue
-      // 统计信息更新
     }
   }
 
-  /**
-   * 保存任务到持久化存储
-   */
   _saveTasks() {
     if (this._taskStore) {
       this._taskStore.saveTasks(Array.from(this._tasks.values()))
     }
   }
 
-  /**
-   * 加载持久化的任务并重新调度
-   */
   _loadPersistedTasks() {
     if (!this._taskStore) return
 
     const savedTasks = this._taskStore.loadTasks()
     if (!savedTasks || savedTasks.length === 0) return
 
-    //log.info(` 加载 ${savedTasks.length} 个持久化任务...`)
-
     for (const saved of savedTasks) {
-      // 跳过已过期的任务或已清理的任务
       if (saved.type === 'once' && saved.runCount > 0) {
-        //log.info(` 跳过已完成的一次性任务: ${saved.name}`)
         continue
       }
 
       let task = { ...saved }
 
-      // 重新调度 Cron 任务
       if (task.type === 'cron' && task.enabled && schedule) {
         try {
           task.cronTask = schedule.scheduleJob(task.cronExpression, async () => {
@@ -597,12 +546,10 @@ class SchedulerPlugin extends Plugin {
           })
           this._tasks.set(task.id, task)
           this._taskStats.total++
-          //log.info(` 已恢复 Cron 任务: ${task.name}`)
         } catch (err) {
           log.error(` 恢复 Cron 任务失败: ${task.name}`, err.message)
         }
       }
-      // 重新调度 Cron Shell 任务
       else if (task.type === 'shell' && task.enabled && task.cronExpression && schedule) {
         try {
           task.cronTask = schedule.scheduleJob(task.cronExpression, async () => {
@@ -610,12 +557,10 @@ class SchedulerPlugin extends Plugin {
           })
           this._tasks.set(task.id, task)
           this._taskStats.total++
-          //log.info(` 已恢复 Shell Cron 任务: ${task.name}`)
         } catch (err) {
           log.error(` 恢复 Shell Cron 任务失败: ${task.name}`, err.message)
         }
       }
-      // 重新调度相对时间任务（计算新的执行时间）
       else if (task.type === 'once' && task.enabled && task.persistDelay) {
         const newDelay = task.persistDelay
         if (newDelay > 0) {
@@ -625,10 +570,8 @@ class SchedulerPlugin extends Plugin {
           }, newDelay)
           this._tasks.set(task.id, task)
           this._taskStats.total++
-          //log.info(` 已恢复一次性任务: ${task.name}，将在 ${newDelay}ms 后执行`)
         }
       }
-      // 重新调度绝对时间任务
       else if (task.type === 'once' && task.enabled && task.runAt) {
         const runAt = new Date(task.runAt)
         if (runAt > new Date()) {
@@ -638,17 +581,11 @@ class SchedulerPlugin extends Plugin {
           }, delay)
           this._tasks.set(task.id, task)
           this._taskStats.total++
-          //log.info(` 已恢复一次性任务: ${task.name}，将在 ${runAt} 执行`)
-        } else {
-          //log.info(` 跳过已过期的任务: ${task.name}`)
         }
       }
     }
   }
 
-  /**
-   * 取消任务
-   */
   _cancelTask(task) {
     if (task.timer) {
       clearTimeout(task.timer)
@@ -661,23 +598,12 @@ class SchedulerPlugin extends Plugin {
     task.enabled = false
   }
 
-  /**
-   * 执行任务
-   */
   async _executeTask(task) {
-    // //log.info(` Executing task: ${task.name} (${task.id})`)
-    // //log.info(` Message: ${task.message}`)
-    // // if (task.sessionId) {
-    // //   //log.info(` Target session: ${task.sessionId}`)
-    // // }
-    // //log.info(` LLM mode: ${task.llm ? 'enabled' : 'disabled'}`)
-
     task.lastRun = new Date()
     task.runCount++
     this._taskStats.running++
 
     try {
-      // Shell 命令执行模式
       if (task.type === 'shell') {
         const result = await this._framework.executeTool('shell', { command: task.shell })
         this._taskStats.completed++
@@ -705,7 +631,6 @@ class SchedulerPlugin extends Plugin {
 
         return { success: true }
       } else if (task.llm) {
-        // LLM 模式：使用子Agent处理
         const schedulerAgent = this._framework.createSubAgent({
           name: 'scheduler_task',
           role: '定时任务执行助手，专注于处理定时提醒和任务执行'
@@ -715,17 +640,9 @@ class SchedulerPlugin extends Plugin {
 
         this._taskStats.completed++
 
-        // 获取 LLM 返回的消息
         const responseText = result.message
 
-        // if (responseText) {
-        //   console.log(`\n🔔 [定时提醒] ${responseText}\n`)
-        // }
-
-        // 根据 notify 参数决定是否发送通知
-        // 只有当 LLM 返回了有效消息时才发送通知
         if (task.notify !== false && responseText && responseText.trim()) {
-          // 发送统一的通知事件
           this._framework.emit('notification', {
             title: task.name,
             message: responseText,
@@ -734,7 +651,6 @@ class SchedulerPlugin extends Plugin {
             sessionId: task.sessionId,
             timestamp: new Date()
           })
-          // 发送 scheduler:reminder 事件
           this._framework.emit('scheduler:reminder', {
             taskId: task.id,
             message: task.message,
@@ -742,16 +658,12 @@ class SchedulerPlugin extends Plugin {
           })
         }
 
-        // 发送任务完成事件
         this._framework.emit('scheduler:task_completed', {
           taskId: task.id,
           result: responseText || task.message
         })
       } else {
-        // 直接显示模式：只显示提醒，不发 LLM
-        // 根据 notify 参数决定是否发送通知
         if (task.notify !== false) {
-          // 发送统一的通知事件
           this._framework.emit('notification', {
             title: task.name,
             message: task.message,
@@ -760,7 +672,6 @@ class SchedulerPlugin extends Plugin {
             sessionId: task.sessionId,
             timestamp: new Date()
           })
-          // 发送 scheduler:reminder 事件
           this._framework.emit('scheduler:reminder', {
             taskId: task.id,
             message: task.message,
@@ -768,7 +679,6 @@ class SchedulerPlugin extends Plugin {
           })
         }
 
-        // 发送任务完成事件
         this._framework.emit('scheduler:task_completed', {
           taskId: task.id,
           result: task.message
@@ -776,7 +686,6 @@ class SchedulerPlugin extends Plugin {
         this._taskStats.completed++
       }
 
-      // 一次性任务执行后清理
       if (task.type === 'once' && !task.cronTask) {
         this._cleanupTask(task.id)
       }
@@ -786,7 +695,6 @@ class SchedulerPlugin extends Plugin {
       this._taskStats.failed++
       log.error(` Task ${task.name} failed: ${err.message}`)
 
-      // 发送统一的通知事件
       this._framework.emit('notification', {
         title: `任务失败: ${task.name}`,
         message: err.message,
@@ -796,13 +704,11 @@ class SchedulerPlugin extends Plugin {
         timestamp: new Date()
       })
 
-      // 发送任务失败事件
       this._framework.emit('scheduler:task_failed', {
         taskId: task.id,
         error: err.message
       })
 
-      // 一次性任务失败后也清理
       if (task.type === 'once' && !task.cronTask) {
         this._cleanupTask(task.id)
       }
@@ -813,9 +719,6 @@ class SchedulerPlugin extends Plugin {
     }
   }
 
-  /**
-   * 清理任务
-   */
   _cleanupTask(taskId) {
     const task = this._tasks.get(taskId)
     if (task) {
@@ -828,13 +731,10 @@ class SchedulerPlugin extends Plugin {
         task.cronTask = null
       }
       this._tasks.delete(taskId)
-      this._saveTasks()  // 持久化
+      this._saveTasks()
     }
   }
 
-  /**
-   * 停止所有任务
-   */
   stopAll() {
     for (const task of this._tasks.values()) {
       this._cancelTask(task)
@@ -845,7 +745,6 @@ class SchedulerPlugin extends Plugin {
       this._timer = null
     }
 
-    // 保存状态
     this._saveTasks()
   }
 
@@ -853,7 +752,6 @@ class SchedulerPlugin extends Plugin {
     this._framework = framework
     this._agent = this._getAgent()
     this._startScheduler()
-    // 重新加载持久化任务
     this._loadPersistedTasks()
   }