@huyooo/ai-chat-bridge-electron 0.1.4 → 0.1.8

package/src/main/index.ts

@@ -0,0 +1,611 @@
+/**
+ * Electron 主进程桥接
+ * 
+ * 在主进程中调用，注册 IPC handlers
+ * 集成 SQLite 存储
+ */
+
+import { ipcMain, shell } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+import { 
+  HybridAgent, 
+  type AgentConfig, 
+  type ChatEvent,
+  type ChatOptions,
+  type ChatMode,
+  type ProviderType,
+  type ToolConfigItem,
+  MODELS,
+  DEFAULT_MODEL,
+} from '@huyooo/ai-chat-core';
+import { createSearchElectronBridge } from '@huyooo/ai-search/bridge/electron';
+
+// 注意：工具解析已移至 HybridAgent 内部（asyncInit 方法）
+// 这里不再需要提前解析，直接传递 ToolConfigItem[] 给 HybridAgent
+
+/** 文件信息 */
+export interface FileInfo {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  size: number;
+  modifiedAt: Date;
+  extension: string;
+}
+import {
+  createStorage,
+  getDefaultStoragePath,
+  type StorageAdapter,
+  type StorageContext,
+  type SessionRecord,
+  type MessageRecord,
+  type CreateSessionInput,
+  type CreateMessageInput,
+} from '@huyooo/ai-chat-storage';
+
+export interface ElectronBridgeOptions extends Omit<AgentConfig, 'tools'> {
+  /** IPC channel 前缀 */
+  channelPrefix?: string;
+  /** 
+   * 统一数据目录（推荐）
+   * 所有数据都存储在此目录下：
+   * - db.sqlite: 对话历史
+   * - search-data/: 搜索索引
+   * 默认: ~/.ai-chat/
+   */
+  dataDir?: string;
+  /** 
+   * SQLite 数据库路径（可选，覆盖 dataDir 设置）
+   * @deprecated 推荐使用 dataDir
+   */
+  storagePath?: string;
+  /** 默认租户上下文 */
+  defaultContext?: StorageContext;
+  /** 
+   * 工具列表（Vite 插件风格）
+   * 支持：ToolPlugin、Promise<ToolPlugin>
+   */
+  tools?: ToolConfigItem[];
+}
+
+/** 发送消息参数 */
+interface SendMessageParams {
+  message: string;
+  images?: string[];
+  options?: ChatOptions;
+  sessionId?: string;
+}
+
+/** 会话相关参数 */
+interface SessionParams {
+  id?: string;
+  title?: string;
+  model?: string;
+  mode?: 'agent' | 'plan' | 'ask';
+  webSearchEnabled?: boolean;
+  thinkingEnabled?: boolean;
+  hidden?: boolean;
+}
+
+/** 消息相关参数 */
+interface MessageParams {
+  /** 消息 ID（可选，如果不传则自动生成） */
+  id?: string;
+  sessionId: string;
+  role: 'user' | 'assistant';
+  content: string;
+  /** 生成此消息时使用的模型 */
+  model?: string;
+  /** 生成此消息时使用的模式 (ask/agent) */
+  mode?: string;
+  /** 生成此消息时是否启用 web 搜索 */
+  webSearchEnabled?: boolean;
+  /** 生成此消息时是否启用深度思考 */
+  thinkingEnabled?: boolean;
+  /** 执行步骤列表 JSON */
+  steps?: string;
+  operationIds?: string;
+}
+
+/** 更新消息参数 */
+interface UpdateMessageParams {
+  id: string;
+  content?: string;
+  steps?: string;
+}
+
+/**
+ * 创建 Electron IPC 桥接
+ * 
+ * @example
+ * ```ts
+ * import { createElectronBridge } from '@huyooo/ai-chat-bridge-electron/main';
+ * 
+ * app.whenReady().then(async () => {
+ *   const { agent, storage } = await createElectronBridge({
+ *     arkApiKey: 'xxx',
+ *     geminiApiKey: 'xxx',
+ *   });
+ * });
+ * ```
+ */
+export async function createElectronBridge(options: ElectronBridgeOptions) {
+  const { 
+    channelPrefix = 'ai-chat', 
+    dataDir,
+    storagePath,
+    defaultContext = {},
+    ...agentConfig 
+  } = options;
+  
+  // 计算实际的存储路径
+  // 优先级：storagePath > dataDir/db.sqlite > 默认路径
+  const resolvedStoragePath = storagePath 
+    || (dataDir ? `${dataDir}/db.sqlite` : undefined);
+  
+  // 🔴 重要：在处理任何 tools 之前，先初始化搜索 Electron 桥接
+  // 这样当 searchPlugin 开始后台索引时，全局进度监听器已经注册好了
+  createSearchElectronBridge({
+    ipcMain,
+    channelPrefix,
+  }).init();
+  
+  // 工具批准请求的等待队列（key: toolCallId, value: { resolve, reject, webContents }）
+  const pendingApprovals = new Map<string, {
+    resolve: (approved: boolean) => void;
+    reject: (error: Error) => void;
+    webContents: Electron.WebContents;
+  }>();
+  
+  // 创建工具批准回调
+  const toolApprovalCallback = async (toolCall: {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+  }): Promise<boolean> => {
+      console.log('[Main] 工具批准回调被调用:', toolCall.name);
+      // 查找当前请求的 webContents（通过最近的 send 调用）
+      // 这里我们需要一个更好的方式来获取 webContents
+      // 暂时使用一个全局变量存储当前的 webContents
+      const currentWebContents = (global as { currentWebContents?: Electron.WebContents }).currentWebContents;
+      if (!currentWebContents) {
+        console.log('[Main] 警告: 没有 webContents，默认批准');
+        // 如果没有 webContents，默认批准（向后兼容）
+        return true;
+      }
+
+      return new Promise<boolean>((resolve, reject) => {
+        // 存储 Promise 的 resolve/reject
+        pendingApprovals.set(toolCall.id, {
+          resolve,
+          reject,
+          webContents: currentWebContents,
+        });
+
+        // 发送批准请求到前端
+        console.log('[Main] 发送工具批准请求到前端:', toolCall.name);
+        currentWebContents.send(`${channelPrefix}:toolApprovalRequest`, {
+          id: toolCall.id,
+          name: toolCall.name,
+          args: toolCall.args,
+        });
+        
+        // 不设置超时，让用户有足够时间思考
+      });
+  };
+  
+  // 初始化存储（在 agent 之前，因为 getAutoRunConfig 需要访问 storage）
+  const storage = await createStorage({
+    type: 'sqlite',
+    sqlitePath: resolvedStoragePath || getDefaultStoragePath(),
+  });
+
+  // 获取上下文
+  const getContext = (): StorageContext => defaultContext;
+  
+  // 动态获取自动运行配置（从数据库实时读取）
+  const getAutoRunConfig = async () => {
+    try {
+      const configJson = await storage.getUserSetting('autoRunConfig', getContext());
+      if (configJson) {
+        return JSON.parse(configJson) as {
+          mode?: 'run-everything' | 'manual';
+        };
+      }
+    } catch (error) {
+      console.error('[Main] 获取 autoRunConfig 失败:', error);
+    }
+    return undefined;
+  };
+  
+  // 创建 Agent（工具会在 HybridAgent 的 asyncInit 中自动解析）
+  const agent = new HybridAgent({
+    ...agentConfig,
+    // tools 直接传递 ToolConfigItem[]，HybridAgent 会在 asyncInit 中解析
+    tools: options.tools,
+    onToolApprovalRequest: toolApprovalCallback,
+    getAutoRunConfig,
+  });
+
+  // ============ AI Chat API ============
+
+  // 获取可用模型
+  ipcMain.handle(`${channelPrefix}:models`, () => {
+    return MODELS;
+  });
+
+  // 发送消息
+  ipcMain.handle(`${channelPrefix}:send`, async (event, params: SendMessageParams) => {
+    const webContents = event.sender;
+    const { message, images, options = {}, sessionId } = params;
+
+    // 存储当前 webContents，供工具批准回调使用
+    (global as { currentWebContents?: Electron.WebContents }).currentWebContents = webContents;
+
+    console.log('[AI-Chat] 收到消息:', { message, options, images: images?.length || 0, sessionId });
+    console.log('[AI-Chat] autoRunConfig:', JSON.stringify(options.autoRunConfig, null, 2));
+
+    try {
+      for await (const chatEvent of agent.chat(message, options, images)) {
+        // 调试：打印事件
+        console.log('[AI-Chat] 事件:', chatEvent.type, 
+          chatEvent.type === 'text_delta' ? (chatEvent.data as { content: string }).content.slice(0, 20) : 
+          chatEvent.type === 'thinking_delta' ? (chatEvent.data as { content: string }).content.slice(0, 20) :
+          chatEvent.type === 'search_result' ? `搜索完成 ${(chatEvent.data as { results?: unknown[] }).results?.length || 0} 条` :
+          JSON.stringify(chatEvent.data).slice(0, 100)
+        );
+        
+        // 发送事件到渲染进程（携带 sessionId 以区分不同会话）
+        if (!webContents.isDestroyed()) {
+          webContents.send(`${channelPrefix}:progress`, { ...chatEvent, sessionId });
+        }
+      }
+      console.log('[AI-Chat] 完成');
+    } catch (error) {
+      console.error('[AI-Chat] 错误:', error);
+      if (error instanceof Error) {
+        console.error('[AI-Chat] 错误详情:', {
+          message: error.message,
+          stack: error.stack,
+          name: error.name,
+        });
+      }
+      if (!webContents.isDestroyed()) {
+        const errorData = error instanceof Error 
+          ? { 
+              category: 'api',
+              message: error.message || String(error),
+              cause: error.stack,
+            }
+          : { 
+              category: 'api',
+              message: String(error),
+            };
+        webContents.send(`${channelPrefix}:progress`, { 
+          type: 'error', 
+          data: errorData,
+          sessionId
+        });
+      }
+    } finally {
+      // 清理当前 webContents
+      delete (global as { currentWebContents?: Electron.WebContents }).currentWebContents;
+    }
+  });
+
+  // 工具批准响应
+  ipcMain.handle(`${channelPrefix}:toolApprovalResponse`, (_event, params: { id: string; approved: boolean }) => {
+    const { id, approved } = params;
+    const pending = pendingApprovals.get(id);
+    if (pending) {
+      pendingApprovals.delete(id);
+      pending.resolve(approved);
+    }
+  });
+
+  // 取消请求
+  ipcMain.handle(`${channelPrefix}:cancel`, () => {
+    agent.abort();
+  });
+
+  // ============ 用户设置 API ============
+
+  // 获取用户设置
+  ipcMain.handle(`${channelPrefix}:settings:get`, async (_event, key: string) => {
+    return storage.getUserSetting(key, getContext());
+  });
+
+  // 设置用户设置
+  ipcMain.handle(`${channelPrefix}:settings:set`, async (_event, key: string, value: string) => {
+    await storage.setUserSetting(key, value, getContext());
+    return { success: true };
+  });
+
+  // 获取所有用户设置
+  ipcMain.handle(`${channelPrefix}:settings:getAll`, async () => {
+    return storage.getUserSettings(getContext());
+  });
+
+  // 删除用户设置
+  ipcMain.handle(`${channelPrefix}:settings:delete`, async (_event, key: string) => {
+    await storage.deleteUserSetting(key, getContext());
+    return { success: true };
+  });
+
+  // 无状态架构：历史通过 ChatOptions.history 传入，不再需要内存历史 API
+
+  // 设置当前工作目录
+  ipcMain.handle(`${channelPrefix}:setCwd`, (_event, dir: string) => {
+    agent.setCwd(dir);
+  });
+
+  // 获取当前配置
+  ipcMain.handle(`${channelPrefix}:config`, () => {
+    return agent.getConfig();
+  });
+
+  // ============ Storage API ============
+
+  // 获取会话列表
+  ipcMain.handle(`${channelPrefix}:sessions:list`, async () => {
+    return storage.getSessions(getContext());
+  });
+
+  // 获取单个会话
+  ipcMain.handle(`${channelPrefix}:sessions:get`, async (_event, id: string) => {
+    return storage.getSession(id, getContext());
+  });
+
+  // 创建会话
+  ipcMain.handle(`${channelPrefix}:sessions:create`, async (_event, params: SessionParams) => {
+    // 无状态架构：历史通过 ChatOptions.history 传入，不需要清空内存
+    
+    const input: CreateSessionInput = {
+      id: params.id || crypto.randomUUID(),
+      title: params.title || '新对话',
+      model: params.model || DEFAULT_MODEL,
+      mode: (params.mode || 'agent') as 'agent' | 'plan' | 'ask',
+      webSearchEnabled: params.webSearchEnabled ?? true,
+      thinkingEnabled: params.thinkingEnabled ?? true,
+      hidden: params.hidden ?? false,
+    };
+    return storage.createSession(input, getContext());
+  });
+
+  // 更新会话
+  ipcMain.handle(`${channelPrefix}:sessions:update`, async (_event, id: string, data: Partial<SessionParams>) => {
+    await storage.updateSession(id, data, getContext());
+    return storage.getSession(id, getContext());
+  });
+
+  // 删除会话
+  ipcMain.handle(`${channelPrefix}:sessions:delete`, async (_event, id: string) => {
+    await storage.deleteSession(id, getContext());
+    return { success: true };
+  });
+
+  // 获取消息列表
+  ipcMain.handle(`${channelPrefix}:messages:list`, async (_event, sessionId: string) => {
+    return storage.getMessages(sessionId, getContext());
+  });
+
+  // 保存消息
+  ipcMain.handle(`${channelPrefix}:messages:save`, async (_event, params: MessageParams) => {
+    const input: CreateMessageInput = {
+      id: params.id || crypto.randomUUID(),
+      sessionId: params.sessionId,
+      role: params.role,
+      content: params.content,
+      model: params.model || null,
+      mode: params.mode || null,
+      webSearchEnabled: params.webSearchEnabled ?? null,
+      thinkingEnabled: params.thinkingEnabled ?? null,
+      steps: params.steps || null,
+      operationIds: params.operationIds || null,
+    };
+    return storage.saveMessage(input, getContext());
+  });
+
+  // 更新消息（增量保存）
+  ipcMain.handle(`${channelPrefix}:messages:update`, async (_event, params: UpdateMessageParams) => {
+    await storage.updateMessage(params.id, {
+      content: params.content,
+      steps: params.steps,
+    }, getContext());
+    return { success: true };
+  });
+
+  // 删除指定时间之后的消息（用于分叉）
+  ipcMain.handle(`${channelPrefix}:messages:deleteAfter`, async (_event, sessionId: string, timestamp: number) => {
+    await storage.deleteMessagesAfter(sessionId, new Date(timestamp), getContext());
+    return { success: true };
+  });
+
+  // 获取操作日志
+  ipcMain.handle(`${channelPrefix}:operations:list`, async (_event, sessionId: string) => {
+    return storage.getOperations(sessionId, getContext());
+  });
+
+  // 获取回收站
+  ipcMain.handle(`${channelPrefix}:trash:list`, async () => {
+    return storage.getTrashItems?.(getContext()) || [];
+  });
+
+  // 恢复回收站项目
+  ipcMain.handle(`${channelPrefix}:trash:restore`, async (_event, id: string) => {
+    return storage.restoreFromTrash?.(id, getContext());
+  });
+
+  // ============ System API ============
+  
+  // 在系统默认浏览器中打开链接
+  ipcMain.handle(`${channelPrefix}:openExternal`, async (_event, url: string) => {
+    return shell.openExternal(url);
+  });
+
+  // ============ File System API ============
+
+  // 列出目录内容
+  ipcMain.handle(`${channelPrefix}:fs:listDir`, async (_event, dirPath: string): Promise<FileInfo[]> => {
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const files: FileInfo[] = [];
+
+      for (const entry of entries) {
+        // 跳过隐藏文件
+        if (entry.name.startsWith('.')) continue;
+
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+          const stats = fs.statSync(fullPath);
+          files.push({
+            name: entry.name,
+            path: fullPath,
+            isDirectory: entry.isDirectory(),
+            size: stats.size,
+            modifiedAt: stats.mtime,
+            extension: entry.isDirectory() ? '' : path.extname(entry.name).toLowerCase(),
+          });
+        } catch {
+          // 跳过无法访问的文件
+        }
+      }
+
+      // 排序：目录在前，文件在后，按名称排序
+      return files.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory) return -1;
+        if (!a.isDirectory && b.isDirectory) return 1;
+        return a.name.localeCompare(b.name);
+      });
+    } catch (error) {
+      console.error('[AI-Chat] 列出目录失败:', error);
+      return [];
+    }
+  });
+
+  // 检查路径是否存在
+  ipcMain.handle(`${channelPrefix}:fs:exists`, async (_event, filePath: string): Promise<boolean> => {
+    return fs.existsSync(filePath);
+  });
+
+  // 获取文件信息
+  ipcMain.handle(`${channelPrefix}:fs:stat`, async (_event, filePath: string): Promise<FileInfo | null> => {
+    try {
+      const stats = fs.statSync(filePath);
+      return {
+        name: path.basename(filePath),
+        path: filePath,
+        isDirectory: stats.isDirectory(),
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        extension: stats.isDirectory() ? '' : path.extname(filePath).toLowerCase(),
+      };
+    } catch {
+      return null;
+    }
+  });
+
+  // 读取文件内容（文本文件）
+  ipcMain.handle(`${channelPrefix}:fs:readFile`, async (_event, filePath: string): Promise<string | null> => {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      return null;
+    }
+  });
+
+  // 读取文件为 base64（图片等二进制文件）
+  ipcMain.handle(`${channelPrefix}:fs:readFileBase64`, async (_event, filePath: string): Promise<string | null> => {
+    try {
+      const buffer = fs.readFileSync(filePath);
+      return buffer.toString('base64');
+    } catch {
+      return null;
+    }
+  });
+
+  // 获取用户主目录
+  ipcMain.handle(`${channelPrefix}:fs:homeDir`, async (): Promise<string> => {
+    return process.env.HOME || process.env.USERPROFILE || '/';
+  });
+
+  // 解析路径（处理 ~）
+  ipcMain.handle(`${channelPrefix}:fs:resolvePath`, async (_event, inputPath: string): Promise<string> => {
+    if (inputPath.startsWith('~')) {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || '/';
+      return path.join(homeDir, inputPath.slice(1));
+    }
+    return path.resolve(inputPath);
+  });
+
+  // 获取父目录
+  ipcMain.handle(`${channelPrefix}:fs:parentDir`, async (_event, dirPath: string): Promise<string> => {
+    return path.dirname(dirPath);
+  });
+
+  // ============ File System Watch API ============
+  
+  // 存储活跃的 watcher
+  const activeWatchers = new Map<string, fs.FSWatcher>();
+  
+  // 监听目录变化
+  ipcMain.handle(`${channelPrefix}:fs:watchDir`, async (event, dirPath: string): Promise<boolean> => {
+    const webContents = event.sender;
+    
+    // 如果已经在监听，先停止
+    if (activeWatchers.has(dirPath)) {
+      activeWatchers.get(dirPath)?.close();
+      activeWatchers.delete(dirPath);
+    }
+    
+    try {
+      const watcher = fs.watch(dirPath, { persistent: false }, (eventType, filename) => {
+        if (!webContents.isDestroyed()) {
+          webContents.send(`${channelPrefix}:fs:dirChange`, {
+            dirPath,
+            eventType,
+            filename,
+          });
+        }
+      });
+      
+      watcher.on('error', (error) => {
+        console.error('[AI-Chat] Watch error:', error);
+        activeWatchers.delete(dirPath);
+      });
+      
+      activeWatchers.set(dirPath, watcher);
+      return true;
+    } catch (error) {
+      console.error('[AI-Chat] Failed to watch directory:', error);
+      return false;
+    }
+  });
+  
+  // 停止监听目录
+  ipcMain.handle(`${channelPrefix}:fs:unwatchDir`, async (_event, dirPath: string): Promise<void> => {
+    const watcher = activeWatchers.get(dirPath);
+    if (watcher) {
+      watcher.close();
+      activeWatchers.delete(dirPath);
+    }
+  });
+
+  return { agent, storage };
+}
+
+// 导出类型
+export type { 
+  AgentConfig, 
+  ChatEvent,
+  ChatOptions,
+  ChatMode,
+  ProviderType,
+  StorageAdapter,
+  StorageContext,
+  SessionRecord,
+  MessageRecord,
+};
+
+export { MODELS };