foliko 2.0.8 → 2.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",

package/plugins/core/scheduler/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2.0.2
+
+### 修复 (bug fixes)
+
+- **B1 [安全] shell 命令注入** — 移除 `child_process.exec` 兜底路径。shell 任务必须通过 `shell_exec` / `shell` 工具执行，工具不可用时返回错误而非 fallback 到任意命令执行
+- **B2 [功能] enable: true 重新启用后调度失效** — 新增 `task.stopped` 字段显式跟踪 `stop()` 状态（croner 的 `stop()` 不清 handle 引用）。enable 路径检查 `stopped` 强制重建
+- **B3 [功能] `_updateTask` 改坏 cron 表达式后任务半残化** — 改为二阶段提交：先 `new Cron(...)` 验证表达式合法，验证通过才 commit 到 `task`。避免半残状态
+- **B4 [功能] cancel 取消不掉 catchup 触发** — catchup 路径从 `setTimeout` 改为 `new Cron(pastDate, ...)`，croner 的 `stop()` 能真正取消未来触发
+- **B5 [功能] catchup + update 双触发** — 同上修复，统一走 croner handle；update 走 `stop()+new Cron()` 自然替换
+- **B6 [并发] 共享 subagent 并发不安全** — LLM 任务改用 promise-chain 互斥（`_llmMutex`），不同任务排队执行，保护 subagent 内部状态
+
+### 改进
+
+- **M1 DRY** — `_createTask` 复用 `isCronString` helper，消除内联正则重复
+- **M3** — `reload` 清掉未触发的 `_persistTimer` 和重置 `_llmMutex`，避免旧 timer 用空 `_tasks` 写盘
+
+### 行为变更
+
+- `_updateTask` 失败时不再修改 `task` 任何字段（包括 `task.cronExpression`），失败语义更安全
+- `updated` 字段现在返回 `message` / `shell` 的真实值（之前是 `'[updated]'` 误导）
+- `updated.task` 返回包含 `stopped` 字段
+
+## 2.0.1
+
+### 新增
+
+- `schedule_get` 工具：按 ID 获取单个任务的完整详情（与 `schedule_list` 不同，会返回所有内部字段含 `running` / `createdAt` / `runAt` 等）
+- `schedule_update` 工具：修改已存在的任务，可改 `name` / `message` / `scheduleTime` / `cronExpression` / `sessionId` / `llm` / `notify` / `shell` / `enabled`
+  - 改 `scheduleTime` / `cronExpression` 会自动 `stop()` 旧 croner handle 并重建
+  - 改 `shell` 会自动把 `llm` 置为 false（互斥）
+  - 跨类型切换（once → cron / cron → once）会被拒绝，提示先 cancel 再 create
+  - `runCount` / `lastRun` / `createdAt` / `id` 始终保留
+  - `enabled: false` 只停止调度不删除任务；`enabled: true` 会在必要时重建 handle
+
 ## 2.0.0
 
 ### Breaking Changes

package/plugins/core/scheduler/index.js

@@ -138,6 +138,11 @@ function detectLLM(message, explicitFlag) {
   return LLM_KEYWORDS.some((kw) => message.includes(kw) || lower.includes(kw.toLowerCase()));
 }
 
+function isCronString(str) {
+  if (!str) return false;
+  return /^[\d*,\/-\s]+$/.test(str) && str.trim().split(/\s+/).length >= 5;
+}
+
 // ============================================================
 // SchedulerPlugin
 // ============================================================
@@ -145,8 +150,8 @@ class SchedulerPlugin extends Plugin {
   constructor(config = {}) {
     super();
     this.name = 'scheduler';
-    this.version = '2.0.0';
-    this.description = '定时任务调度 v2（croner 引擎，事件循环阻塞自愈 + 持久化 + 重叠保护）';
+    this.version = '2.0.2';
+    this.description = '定时任务调度 v2（croner 引擎，事件循环阻塞自愈 + 持久化 + 重叠保护 + 增删改查 + 并发安全）';
     this.priority = 15;
     this.system = true;
 
@@ -161,6 +166,8 @@ class SchedulerPlugin extends Plugin {
     this._taskStore = new TaskStore(this.config.persistencePath);
     // 复用的 LLM 执行 subagent（避免每次 tick 新建导致 _agents 数组漏内存）
     this._schedulerSubAgent = null;
+    // LLM 任务互斥链：B6 修复，避免不同任务的 subagent.chat() 并发污染 subagent 内部状态
+    this._llmMutex = Promise.resolve();
     // debounce 写入
     this._persistTimer = null;
     this._persistDirty = false;
@@ -260,6 +267,58 @@ class SchedulerPlugin extends Plugin {
       execute: async (args) => this._cancelTask(args.taskId),
     });
 
+    framework.registerTool({
+      name: 'schedule_get',
+      description: '按 ID 获取单个定时任务的完整详情',
+      inputSchema: z.object({ taskId: z.string().describe('任务 ID') }),
+      execute: async (args) => {
+        const task = this._tasks.get(args.taskId);
+        if (!task) return { success: false, error: 'Task not found' };
+        let nextRun = null;
+        try { nextRun = task.scheduleHandle?.nextRun?.() || task.runAt || null; } catch {}
+        return {
+          success: true,
+          task: {
+            id: task.id,
+            name: task.name,
+            type: task.type,
+            message: task.message,
+            shell: task.shell || null,
+            enabled: task.enabled,
+            running: task.running,
+            nextRun,
+            runCount: task.runCount,
+            lastRun: task.lastRun,
+            createdAt: task.createdAt,
+            cronExpression: task.cronExpression,
+            runAt: task.runAt,
+            timezone: task.timezone,
+            llm: task.llm,
+            notify: task.notify,
+            sessionId: task.sessionId,
+          },
+        };
+      },
+    });
+
+    framework.registerTool({
+      name: 'schedule_update',
+      description: '修改已存在的定时任务。可以修改：name/message/scheduleTime/cronExpression/sessionId/llm/notify/shell。如果改了 scheduleTime 或 cronExpression，会自动重新创建调度。runCount/lastRun/createdAt 保持不变。',
+      inputSchema: z.object({
+        taskId: z.string().describe('要修改的任务 ID'),
+        name: z.string().optional().describe('新任务名称'),
+        message: z.string().optional().describe('新提醒消息'),
+        scheduleTime: z.string().optional().describe('新时间（覆盖原 scheduleTime）。格式同 schedule_task'),
+        cronExpression: z.string().optional().describe('新 Cron 表达式（仅 cron 任务有效，优先级高于 scheduleTime）'),
+        sessionId: z.string().optional().describe('新会话 ID'),
+        llm: z.boolean().optional().describe('是否需要 LLM 处理'),
+        notify: z.boolean().optional().describe('是否发送通知'),
+        shell: z.string().optional().describe('新的 shell 命令（覆盖旧值）'),
+        enabled: z.boolean().optional().describe('启用/禁用任务（不删除）'),
+      }),
+      execute: async (args) => this._updateTask(args),
+    });
+
     framework.registerTool({
       name: 'cron_examples',
       description: '获取常用 Cron 表达式示例',
@@ -293,7 +352,7 @@ class SchedulerPlugin extends Plugin {
       const { scheduleTime, message, repeat, cronExpression, sessionId, shell } = args;
 
       // 解析时间
-      const isCron = /^[\d*,\/-\s]+$/.test(scheduleTime) && scheduleTime.split(/\s+/).length >= 5;
+      const isCron = isCronString(scheduleTime);
       let taskType; // 'cron' | 'once'
       let runAt = null;
       let cron = null;
@@ -316,9 +375,10 @@ class SchedulerPlugin extends Plugin {
         runAt = new Date(Date.now() + delayMs);
       }
 
-      // shell 任务必须能用 shell 工具，否则提示
+      // shell 任务的实际执行受 _runShell 内的安全策略控制：必须通过已注册的 shell 工具
       if (shell && !this._hasShellTool()) {
-        // 不阻塞：fallback 到 child_process 执行
+        // 创建时仍允许；执行时会被 _runShell 拒绝（fail-closed）
+        log.warn(` Shell 任务 ${args.name} 创建时未检测到 shell_exec/shell 工具，触发时将失败`);
       }
 
       // 解析 sessionId
@@ -360,6 +420,7 @@ class SchedulerPlugin extends Plugin {
         llm: llmMode,
         notify: args.notify !== false,
         running: false,
+        stopped: false,        // 显式跟踪被 stop() 的状态（croner stop() 不清 handle 引用）
         scheduleHandle: null,
       };
 
@@ -472,9 +533,26 @@ class SchedulerPlugin extends Plugin {
   }
 
   async _runShell(task) {
-    let result;
+    // 安全要求：shell 命令必须通过已注册的 shell 工具执行（这些工具应实现沙箱/白名单）
+    // 不再 fallback 到 child_process.exec，避免任意命令执行漏洞
     const shellTool = this._hasShellTool() ? this._pickShellTool() : null;
-    if (shellTool) {
+    if (!shellTool) {
+      const errMsg = '未检测到 shell_exec/shell 工具，拒绝执行 shell 任务（安全策略）';
+      log.error(` ${task.name}: ${errMsg}`);
+      this._framework?.emit('notification', {
+        title: `任务失败: ${task.name}`,
+        message: errMsg,
+        source: 'scheduler',
+        level: 'error',
+        sessionId: task.sessionId,
+        timestamp: new Date(),
+      });
+      this._framework?.emit('scheduler:task_failed', { taskId: task.id, error: errMsg });
+      return { error: errMsg };
+    }
+
+    let result;
+    try {
       const raw = await this._framework.executeTool(shellTool, { command: task.shell });
       // 适配不同 shell 工具的返回格式
       if (raw?.error) {
@@ -485,17 +563,8 @@ class SchedulerPlugin extends Plugin {
       } else {
         result = { output: raw.stdout || raw.output || '', stdout: raw.stdout, stderr: raw.stderr };
       }
-    } else {
-      // 兜底：直接 child_process
-      const { exec } = require('child_process');
-      const util = require('util');
-      const execAsync = util.promisify(exec);
-      try {
-        const { stdout, stderr } = await execAsync(task.shell, { timeout: 60000 });
-        result = { output: stdout.trim(), stdout: stdout.trim(), stderr: (stderr || '').trim() };
-      } catch (e) {
-        result = { error: e.message, stderr: e.stderr || '' };
-      }
+    } catch (e) {
+      result = { error: e.message || String(e) };
     }
 
     const output = result.error
@@ -521,28 +590,49 @@ class SchedulerPlugin extends Plugin {
     if (!subAgent) {
       return { error: '无法创建 scheduler subagent' };
     }
-    const result = await subAgent.chat(task.message);
-    const responseText = result?.message;
-    if (task.notify !== false && responseText && responseText.trim()) {
-      this._framework?.emit('notification', {
-        title: task.name,
-        message: responseText,
-        source: 'scheduler',
-        level: 'info',
-        sessionId: task.sessionId,
-        timestamp: new Date(),
-      });
-      this._framework?.emit('scheduler:reminder', {
-        taskId: task.id,
-        message: task.message,
-        time: task.runAt || null,
-      });
-    }
-    this._framework?.emit('scheduler:task_completed', {
-      taskId: task.id,
-      result: responseText || task.message,
-    });
-    return { success: true };
+    // B6 修复：用 promise-chain 互斥，把 LLM 任务串行化
+    // 即使两个不同任务同时触发 _onFire，它们的 subagent.chat() 也会排队执行
+    const work = async () => {
+      try {
+        const result = await subAgent.chat(task.message);
+        const responseText = result?.message;
+        if (task.notify !== false && responseText && responseText.trim()) {
+          this._framework?.emit('notification', {
+            title: task.name,
+            message: responseText,
+            source: 'scheduler',
+            level: 'info',
+            sessionId: task.sessionId,
+            timestamp: new Date(),
+          });
+          this._framework?.emit('scheduler:reminder', {
+            taskId: task.id,
+            message: task.message,
+            time: task.runAt || null,
+          });
+        }
+        this._framework?.emit('scheduler:task_completed', {
+          taskId: task.id,
+          result: responseText || task.message,
+        });
+        return { success: true };
+      } catch (e) {
+        const errMsg = e?.message || String(e);
+        log.error(` _runLLM ${task.name}:`, errMsg);
+        this._framework?.emit('notification', {
+          title: `任务失败: ${task.name}`,
+          message: errMsg,
+          source: 'scheduler',
+          level: 'error',
+          sessionId: task.sessionId,
+          timestamp: new Date(),
+        });
+        this._framework?.emit('scheduler:task_failed', { taskId: task.id, error: errMsg });
+        return { error: errMsg };
+      }
+    };
+    this._llmMutex = this._llmMutex.then(work, work);
+    return this._llmMutex;
   }
 
   async _runNotification(task) {
@@ -580,6 +670,7 @@ class SchedulerPlugin extends Plugin {
       task.scheduleHandle?.stop();
     } catch {}
     task.enabled = false;
+    task.stopped = true;
     this._tasks.delete(taskId);
     this._schedulePersist();
 
@@ -595,6 +686,169 @@ class SchedulerPlugin extends Plugin {
     return { success: true, cancelled: taskId };
   }
 
+  /**
+   * 修改任务。
+   * 关键规则：
+   * 1. 改 scheduleTime / cronExpression → 二阶段提交：先构造验证新 handle 成功，再 commit
+   * 2. 改 message / shell / llm / notify / sessionId / name / enabled → 仅更新字段
+   * 3. runCount / lastRun / createdAt / id 永远不变
+   * 4. type 字段（cron/once）不能跨类型切换——例如不能把 once 改成 cron（语义差异大），
+   *    这种情况下提示用户先 cancel 再 create
+   * 5. enable: false → set stopped=true + stop() handle；enable: true → 检查 stopped 重建 handle
+   */
+  _updateTask(args) {
+    const { taskId } = args;
+    const task = this._tasks.get(taskId);
+    if (!task) return { success: false, error: 'Task not found' };
+
+    const updated = {};
+    // 收集"非时间"变更（这些变更先做；时间变更走二阶段提交）
+    if (args.name !== undefined) { task.name = args.name; updated.name = args.name; }
+    if (args.message !== undefined) { task.message = args.message; updated.message = task.message; }
+    if (args.sessionId !== undefined) { task.sessionId = args.sessionId || null; updated.sessionId = task.sessionId; }
+    if (args.notify !== undefined) { task.notify = !!args.notify; updated.notify = task.notify; }
+    if (args.llm !== undefined) { task.llm = !!args.llm; updated.llm = task.llm; }
+    if (args.shell !== undefined) {
+      task.shell = args.shell || null;
+      // shell 与 llm 互斥
+      if (task.shell) { task.llm = false; updated.llm = false; }
+      updated.shell = task.shell;
+    }
+
+    // enabled 处理（影响 stopped 状态和后续重建）
+    if (args.enabled !== undefined) {
+      const wasEnabled = task.enabled;
+      task.enabled = !!args.enabled;
+      updated.enabled = task.enabled;
+      if (!task.enabled) {
+        // 暂停：stop handle，标记 stopped=true
+        try { task.scheduleHandle?.stop(); } catch {}
+        task.stopped = true;
+      } else if (!wasEnabled) {
+        // 从暂停恢复：标记为需要重建（在时间变更之后统一重建）
+        task.stopped = true; // 强制让下面"重建"分支执行
+      }
+    }
+
+    // 时间变更（cronExpression / scheduleTime）— 二阶段提交
+    let newCron = task.cronExpression;
+    let newRunAt = task.runAt;
+    let typeChanged = false;
+    let timeValidationError = null;
+
+    if (args.cronExpression !== undefined) {
+      // 显式 cron 表达式：必须是 cron 任务
+      if (task.type !== 'cron') {
+        timeValidationError = `无法把 ${task.type} 任务改为 cron 表达式（类型不兼容）。请先取消再创建。`;
+      } else {
+        newCron = args.cronExpression;
+      }
+    } else if (args.scheduleTime !== undefined) {
+      const st = args.scheduleTime;
+      const isCron = isCronString(st);
+      if (isCron) {
+        if (task.type !== 'cron') {
+          timeValidationError = `无法把 ${task.type} 任务改为 cron 表达式（类型不兼容）。请先取消再创建。`;
+        } else {
+          newCron = st;
+        }
+      } else {
+        if (task.type !== 'once') {
+          timeValidationError = `无法把 ${task.type} 任务改为一次性时间（类型不兼容）。请先取消再创建。`;
+        } else {
+          // 解析 runAt
+          let parsed;
+          if (st.includes(':')) {
+            parsed = parseAtTime(st);
+          } else {
+            const delayMs = parseDelay(st);
+            if (!delayMs) {
+              timeValidationError = `无效的时间格式: ${st}`;
+            } else {
+              parsed = new Date(Date.now() + delayMs);
+            }
+          }
+          if (parsed && isNaN(parsed.getTime())) {
+            timeValidationError = `无法解析时间: ${st}`;
+          } else if (parsed) {
+            if (task.runCount > 0) {
+              timeValidationError = '一次性任务已执行过，无法修改时间。请取消后重建。';
+            } else {
+              newRunAt = parsed;
+            }
+          }
+        }
+      }
+    }
+
+    if (timeValidationError) {
+      return { success: false, error: timeValidationError };
+    }
+
+    // 二阶段提交：先尝试构造新 handle 验证
+    let newHandle = null;
+    const handleChanged =
+      newCron !== task.cronExpression ||
+      newRunAt !== task.runAt ||
+      (args.enabled !== undefined && task.enabled === true && task.stopped);
+
+    if (handleChanged && task.enabled) {
+      try {
+        if (task.type === 'cron') {
+          newHandle = new Cron(newCron, this._cronOptions(task), () => this._onFire(task));
+        } else {
+          newHandle = new Cron(newRunAt, this._cronOptions(task), () => this._onFire(task));
+        }
+      } catch (err) {
+        return { success: false, error: `新调度表达式无效: ${err.message}` };
+      }
+    }
+
+    // 验证通过，commit
+    if (newHandle) {
+      try { task.scheduleHandle?.stop(); } catch {}
+      task.scheduleHandle = newHandle;
+      task.cronExpression = newCron;
+      task.runAt = newRunAt;
+      task.stopped = false;
+      if (args.cronExpression !== undefined || (args.scheduleTime !== undefined && isCronString(args.scheduleTime))) {
+        updated.cronExpression = task.cronExpression;
+      }
+      if (args.scheduleTime !== undefined && !isCronString(args.scheduleTime)) {
+        updated.runAt = task.runAt.toISOString();
+      }
+    } else if (args.enabled !== undefined && task.enabled) {
+      // enable: true 但 handle 没变（任务本来就是 enabled）；无需操作
+    }
+
+    this._tasks.set(task.id, task);
+    this._schedulePersist();
+
+    let nextRun = null;
+    try { nextRun = task.scheduleHandle?.nextRun?.() || task.runAt || null; } catch {}
+
+    return {
+      success: true,
+      taskId: task.id,
+      updated,
+      task: {
+        id: task.id,
+        name: task.name,
+        type: task.type,
+        message: task.message,
+        shell: task.shell || null,
+        enabled: task.enabled,
+        stopped: task.stopped,
+        llm: task.llm,
+        notify: task.notify,
+        sessionId: task.sessionId,
+        cronExpression: task.cronExpression,
+        runAt: task.runAt,
+        nextRun,
+      },
+    };
+  }
+
   _cleanupTask(taskId) {
     const task = this._tasks.get(taskId);
     if (!task) return;
@@ -638,7 +892,6 @@ class SchedulerPlugin extends Plugin {
     const savedTasks = this._taskStore.loadTasks();
     if (!savedTasks || savedTasks.length === 0) return;
     const now = Date.now();
-    const expiredImmediate = []; // 需要立即补触发的过期任务
 
     for (const saved of savedTasks) {
       // 已完成的 once 任务不再恢复
@@ -650,6 +903,7 @@ class SchedulerPlugin extends Plugin {
         lastRun: saved.lastRun ? new Date(saved.lastRun) : null,
         runAt: saved.runAt ? new Date(saved.runAt) : null,
         running: false,
+        stopped: false,
         scheduleHandle: null,
       };
 
@@ -661,16 +915,19 @@ class SchedulerPlugin extends Plugin {
           if (!task.runAt) continue;
           const fireAt = task.runAt.getTime();
           if (fireAt <= now) {
-            // 已过期：超过 grace period 就丢弃，否则排队立即补触发
+            // 已过期：超过 grace period 就丢弃
             if (now - fireAt > ONCE_EXPIRY_GRACE_MS) {
               log.warn(` 丢弃过期任务 ${task.name}（已过期 ${Math.round((now - fireAt) / 1000)}s，超出 24h 容忍期）`);
               continue;
             }
-            // 安排一个微小延迟的补触发（避免与启动逻辑抢资源）
-            setTimeout(() => this._onFire(task), 100).unref?.();
-            // 不放入 _tasks 的 scheduleHandle 路径（因为是一次性补触发），
-            // 但保留在 _tasks 里供 schedule_list 查看
-            this._tasks.set(task.id, { ...task, expiredCatchup: true });
+            // B4/B5 修复：catchup 也用 croner 调度过去时间，croner 会立即触发；
+            // stop() 能真正取消，update 走 stop()+new Cron() 不会双触发
+            // protect:false 是因为"补触发"不应被 startup 期间的并发阻塞
+            task.scheduleHandle = new Cron(task.runAt, {
+              ...this._cronOptions(task),
+              protect: false,
+            }, () => this._onFire(task));
+            this._tasks.set(task.id, task);
           } else {
             // 未来触发
             task.scheduleHandle = new Cron(task.runAt, this._cronOptions(task), () => this._onFire(task));
@@ -713,6 +970,13 @@ class SchedulerPlugin extends Plugin {
     }
     this._tasks.clear();
     this._schedulerSubAgent = null;
+    // 清掉未触发的 debounce，避免 reload 后旧 timer 用空 _tasks 写盘
+    if (this._persistTimer) {
+      clearTimeout(this._persistTimer);
+      this._persistTimer = null;
+    }
+    this._persistDirty = false;
+    this._llmMutex = Promise.resolve();
     this._framework = framework;
     this._agent = this._getAgent();
     this._loadPersistedTasks();