metona-ai-desktop/electron/ipc/data.ts

/**
 * IPC Data Handlers — 数据导出与清理域（P2-9 从 handlers.ts 拆分）
 */

import { ipcMain } from 'electron';
import type { IPCContext } from './context';
import log from 'electron-log';

/**
 * 导出限流常量：单会话导出的最大消息条数。
 *
 * 背景：导出会把所有会话×所有消息×完整 toolResult 一次性 JSON.stringify 成单个 Blob
 * 传到渲染进程。含 view_image 的会话单条 tool_result 就有 ~6.7MB base64 dataUrl，
 * 全量导出会直接撑爆渲染进程堆导致 OOM 崩溃。
 *
 * 双重防护：
 * 1. 剥离每条 tool 消息中的 dataUrl 等超大 base64（sanitizeExportMessage）
 * 2. 全量导出时按会话限制消息条数（MAX_EXPORT_MESSAGES_PER_SESSION）
 */
const MAX_EXPORT_MESSAGES_PER_SESSION = 2000;

/**
 * 剥离导出消息中的超大 base64 字段（如 view_image 的 dataUrl）。
 * 仅用于导出快照——原数据库数据不受影响。
 */
const sanitizeExportMessage = (msg: Record<string, unknown>): Record<string, unknown> => {
  const toolResult = msg.toolResult as Record<string, unknown> | undefined;
  if (toolResult && typeof toolResult === 'object' && 'result' in toolResult) {
    const result = toolResult.result;
    // result 含 dataUrl（view_image 等图片结果）：剥离 dataUrl，保留 path/size/mimeType 等小字段
    if (result && typeof result === 'object' && !Array.isArray(result) && 'dataUrl' in result) {
      const { dataUrl: _omit, ...rest } = result as Record<string, unknown>;
      void _omit;
      return {
        ...msg,
        toolResult: { ...toolResult, result: { ...rest, _displayNote: '[image base64 omitted in export]' } },
      };
    }
  }
  // attachments[].preview（用户上传图片的 base64 缩略图）也一并剥离，避免导出文件膨胀
  const attachments = msg.attachments;
  if (Array.isArray(attachments)) {
    const sanitized = attachments.map((att) => {
      if (att && typeof att === 'object' && 'preview' in att) {
        const { preview: _omit, ...rest } = att as Record<string, unknown>;
        void _omit;
        return { ...rest, _displayNote: '[preview omitted in export]' };
      }
      return att;
    });
    return { ...msg, attachments: sanitized };
  }
  return msg;
};

export function registerDataHandlers(ctx: IPCContext): void {
  const { sessionService, configService } = ctx;

  ipcMain.handle('data:export', async (_event, sessionId?: string) => {
    try {
      if (sessionId) {
        // 导出单个会话：剥离超大 base64 后返回
        const messages = sessionService.getMessages(sessionId);
        const sanitized = messages.map((m) => sanitizeExportMessage(m as unknown as Record<string, unknown>));
        return { success: true, data: sanitized };
      }
      // 导出所有会话：剥离 dataUrl + 每会话限条数，防渲染进程 Blob 序列化 OOM
      const sessions = sessionService.list();
      const allData: Record<string, unknown> = { sessions: [], config: configService.getAll() };
      for (const session of sessions) {
        const rawMessages = sessionService.getMessages(session.id, { limit: MAX_EXPORT_MESSAGES_PER_SESSION });
        const sanitizedMessages = rawMessages.map((m) => sanitizeExportMessage(m as unknown as Record<string, unknown>));
        (allData.sessions as Array<Record<string, unknown>>).push({
          ...session,
          messages: sanitizedMessages,
          truncated: rawMessages.length >= MAX_EXPORT_MESSAGES_PER_SESSION,
        });
      }
      return { success: true, data: allData };
    } catch (error) {
      return { success: false, error: (error as Error).message };
    }
  });

  ipcMain.handle('data:clearSessions', async () => {
    // M-40 修复: 危险操作审计日志，便于追踪异常调用
    log.warn('[DATA] DANGER: clearSessions invoked — all sessions and messages will be deleted');
    const db = sessionService.getDB();
    try {
      db.exec('BEGIN');
      const msgCount = db.prepare('SELECT COUNT(*) as c FROM messages').get() as { c: number };
      const sessCount = db.prepare('SELECT COUNT(*) as c FROM sessions').get() as { c: number };
      db.exec('DELETE FROM messages');
      db.exec('DELETE FROM sessions');
      db.exec('COMMIT');
      log.info(`[DATA] All sessions cleared: ${sessCount.c} sessions, ${msgCount.c} messages deleted`);
      return { success: true, deletedSessions: sessCount.c, deletedMessages: msgCount.c };
    } catch (error) {
      try { db.exec('ROLLBACK'); } catch { /* 忽略回滚错误 */ }
      log.error('[DATA] clearSessions failed:', (error as Error).message);
      return { success: false, error: (error as Error).message };
    }
  });

  ipcMain.handle('data:clearMemories', async () => {
    // M-40 修复: 危险操作审计日志
    log.warn('[DATA] DANGER: clearMemories invoked — all memories will be deleted');
    const db = sessionService.getDB();
    try {
      // M-41 修复: 三个 DELETE 操作用事务包裹，防止部分失败导致三类记忆数据不一致
      const epiCount = db.prepare('SELECT COUNT(*) as c FROM episodic_memories').get() as { c: number };
      const semCount = db.prepare('SELECT COUNT(*) as c FROM semantic_memories').get() as { c: number };
      const workCount = db.prepare('SELECT COUNT(*) as c FROM working_memories').get() as { c: number };
      db.exec('BEGIN');
      db.exec('DELETE FROM episodic_memories');
      db.exec('DELETE FROM semantic_memories');
      db.exec('DELETE FROM working_memories');
      db.exec('COMMIT');
      log.info(`[DATA] All memories cleared: ${epiCount.c} episodic, ${semCount.c} semantic, ${workCount.c} working memories deleted`);
      return { success: true, deletedEpisodic: epiCount.c, deletedSemantic: semCount.c, deletedWorking: workCount.c };
    } catch (error) {
      // M-41 修复: 失败时回滚事务，确保数据一致性
      try { db.exec('ROLLBACK'); } catch { /* 忽略回滚错误 */ }
      log.error('[DATA] clearMemories failed:', (error as Error).message);
      return { success: false, error: (error as Error).message };
    }
  });

  ipcMain.handle('data:clearAuditLogs', async () => {
    // 审计日志是 INSERT-ONLY，需要先禁用触发器
    const db = sessionService.getDB();
    try {
      db.exec('BEGIN');
      db.exec('DROP TRIGGER IF EXISTS audit_no_delete');
      db.exec('DELETE FROM audit_logs');
      db.exec(`
        CREATE TRIGGER audit_no_delete BEFORE DELETE ON audit_logs
        BEGIN
          SELECT RAISE(ABORT, 'Audit logs are INSERT-ONLY. Deletion is not allowed.');
        END
      `);
      db.exec('COMMIT');
      log.info('[DATA] Audit logs cleared');
      return { success: true };
    } catch (error) {
      try { db.exec('ROLLBACK'); } catch { /* 忽略回滚错误 */ }
      return { success: false, error: (error as Error).message };
    }
  });
}