flashclaw 1.7.1 → 1.9.0

package/plugins/anthropic-provider/index.ts

@@ -14,18 +14,53 @@ import type {
   PluginConfig,
   ImageBlock,
   TextBlock,
+  ToolDefinition,
 } from '../../src/plugins/types';
 
 // ==================== 内部状态 ====================
 
 let client: Anthropic | null = null;
 let model: string = 'claude-sonnet-4-20250514';
+let baseURL: string | undefined;
 
 // ==================== 内部常量和工具函数 ====================
 
 const MAX_TOOL_CALL_DEPTH = 20;
+
+/**
+ * 从错误对象中提取完整的错误信息链（包括 cause）
+ * Anthropic SDK 的 APIConnectionError 会将真正的网络错误藏在 cause 中
+ */
+function extractFullErrorMessage(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  
+  const parts: string[] = [err.message];
+  let current: unknown = (err as Error & { cause?: unknown }).cause;
+  let depth = 0;
+  
+  while (current && depth < 5) {
+    if (current instanceof Error) {
+      parts.push(current.message);
+      current = (current as Error & { cause?: unknown }).cause;
+    } else {
+      parts.push(String(current));
+      break;
+    }
+    depth++;
+  }
+  
+  // 附加 HTTP 状态码（如果是 API 错误）
+  const status = (err as Error & { status?: number }).status;
+  if (status) {
+    parts.unshift(`[HTTP ${status}]`);
+  }
+  
+  return parts.join(' → ');
+}
 const MAX_TOOL_RESULT_CHARS = 4000;
 const KEEP_RECENT_TOOL_ROUNDS = 2;
+const MOCK_RESPONSE_PREFIX = process.env.FLASHCLAW_MOCK_RESPONSE_PREFIX || 'MOCK';
+const MOCK_TOOL_MARKER = process.env.FLASHCLAW_MOCK_TOOL_MARKER || '[tool:send_message]';
 
 function truncateToolResult(content: string, maxChars: number): string {
   if (content.length <= maxChars) return content;
@@ -102,6 +137,88 @@ function extractText(response: Anthropic.Message): string {
   return textBlocks.map(block => block.text).join('');
 }
 
+function isMockMode(): boolean {
+  return process.env.FLASHCLAW_MOCK_API === '1';
+}
+
+function contentToText(content: ChatMessage['content']): string {
+  if (typeof content === 'string') return content;
+  return content
+    .filter((block): block is TextBlock => block.type === 'text')
+    .map(block => block.text)
+    .join('');
+}
+
+function getLastUserText(messages: ChatMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (msg.role === 'user') {
+      return contentToText(msg.content);
+    }
+  }
+  return '';
+}
+
+function shouldMockToolUse(prompt: string, tools?: ToolDefinition[]): boolean {
+  if (!tools || tools.length === 0) return false;
+  if (process.env.FLASHCLAW_MOCK_FORCE_TOOL === '1') return true;
+  return prompt.includes(MOCK_TOOL_MARKER);
+}
+
+function buildMockMessage(params: {
+  content: Array<TextBlock | { type: 'tool_use'; id: string; name: string; input: unknown }>;
+  stopReason: 'end_turn' | 'tool_use';
+  model: string;
+}): Anthropic.Message {
+  return {
+    id: `mock-${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    model: params.model,
+    content: params.content as Anthropic.Message['content'],
+    stop_reason: params.stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: 1,
+      output_tokens: 1,
+      cache_creation_input_tokens: null,
+      cache_read_input_tokens: null,
+      cache_creation: null,
+      server_tool_use: null,
+      service_tier: 'standard',
+    },
+  };
+}
+
+async function createMockResponse(messages: ChatMessage[], options?: ChatOptions): Promise<Anthropic.Message> {
+  const prompt = getLastUserText(messages);
+  const tools = options?.tools;
+  const useTool = shouldMockToolUse(prompt, tools);
+
+  if (useTool && tools && tools.length > 0) {
+    const toolName = tools.find(t => t.name === 'send_message')?.name || tools[0].name;
+    const toolInput = { content: `${MOCK_RESPONSE_PREFIX} TOOL: ${prompt}` };
+    return buildMockMessage({
+      model,
+      stopReason: 'tool_use',
+      content: [
+        {
+          type: 'tool_use',
+          id: 'mock_tool_1',
+          name: toolName,
+          input: toolInput,
+        },
+      ],
+    });
+  }
+
+  return buildMockMessage({
+    model,
+    stopReason: 'end_turn',
+    content: [{ type: 'text', text: `${MOCK_RESPONSE_PREFIX}: ${prompt}` }],
+  });
+}
+
 async function streamFollowUp(
   messages: Anthropic.MessageParam[],
   options?: ChatOptions,
@@ -126,7 +243,13 @@ async function streamFollowUp(
     params.tools = options.tools as unknown as Anthropic.Tool[];
   }
 
-  const stream = await client.messages.create(params);
+  let stream;
+  try {
+    stream = await client.messages.create(params);
+  } catch (err) {
+    const detail = extractFullErrorMessage(err);
+    throw new Error(`Anthropic API 后续请求失败 (${baseURL || 'default'}): ${detail}`);
+  }
 
   let finalMessage: Anthropic.Message | null = null;
   const contentBlocks: Array<Anthropic.TextBlock | Anthropic.ToolUseBlock> = [];
@@ -274,25 +397,36 @@ const anthropicProvider: AIProviderPlugin = {
   description: 'Anthropic AI Provider - 支持 Claude 等模型',
 
   async init(config: PluginConfig): Promise<void> {
+    model = config.model as string || process.env.AI_MODEL || process.env.ANTHROPIC_MODEL || (isMockMode() ? 'mock-model' : 'claude-sonnet-4-20250514');
+
+    if (isMockMode()) {
+      client = null;
+      return;
+    }
+
     const apiKey = config.apiKey as string || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
       throw new Error('Missing API key: ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY');
     }
 
+    baseURL = config.baseURL as string || process.env.ANTHROPIC_BASE_URL || undefined;
+
     client = new Anthropic({
       apiKey,
-      baseURL: config.baseURL as string || process.env.ANTHROPIC_BASE_URL,
+      baseURL,
       maxRetries: 0,
       timeout: config.timeout ? Number(config.timeout) : 60000,
     });
-
-    model = config.model as string || process.env.AI_MODEL || process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514';
   },
 
   async chat(
     messages: ChatMessage[],
     options?: ChatOptions
   ): Promise<Anthropic.Message> {
+    if (isMockMode()) {
+      return createMockResponse(messages, options);
+    }
+
     if (!client) {
       throw new Error('Provider not initialized. Call init() first.');
     }
@@ -322,13 +456,36 @@ const anthropicProvider: AIProviderPlugin = {
       params.stop_sequences = options.stopSequences;
     }
 
-    return await client.messages.create(params);
+    try {
+      return await client.messages.create(params);
+    } catch (err) {
+      const detail = extractFullErrorMessage(err);
+      throw new Error(`Anthropic API 请求失败 (${baseURL || 'default'}): ${detail}`);
+    }
   },
 
   async *chatStream(
     messages: ChatMessage[],
     options?: ChatOptions
   ): AsyncGenerator<StreamEvent> {
+    if (isMockMode()) {
+      const response = await createMockResponse(messages, options);
+      for (const block of response.content) {
+        if (block.type === 'text') {
+          yield { type: 'text', text: block.text };
+        } else if (block.type === 'tool_use') {
+          yield {
+            type: 'tool_use',
+            id: block.id,
+            name: block.name,
+            input: block.input,
+          };
+        }
+      }
+      yield { type: 'done', message: response };
+      return;
+    }
+
     if (!client) {
       throw new Error('Provider not initialized. Call init() first.');
     }
@@ -355,7 +512,13 @@ const anthropicProvider: AIProviderPlugin = {
       params.temperature = options.temperature;
     }
 
-    const stream = await client.messages.create(params);
+    let stream;
+    try {
+      stream = await client.messages.create(params);
+    } catch (err) {
+      const detail = extractFullErrorMessage(err);
+      throw new Error(`Anthropic API 请求失败 (${baseURL || 'default'}): ${detail}`);
+    }
 
     let finalMessage: Anthropic.Message | null = null;
     const contentBlocks: Array<Anthropic.TextBlock | Anthropic.ToolUseBlock> = [];
@@ -441,6 +604,25 @@ const anthropicProvider: AIProviderPlugin = {
     heartbeat?: HeartbeatCallback
   ): Promise<string> {
     const anthropicResponse = response as Anthropic.Message;
+
+    if (isMockMode()) {
+      const toolUseBlocks = anthropicResponse.content.filter(
+        (block): block is Anthropic.ToolUseBlock => block.type === 'tool_use'
+      );
+
+      if (toolUseBlocks.length === 0) {
+        return extractText(anthropicResponse);
+      }
+
+      const results: string[] = [];
+      for (const toolUse of toolUseBlocks) {
+        heartbeat?.();
+        const result = await executeTool(toolUse.name, toolUse.input);
+        results.push(typeof result === 'string' ? result : JSON.stringify(result));
+      }
+      return results.join('\n');
+    }
+
     const apiMessages: Anthropic.MessageParam[] = messages.map(msg => ({
       role: msg.role as 'user' | 'assistant',
       content: msg.content,

package/plugins/memory/index.ts

@@ -10,39 +10,44 @@ import { getMemoryManager } from '../../src/core/memory.js';
  * 记忆操作参数
  */
 interface MemoryParams {
-  /** 操作类型：remember（记住）或 recall（回忆） */
-  action: 'remember' | 'recall';
+  /** 操作类型：remember（记住）、recall（回忆）或 log（追加每日日志） */
+  action: 'remember' | 'recall' | 'log';
   /** 记忆键（remember 必需，recall 可选） */
   key?: string;
-  /** 记忆值（remember 必需） */
+  /** 记忆值（remember 必需）/ 日志内容（log 必需） */
   value?: string;
-  /** 作用域：user（用户级别，跨会话共享）或 group（会话级别，默认） */
-  scope?: 'user' | 'group';
+  /** 作用域：user（用户级别）或 global（全局共享，默认） */
+  scope?: 'user' | 'global';
 }
 
 const plugin: ToolPlugin = {
   name: 'memory',
-  version: '1.0.0',
-  description: '长期记忆管理，可以记住和回忆重要信息',
+  version: '1.1.0',
+  description: '长期记忆管理，可以记住、回忆重要信息，以及写入每日日志',
   
   schema: {
     name: 'memory',
-    description: `管理长期记忆。支持两种操作：
-- remember: 保存重要信息到长期记忆（用户偏好、重要事实等）
-- recall: 回忆之前保存的信息
+    description: `管理长期记忆和每日日志。
 
-支持两种作用域：
-- user: 用户级别记忆，跨所有会话共享（推荐用于个人偏好）
-- group: 会话级别记忆，仅在当前会话有效（默认）
+**何时用 remember**: 保存持久事实（姓名、偏好、配置等），需要 key 和 value
+**何时用 recall**: 查询之前保存的事实
+**何时用 log**: 记录事件、笔记、动态（"今天做了XX"、"开了会"、"学了XX"），自动按日期归档，无需 key
 
-记忆会持久化到文件，跨会话保持。`,
+示例：
+- "记住我叫张三" → remember(key="user_name", value="用户叫张三")
+- "你现在叫波特" → remember(key="ai_name", value="AI 的名字是波特")
+- "我喜欢吃火锅" → remember(key="user_food", value="用户喜欢吃火锅")
+- "帮我记录今天开了会" → log(value="今天开了会")
+- "我叫什么" → recall(key="user_name")
+
+key 命名建议：用 user_ 前缀表示用户信息，用 ai_ 前缀表示 AI 自身信息。`,
     input_schema: {
       type: 'object',
       properties: {
         action: {
           type: 'string',
-          enum: ['remember', 'recall'],
-          description: 'remember 保存信息，recall 回忆信息'
+          enum: ['remember', 'recall', 'log'],
+          description: 'remember 保存信息，recall 回忆信息，log 追加每日日志'
         },
         key: {
           type: 'string',
@@ -54,8 +59,8 @@ const plugin: ToolPlugin = {
         },
         scope: {
           type: 'string',
-          enum: ['user', 'group'],
-          description: '作用域。user=用户级别（跨会话共享，适合个人偏好），group=会话级别（默认）'
+          enum: ['user', 'global'],
+          description: '作用域。user=用户级别（适合个人偏好），global=全局级别（跨渠道共享，默认）'
         }
       },
       required: ['action']
@@ -63,12 +68,11 @@ const plugin: ToolPlugin = {
   },
   
   async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
-    const { action, key, value, scope = 'group' } = params as MemoryParams;
+    const { action, key, value, scope = 'global' } = params as MemoryParams;
     const mm = getMemoryManager();
-    
-    // 默认使用会话级别记忆（仅当前会话有效）
+
     const isUserScope = scope === 'user';
-    const scopeLabel = isUserScope ? '用户' : '会话';
+    const scopeLabel = isUserScope ? '用户' : '全局';
     
     if (action === 'remember') {
       // 记住信息
@@ -90,7 +94,7 @@ const plugin: ToolPlugin = {
         if (isUserScope) {
           mm.rememberUser(context.userId, key, value);
         } else {
-          mm.remember(context.groupId, key, value);
+          mm.remember(key, value);
         }
         return {
           success: true,
@@ -113,15 +117,15 @@ const plugin: ToolPlugin = {
     if (action === 'recall') {
       // 回忆信息
       try {
-        // 默认同时查询用户级别和会话级别记忆
+        // 默认同时查询用户级别和全局级别记忆
         const userResult = mm.recallUser(context.userId, key);
-        const groupResult = mm.recall(context.groupId, key);
-        
+        const globalResult = mm.recall(key);
+
         if (key) {
-          // 回忆特定键 - 优先返回用户级别，其次会话级别
-          const result = userResult || groupResult;
-          const foundScope = userResult ? '用户' : (groupResult ? '会话' : null);
-          
+          // 回忆特定键 - 优先返回用户级别，其次全局级别
+          const result = userResult || globalResult;
+          const foundScope = userResult ? '用户' : (globalResult ? '全局' : null);
+
           if (result) {
             return {
               success: true,
@@ -144,15 +148,15 @@ const plugin: ToolPlugin = {
             };
           }
         } else {
-          // 回忆所有 - 合并用户级别和会话级别
+          // 回忆所有 - 合并用户级别和全局级别
           const memories: string[] = [];
           if (userResult) {
             memories.push(`【用户记忆】\n${userResult}`);
           }
-          if (groupResult) {
-            memories.push(`【会话记忆】\n${groupResult}`);
+          if (globalResult) {
+            memories.push(`【全局记忆】\n${globalResult}`);
           }
-          
+
           if (memories.length > 0) {
             return {
               success: true,
@@ -180,9 +184,38 @@ const plugin: ToolPlugin = {
       }
     }
     
+    if (action === 'log') {
+      // 追加每日日志
+      if (!value || typeof value !== 'string') {
+        return {
+          success: false,
+          error: 'log 操作需要提供 value（日志内容）'
+        };
+      }
+
+      try {
+        const log = mm.appendDailyLog(value);
+        return {
+          success: true,
+          data: {
+            action: 'logged',
+            date: log.date,
+            time: log.time,
+            content: value,
+            message: `已记录到 ${log.date} 日志`
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `写入日志失败: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    
     return {
       success: false,
-      error: 'action 必须是 remember 或 recall'
+      error: 'action 必须是 remember、recall 或 log'
     };
   }
 };

package/plugins/cancel-task/index.ts

@@ -1,161 +0,0 @@
-/**
- * FlashClaw 插件 - 取消定时任务
- * 取消或暂停定时任务
- */
-
-import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
-import { getTaskById, updateTask, deleteTask } from '../../src/db.js';
-import { MAIN_GROUP_FOLDER } from '../../src/config.js';
-
-/**
- * 取消任务参数
- */
-interface CancelTaskParams {
-  /** 要取消的任务 ID */
-  taskId: string;
-  /** 操作类型：cancel（取消并删除）、pause（暂停）、resume（恢复） */
-  action?: 'cancel' | 'pause' | 'resume';
-}
-
-const plugin: ToolPlugin = {
-  name: 'cancel_task',
-  version: '1.0.0',
-  description: '取消、暂停或恢复定时任务',
-  
-  schema: {
-    name: 'cancel_task',
-    description: '管理定时任务的状态。可以取消（永久删除）、暂停或恢复任务。',
-    input_schema: {
-      type: 'object',
-      properties: {
-        taskId: {
-          type: 'string',
-          description: '任务 ID，可以通过 list_tasks 工具获取'
-        },
-        action: {
-          type: 'string',
-          enum: ['cancel', 'pause', 'resume'],
-          description: '操作类型。cancel 永久删除任务，pause 暂停任务，resume 恢复已暂停的任务。默认为 cancel'
-        }
-      },
-      required: ['taskId']
-    }
-  },
-  
-  async execute(params: unknown, context: ToolContext): Promise<ToolResult> {
-    const { taskId, action = 'cancel' } = params as CancelTaskParams;
-    
-    // 参数验证
-    if (!taskId || typeof taskId !== 'string') {
-      return {
-        success: false,
-        error: '任务 ID 不能为空'
-      };
-    }
-    
-    if (!['cancel', 'pause', 'resume'].includes(action)) {
-      return {
-        success: false,
-        error: '操作类型必须是 cancel、pause 或 resume'
-      };
-    }
-    
-    // 查找任务
-    const task = getTaskById(taskId);
-    
-    if (!task) {
-      return {
-        success: false,
-        error: `任务不存在: ${taskId}`
-      };
-    }
-    
-    // 权限检查：只能操作自己群组的任务，或者 main 群组可以操作所有任务
-    const isMainGroup = context.groupId === MAIN_GROUP_FOLDER;
-    const isOwnTask = task.group_folder === context.groupId;
-    
-    if (!isMainGroup && !isOwnTask) {
-      return {
-        success: false,
-        error: '无权操作其他群组的任务'
-      };
-    }
-    
-    try {
-      switch (action) {
-        case 'cancel': {
-          // 永久删除任务
-          deleteTask(taskId);
-          return {
-            success: true,
-            data: {
-              taskId,
-              action: 'cancelled',
-              message: '任务已永久删除'
-            }
-          };
-        }
-        
-        case 'pause': {
-          // 暂停任务
-          if (task.status === 'paused') {
-            return {
-              success: false,
-              error: '任务已经是暂停状态'
-            };
-          }
-          if (task.status === 'completed') {
-            return {
-              success: false,
-              error: '已完成的任务无法暂停'
-            };
-          }
-          
-          updateTask(taskId, { status: 'paused' });
-          return {
-            success: true,
-            data: {
-              taskId,
-              action: 'paused',
-              message: '任务已暂停，可以使用 resume 操作恢复'
-            }
-          };
-        }
-        
-        case 'resume': {
-          // 恢复任务
-          if (task.status !== 'paused') {
-            return {
-              success: false,
-              error: '只能恢复已暂停的任务'
-            };
-          }
-          
-          updateTask(taskId, { status: 'active' });
-          return {
-            success: true,
-            data: {
-              taskId,
-              action: 'resumed',
-              message: '任务已恢复，将在下一个调度时间执行',
-              nextRun: task.next_run
-            }
-          };
-        }
-        
-        default:
-          return {
-            success: false,
-            error: `未知操作: ${action}`
-          };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: `操作失败: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-};
-
-export default plugin;

package/plugins/cancel-task/plugin.json

@@ -1,9 +0,0 @@
-{
-  "name": "cancel-task",
-  "version": "1.0.0",
-  "type": "tool",
-  "description": "取消定时任务",
-  "main": "index.ts"
-}
-
-

package/plugins/cli-channel/index.ts

@@ -1,51 +0,0 @@
-/**
- * CLI 渠道插件 - 终端交互渠道
- *
- * 作为 FlashClaw 的内置终端渠道，
- * 提供 CLI 命令客户端连接到服务
- *
- * 使用方式：
- * 1. 启动服务: flashclaw start
- * 2. 连接 CLI: flashclaw cli
- */
-
-import type { ChannelPlugin, MessageHandler, PluginConfig, SendMessageResult } from '../../src/plugins/types.js';
-import { createLogger } from '../../src/logger.js';
-
-const logger = createLogger('CLI-Channel');
-
-const plugin: ChannelPlugin & {
-  group: string;
-} = {
-  name: 'cli-channel',
-  version: '1.0.0',
-  group: 'cli-default',
-
-  async init(_config: PluginConfig): Promise<void> {
-    // CLI 渠道不需要特殊配置
-  },
-
-  onMessage(_handler: MessageHandler): void {
-    // CLI 是客户端模式，由 flashclaw cli 命令连接
-    // 消息通过 HTTP API 传输
-  },
-
-  async start(): Promise<void> {
-    // CLI 渠道是客户端模式，不绑定终端
-    // 用户通过 flashclaw cli 命令连接
-    // 消息通过 web-ui 的 /api/chat 接口传输
-    logger.info('CLI 渠道已就绪，使用 flashclaw cli 连接服务');
-  },
-
-  async stop(): Promise<void> {
-    // 清理资源
-  },
-
-  async sendMessage(_chatId: string, content: string): Promise<SendMessageResult> {
-    // CLI 渠道的消息由 flashclaw cli 命令处理
-    // 这里不需要实现（消息通过 API 传输）
-    return { success: true };
-  }
-};
-
-export default plugin;

package/plugins/cli-channel/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "cli-channel",
-  "version": "1.0.0",
-  "type": "channel",
-  "description": "终端交互渠道 - CLI REPL 模式",
-  "main": "index.ts",
-  "dependencies": []
-}