flashclaw 1.0.0

package/plugins/feishu/plugin.json

@@ -0,0 +1,29 @@
+{
+  "name": "feishu",
+  "version": "1.0.0",
+  "type": "channel",
+  "description": "飞书通讯渠道插件",
+  "author": "FlashClaw",
+  "main": "index.ts",
+  "dependencies": [
+    "send-message",
+    "schedule-task",
+    "list-tasks",
+    "cancel-task",
+    "memory"
+  ],
+  "config": {
+    "appId": {
+      "type": "string",
+      "required": true,
+      "env": "FEISHU_APP_ID"
+    },
+    "appSecret": {
+      "type": "string",
+      "required": true,
+      "env": "FEISHU_APP_SECRET"
+    }
+  }
+}
+
+

package/plugins/list-tasks/index.ts

@@ -0,0 +1,150 @@
+/**
+ * FlashClaw 插件 - 列出定时任务
+ * 查看当前群组或所有群组的定时任务
+ */
+
+import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
+import { getTasksForGroup, getAllTasks, getTaskRunLogs } from '../../src/db.js';
+import { TIMEZONE, MAIN_GROUP_FOLDER } from '../../src/config.js';
+import { ScheduledTask } from '../../src/types.js';
+
+/**
+ * 列出任务参数
+ */
+interface ListTasksParams {
+  /** 是否列出所有群组的任务（仅 main 群组可用） */
+  all?: boolean;
+  /** 任务状态过滤 */
+  status?: 'active' | 'paused' | 'completed' | 'all';
+  /** 是否包含最近运行记录 */
+  includeRunLogs?: boolean;
+}
+
+/**
+ * 格式化任务信息
+ */
+function formatTask(task: ScheduledTask, includeRunLogs: boolean = false): Record<string, unknown> {
+  const formatted: Record<string, unknown> = {
+    id: task.id,
+    prompt: task.prompt.length > 100 ? task.prompt.slice(0, 100) + '...' : task.prompt,
+    scheduleType: task.schedule_type,
+    scheduleValue: task.schedule_value,
+    status: task.status,
+    groupFolder: task.group_folder,
+    chatId: task.chat_jid,
+    contextMode: task.context_mode,
+    createdAt: formatDateTime(task.created_at)
+  };
+  
+  if (task.next_run) {
+    formatted.nextRun = formatDateTime(task.next_run);
+  }
+  
+  if (task.last_run) {
+    formatted.lastRun = formatDateTime(task.last_run);
+    formatted.lastResult = task.last_result;
+  }
+  
+  // 获取最近运行记录
+  if (includeRunLogs) {
+    const logs = getTaskRunLogs(task.id, 3);
+    if (logs.length > 0) {
+      formatted.recentRuns = logs.map(log => ({
+        runAt: formatDateTime(log.run_at),
+        status: log.status,
+        durationMs: log.duration_ms,
+        result: log.result ? (log.result.length > 50 ? log.result.slice(0, 50) + '...' : log.result) : null,
+        error: log.error
+      }));
+    }
+  }
+  
+  return formatted;
+}
+
+/**
+ * 格式化日期时间为可读格式
+ */
+function formatDateTime(isoString: string): string {
+  const date = new Date(isoString);
+  return date.toLocaleString('zh-CN', { timeZone: TIMEZONE });
+}
+
+const plugin: ToolPlugin = {
+  name: 'list_tasks',
+  version: '1.0.0',
+  description: '列出定时任务，查看任务状态和运行记录',
+  
+  schema: {
+    name: 'list_tasks',
+    description: '列出定时任务。默认只显示当前群组的任务，main 群组可以查看所有任务。',
+    input_schema: {
+      type: 'object',
+      properties: {
+        all: {
+          type: 'boolean',
+          description: '是否列出所有群组的任务（仅 main 群组有权限）'
+        },
+        status: {
+          type: 'string',
+          enum: ['active', 'paused', 'completed', 'all'],
+          description: '按状态过滤任务。默认显示所有状态'
+        },
+        includeRunLogs: {
+          type: 'boolean',
+          description: '是否包含最近 3 次运行记录'
+        }
+      }
+    }
+  },
+  
+  async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
+    const { all = false, status = 'all', includeRunLogs = false } = (params || {}) as ListTasksParams;
+    
+    const isMainGroup = context.groupId === MAIN_GROUP_FOLDER;
+    
+    // 获取任务列表
+    let tasks: ScheduledTask[];
+    
+    if (all && isMainGroup) {
+      // main 群组可以查看所有任务
+      tasks = getAllTasks();
+    } else if (all && !isMainGroup) {
+      return {
+        success: false,
+        error: '只有 main 群组可以查看所有群组的任务'
+      };
+    } else {
+      // 只查看当前群组的任务
+      tasks = getTasksForGroup(context.groupId);
+    }
+    
+    // 按状态过滤
+    if (status !== 'all') {
+      tasks = tasks.filter(task => task.status === status);
+    }
+    
+    // 格式化任务列表
+    const formattedTasks = tasks.map(task => formatTask(task, includeRunLogs));
+    
+    // 统计信息
+    const stats = {
+      total: tasks.length,
+      active: tasks.filter(t => t.status === 'active').length,
+      paused: tasks.filter(t => t.status === 'paused').length,
+      completed: tasks.filter(t => t.status === 'completed').length
+    };
+    
+    return {
+      success: true,
+      data: {
+        tasks: formattedTasks,
+        stats,
+        scope: all ? 'all_groups' : 'current_group',
+        groupId: context.groupId
+      }
+    };
+  }
+};
+
+export default plugin;

package/plugins/list-tasks/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "list-tasks",
+  "version": "1.0.0",
+  "type": "tool",
+  "description": "列出定时任务",
+  "main": "index.ts"
+}
+
+

package/plugins/memory/index.ts

@@ -0,0 +1,190 @@
+/**
+ * FlashClaw 插件 - 长期记忆管理
+ * 提供 remember 和 recall 功能
+ */
+
+import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
+import { getMemoryManager } from '../../src/core/memory.js';
+
+/**
+ * 记忆操作参数
+ */
+interface MemoryParams {
+  /** 操作类型：remember（记住）或 recall（回忆） */
+  action: 'remember' | 'recall';
+  /** 记忆键（remember 必需，recall 可选） */
+  key?: string;
+  /** 记忆值（remember 必需） */
+  value?: string;
+  /** 作用域：user（用户级别，跨会话共享）或 group（会话级别，默认） */
+  scope?: 'user' | 'group';
+}
+
+const plugin: ToolPlugin = {
+  name: 'memory',
+  version: '1.0.0',
+  description: '长期记忆管理，可以记住和回忆重要信息',
+  
+  schema: {
+    name: 'memory',
+    description: `管理长期记忆。支持两种操作：
+- remember: 保存重要信息到长期记忆（用户偏好、重要事实等）
+- recall: 回忆之前保存的信息
+
+支持两种作用域：
+- user: 用户级别记忆，跨所有会话共享（推荐用于个人偏好）
+- group: 会话级别记忆，仅在当前会话有效（默认）
+
+记忆会持久化到文件，跨会话保持。`,
+    input_schema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['remember', 'recall'],
+          description: 'remember 保存信息，recall 回忆信息'
+        },
+        key: {
+          type: 'string',
+          description: '记忆的键名（如 "favorite_food"、"name"）。recall 时留空则返回所有记忆'
+        },
+        value: {
+          type: 'string',
+          description: 'remember 时要保存的值'
+        },
+        scope: {
+          type: 'string',
+          enum: ['user', 'group'],
+          description: '作用域。user=用户级别（跨会话共享，适合个人偏好），group=会话级别（默认）'
+        }
+      },
+      required: ['action']
+    }
+  },
+  
+  async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
+    const { action, key, value, scope = 'user' } = params as MemoryParams;
+    const mm = getMemoryManager();
+    
+    // 默认使用用户级别记忆（跨会话共享）
+    const isUserScope = scope === 'user';
+    const scopeLabel = isUserScope ? '用户' : '会话';
+    
+    if (action === 'remember') {
+      // 记住信息
+      if (!key || typeof key !== 'string') {
+        return {
+          success: false,
+          error: 'remember 操作需要提供 key'
+        };
+      }
+      
+      if (!value || typeof value !== 'string') {
+        return {
+          success: false,
+          error: 'remember 操作需要提供 value'
+        };
+      }
+      
+      try {
+        if (isUserScope) {
+          mm.rememberUser(context.userId, key, value);
+        } else {
+          mm.remember(context.groupId, key, value);
+        }
+        return {
+          success: true,
+          data: {
+            action: 'remembered',
+            scope: scopeLabel,
+            key,
+            value,
+            message: `已记住（${scopeLabel}级别）: ${key} = ${value}`
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `保存记忆失败: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    
+    if (action === 'recall') {
+      // 回忆信息
+      try {
+        // 默认同时查询用户级别和会话级别记忆
+        const userResult = mm.recallUser(context.userId, key);
+        const groupResult = mm.recall(context.groupId, key);
+        
+        if (key) {
+          // 回忆特定键 - 优先返回用户级别，其次会话级别
+          const result = userResult || groupResult;
+          const foundScope = userResult ? '用户' : (groupResult ? '会话' : null);
+          
+          if (result) {
+            return {
+              success: true,
+              data: {
+                action: 'recalled',
+                scope: foundScope,
+                key,
+                value: result
+              }
+            };
+          } else {
+            return {
+              success: true,
+              data: {
+                action: 'recalled',
+                key,
+                value: null,
+                message: `没有找到键为 "${key}" 的记忆`
+              }
+            };
+          }
+        } else {
+          // 回忆所有 - 合并用户级别和会话级别
+          const memories: string[] = [];
+          if (userResult) {
+            memories.push(`【用户记忆】\n${userResult}`);
+          }
+          if (groupResult) {
+            memories.push(`【会话记忆】\n${groupResult}`);
+          }
+          
+          if (memories.length > 0) {
+            return {
+              success: true,
+              data: {
+                action: 'recalled',
+                memories: memories.join('\n\n')
+              }
+            };
+          } else {
+            return {
+              success: true,
+              data: {
+                action: 'recalled',
+                memories: null,
+                message: '没有保存的记忆'
+              }
+            };
+          }
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `回忆失败: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    
+    return {
+      success: false,
+      error: 'action 必须是 remember 或 recall'
+    };
+  }
+};
+
+export default plugin;

package/plugins/memory/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "memory",
+  "version": "1.0.0",
+  "type": "tool",
+  "description": "长期记忆管理（remember/recall）",
+  "main": "index.ts"
+}

package/plugins/pause-task/index.ts

@@ -0,0 +1,95 @@
+/**
+ * FlashClaw 插件 - 暂停定时任务
+ */
+
+import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
+import { getTaskById, updateTask } from '../../src/db.js';
+import { MAIN_GROUP_FOLDER } from '../../src/config.js';
+
+interface PauseTaskParams {
+  task_id: string;
+}
+
+const plugin: ToolPlugin = {
+  name: 'pause_task',
+  version: '1.0.0',
+  description: '暂停定时任务',
+  
+  schema: {
+    name: 'pause_task',
+    description: '暂停一个定时任务。暂停后任务不会执行，直到使用 resume_task 恢复。',
+    input_schema: {
+      type: 'object',
+      properties: {
+        task_id: {
+          type: 'string',
+          description: '要暂停的任务 ID，可以通过 list_tasks 获取'
+        }
+      },
+      required: ['task_id']
+    }
+  },
+  
+  async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
+    const { task_id } = params as PauseTaskParams;
+    
+    if (!task_id || typeof task_id !== 'string') {
+      return {
+        success: false,
+        error: '任务 ID 不能为空'
+      };
+    }
+    
+    const task = getTaskById(task_id);
+    
+    if (!task) {
+      return {
+        success: false,
+        error: `任务不存在: ${task_id}`
+      };
+    }
+    
+    // 权限检查
+    const isMainGroup = context.groupId === MAIN_GROUP_FOLDER;
+    const isOwnTask = task.group_folder === context.groupId;
+    
+    if (!isMainGroup && !isOwnTask) {
+      return {
+        success: false,
+        error: '无权操作其他群组的任务'
+      };
+    }
+    
+    if (task.status === 'paused') {
+      return {
+        success: false,
+        error: '任务已经是暂停状态'
+      };
+    }
+    
+    if (task.status === 'completed') {
+      return {
+        success: false,
+        error: '已完成的任务无法暂停'
+      };
+    }
+    
+    try {
+      updateTask(task_id, { status: 'paused' });
+      return {
+        success: true,
+        data: {
+          task_id,
+          message: '任务已暂停，使用 resume_task 可以恢复执行'
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `暂停任务失败: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+};
+
+export default plugin;

package/plugins/pause-task/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "pause_task",
+  "version": "1.0.0",
+  "description": "暂停定时任务",
+  "type": "tool",
+  "main": "index.ts",
+  "dependencies": []
+}

package/plugins/register-group/index.ts

@@ -0,0 +1,147 @@
+/**
+ * FlashClaw 插件 - 注册群组
+ * 允许 AI Agent 注册新的聊天群组
+ */
+
+import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
+import { MAIN_GROUP_FOLDER } from '../../src/config.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * 注册群组参数
+ */
+interface RegisterGroupParams {
+  /** 聊天 ID（如 "oc_xxxxxxxx"） */
+  jid: string;
+  /** 群组显示名称 */
+  name: string;
+  /** 群组文件夹名称（小写，用连字符分隔） */
+  folder: string;
+  /** 触发词（如 "@Andy"） */
+  trigger: string;
+}
+
+const plugin: ToolPlugin = {
+  name: 'register_group',
+  version: '1.0.0',
+  description: '注册新的聊天群组',
+  
+  schema: {
+    name: 'register_group',
+    description: `注册新的聊天群组，使机器人可以响应该群组的消息。
+仅限 main 群组使用。文件夹名称应使用小写字母和连字符（如 "family-chat"）。`,
+    input_schema: {
+      type: 'object',
+      properties: {
+        jid: {
+          type: 'string',
+          description: '聊天 ID（如 "oc_xxxxxxxx"）'
+        },
+        name: {
+          type: 'string',
+          description: '群组显示名称'
+        },
+        folder: {
+          type: 'string',
+          description: '群组文件夹名称（小写，用连字符分隔）'
+        },
+        trigger: {
+          type: 'string',
+          description: '触发词（如 "@Andy"）'
+        }
+      },
+      required: ['jid', 'name', 'folder', 'trigger']
+    }
+  },
+  
+  async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
+    const { jid, name, folder, trigger } = params as RegisterGroupParams;
+    
+    // 权限检查：只有 main 群组可以注册新群组
+    if (context.groupId !== MAIN_GROUP_FOLDER) {
+      return {
+        success: false,
+        error: '只有 main 群组可以注册新群组'
+      };
+    }
+    
+    // 参数验证
+    if (!jid || typeof jid !== 'string') {
+      return {
+        success: false,
+        error: 'jid（聊天 ID）不能为空'
+      };
+    }
+    
+    if (!name || typeof name !== 'string') {
+      return {
+        success: false,
+        error: 'name（群组名称）不能为空'
+      };
+    }
+    
+    if (!folder || typeof folder !== 'string') {
+      return {
+        success: false,
+        error: 'folder（文件夹名称）不能为空'
+      };
+    }
+    
+    if (!trigger || typeof trigger !== 'string') {
+      return {
+        success: false,
+        error: 'trigger（触发词）不能为空'
+      };
+    }
+    
+    // 验证 folder 格式
+    if (!/^[a-z0-9-]+$/.test(folder)) {
+      return {
+        success: false,
+        error: 'folder 只能包含小写字母、数字和连字符'
+      };
+    }
+    
+    // 通过 IPC 写入注册请求
+    const ipcDir = path.join(process.cwd(), 'data', 'ipc', context.groupId, 'tasks');
+    fs.mkdirSync(ipcDir, { recursive: true });
+    
+    const data = {
+      type: 'register_group',
+      jid,
+      name,
+      folder,
+      trigger,
+      timestamp: new Date().toISOString()
+    };
+    
+    const filename = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
+    const filepath = path.join(ipcDir, filename);
+    
+    try {
+      // 原子写入
+      const tempPath = `${filepath}.tmp`;
+      fs.writeFileSync(tempPath, JSON.stringify(data, null, 2));
+      fs.renameSync(tempPath, filepath);
+      
+      return {
+        success: true,
+        data: {
+          jid,
+          name,
+          folder,
+          trigger,
+          message: `群组 "${name}" 已注册，机器人将开始响应该群组的消息`
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `注册失败: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+};
+
+export default plugin;

package/plugins/register-group/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "register_group",
+  "version": "1.0.0",
+  "type": "tool",
+  "description": "注册新的聊天群组",
+  "main": "index.ts"
+}