flashclaw 1.7.0 → 1.8.0

package/plugins/cli-channel/index.ts

@@ -1,8 +1,8 @@
 /**
  * CLI 渠道插件 - 终端交互渠道
  *
- * 作为 FlashClaw 的内置终端渠道，
- * 提供 CLI 命令客户端连接到服务
+ * 提供独立的 HTTP API 供 flashclaw cli 客户端连接。
+ * 通过核心 API 层（core-api）处理消息和命令，不依赖 web-ui。
  *
  * 使用方式：
  * 1. 启动服务: flashclaw start
@@ -11,39 +11,223 @@
 
 import type { ChannelPlugin, MessageHandler, PluginConfig, SendMessageResult } from '../../src/plugins/types.js';
 import { createLogger } from '../../src/logger.js';
+import http from 'http';
 
 const logger = createLogger('CLI-Channel');
 
-const plugin: ChannelPlugin & {
-  group: string;
-} = {
+const DEFAULT_PORT = 3001;
+let server: http.Server | null = null;
+let cliPort = DEFAULT_PORT;
+
+/**
+ * 获取核心 API（通过全局变量注入）
+ */
+function getCoreApi() {
+  return (global as Record<string, unknown>).__flashclaw_core_api as typeof import('../../src/core-api.js') | undefined;
+}
+
+/**
+ * 解析 JSON 请求体
+ */
+function parseBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/**
+ * 发送 JSON 响应
+ */
+function sendJson(res: http.ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+  });
+  res.end(JSON.stringify(data));
+}
+
+/**
+ * 处理 HTTP 请求
+ */
+async function handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+  const url = req.url || '/';
+  const method = req.method || 'GET';
+
+  // CORS preflight
+  if (method === 'OPTIONS') {
+    res.writeHead(204, {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end();
+    return;
+  }
+
+  const api = getCoreApi();
+  if (!api) {
+    sendJson(res, 503, { error: 'Core API not ready' });
+    return;
+  }
+
+  try {
+    // GET /api/status
+    if (url === '/api/status' && method === 'GET') {
+      sendJson(res, 200, api.getStatus());
+      return;
+    }
+
+    // GET /api/chat/history?group=xxx
+    if (url.startsWith('/api/chat/history') && method === 'GET') {
+      const params = new URL(url, 'http://localhost').searchParams;
+      const group = params.get('group') || 'main';
+      const chatId = `${group}-chat`;
+      const messages = api.getHistory(chatId);
+      sendJson(res, 200, { success: true, messages });
+      return;
+    }
+
+    // POST /api/chat/clear
+    if (url === '/api/chat/clear' && method === 'POST') {
+      const body = await parseBody(req);
+      const group = (body.group as string) || 'main';
+      api.clearSession(group);
+      sendJson(res, 200, { success: true });
+      return;
+    }
+
+    // POST /api/chat/stream — 流式对话
+    if (url === '/api/chat/stream' && method === 'POST') {
+      const body = await parseBody(req);
+      const message = body.message as string;
+      const group = (body.group as string) || 'main';
+
+      if (!message) {
+        sendJson(res, 400, { error: 'message is required' });
+        return;
+      }
+
+      // 流式响应
+      res.writeHead(200, {
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Transfer-Encoding': 'chunked',
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'no-cache',
+      });
+
+      try {
+        const result = await api.chat({
+          message,
+          group,
+          userId: 'cli-user',
+          platform: 'cli-channel',
+          onToken: (chunk: string) => {
+            res.write(chunk);
+          },
+          onToolUse: (name: string, input: unknown) => {
+            res.write(`[TOOL:${JSON.stringify({ name, input })}]`);
+          },
+        });
+
+        // 发送 metrics
+        if (result.metrics) {
+          res.write(`[METRICS:${JSON.stringify({
+            durationMs: result.metrics.durationMs,
+            model: result.metrics.model,
+            inputTokens: result.metrics.usage?.inputTokens ?? null,
+            outputTokens: result.metrics.usage?.outputTokens ?? null,
+          })}]`);
+        }
+      } catch (err) {
+        res.write(`\n\n❌ 错误: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
+      res.end();
+      return;
+    }
+
+    // POST /api/chat — 非流式对话
+    if (url === '/api/chat' && method === 'POST') {
+      const body = await parseBody(req);
+      const message = body.message as string;
+      const group = (body.group as string) || 'main';
+
+      if (!message) {
+        sendJson(res, 400, { error: 'message is required' });
+        return;
+      }
+
+      const result = await api.chat({ message, group, userId: 'cli-user', platform: 'cli-channel' });
+      sendJson(res, 200, { response: result.response, metrics: result.metrics });
+      return;
+    }
+
+    // POST /api/compact
+    if (url === '/api/compact' && method === 'POST') {
+      const body = await parseBody(req);
+      const group = (body.group as string) || 'main';
+      const chatId = `${group}-chat`;
+      const summary = await api.compactSession(chatId, group, 'cli-user', 'cli-channel');
+      sendJson(res, 200, { success: true, summary });
+      return;
+    }
+
+    // 404
+    sendJson(res, 404, { error: 'Not Found' });
+  } catch (err) {
+    logger.error({ err, url }, 'CLI-Channel API 错误');
+    sendJson(res, 500, { error: err instanceof Error ? err.message : 'Internal Server Error' });
+  }
+}
+
+const plugin: ChannelPlugin = {
   name: 'cli-channel',
-  version: '1.0.0',
-  group: 'cli-default',
+  version: '2.0.0',
 
-  async init(_config: PluginConfig): Promise<void> {
-    // CLI 渠道不需要特殊配置
+  async init(config: PluginConfig): Promise<void> {
+    cliPort = Number(config.port || process.env.CLI_PORT || DEFAULT_PORT);
   },
 
   onMessage(_handler: MessageHandler): void {
-    // CLI 是客户端模式，由 flashclaw cli 命令连接
-    // 消息通过 HTTP API 传输
+    // CLI 渠道通过 HTTP API 接收消息，不需要 onMessage handler
   },
 
   async start(): Promise<void> {
-    // CLI 渠道是客户端模式，不绑定终端
-    // 用户通过 flashclaw cli 命令连接
-    // 消息通过 web-ui 的 /api/chat 接口传输
-    logger.info('CLI 渠道已就绪，使用 flashclaw cli 连接服务');
+    server = http.createServer((req, res) => {
+      handleRequest(req, res).catch(err => {
+        logger.error({ err }, 'CLI-Channel 请求处理失败');
+        if (!res.headersSent) {
+          sendJson(res, 500, { error: 'Internal Server Error' });
+        }
+      });
+    });
+
+    server.listen(cliPort, () => {
+      logger.debug({ port: cliPort }, '⚡ CLI 渠道 API 已启动');
+    });
   },
 
   async stop(): Promise<void> {
-    // 清理资源
+    if (server) {
+      await new Promise<void>((resolve) => {
+        server!.close(() => resolve());
+      });
+      server = null;
+      logger.info('⚡ CLI 渠道 API 已停止');
+    }
   },
 
-  async sendMessage(_chatId: string, content: string): Promise<SendMessageResult> {
-    // CLI 渠道的消息由 flashclaw cli 命令处理
-    // 这里不需要实现（消息通过 API 传输）
+  async sendMessage(_chatId: string, _content: string): Promise<SendMessageResult> {
+    // CLI 渠道的消息通过 HTTP 流式响应直接返回，不需要主动推送
     return { success: true };
   }
 };

package/plugins/memory/index.ts

@@ -5,16 +5,18 @@
 
 import { ToolPlugin, ToolContext, ToolResult } from '../../src/plugins/types.js';
 import { getMemoryManager } from '../../src/core/memory.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 /**
  * 记忆操作参数
  */
 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';
@@ -22,27 +24,28 @@ interface MemoryParams {
 
 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="name", value="张三")
+- "帮我记录今天开了会" → log(value="今天开了会")
+- "我叫什么" → recall(key="name")`,
     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',
@@ -180,9 +183,56 @@ const plugin: ToolPlugin = {
       }
     }
     
+    if (action === 'log') {
+      // 追加每日日志
+      if (!value || typeof value !== 'string') {
+        return {
+          success: false,
+          error: 'log 操作需要提供 value（日志内容）'
+        };
+      }
+      
+      try {
+        const mm = getMemoryManager();
+        const memoryDir = (mm as unknown as { config: { memoryDir: string } }).config.memoryDir;
+        const logsDir = path.join(memoryDir, 'daily');
+        if (!fs.existsSync(logsDir)) {
+          fs.mkdirSync(logsDir, { recursive: true });
+        }
+        
+        const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+        const logFile = path.join(logsDir, `${today}.md`);
+        const time = new Date().toLocaleTimeString('zh-CN', { hour12: false });
+        const entry = `- [${time}] ${value}\n`;
+        
+        // 如果文件不存在，添加标题
+        if (!fs.existsSync(logFile)) {
+          fs.writeFileSync(logFile, `# ${today} 日志\n\n${entry}`, 'utf-8');
+        } else {
+          fs.appendFileSync(logFile, entry, 'utf-8');
+        }
+        
+        return {
+          success: true,
+          data: {
+            action: 'logged',
+            date: today,
+            time,
+            content: value,
+            message: `已记录到 ${today} 日志`
+          }
+        };
+      } 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'
     };
   }
 };