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';
import { sanitizeExportConfig } from './shared';

/**
 * 导出限流常量：单会话导出的最大消息条数。
 *
 * 背景：导出会把所有会话×所有消息×完整 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, auditService } = 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
      // S-1 修复：config 走 sanitizeExportConfig 脱敏 —— getAll() 对敏感 key
      // 解密返回明文，直接透传会把明文 API Key 写入用户下载的导出文件
      const sessions = sessionService.list();
      const allData: Record<string, unknown> = {
        sessions: [],
        config: sanitizeExportConfig(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');
      // v0.8.1 P0-2: working_memories 无 sessions 外键（历史 schema），此处显式清理
      // 防止全量清空后工作记忆成为无主孤数据
      db.exec('DELETE FROM working_memories');
      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');
      // v0.7.4 P1-5: 清空后重置链式哈希缓存 —— 否则下一条 log() 的 prev_hash
      // 引用已删除的末行，audit:verifyChain 会误报 TAMPERED
      auditService.resetChainCache();
      log.info('[DATA] Audit logs cleared');
      return { success: true };
    } catch (error) {
      try {
        db.exec('ROLLBACK');
      } catch {
        /* 忽略回滚错误 */
      }
      return { success: false, error: (error as Error).message };
    }
  });
}