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

/**
 * IPC Workspace Handlers — 工作空间域（P2-9 从 handlers.ts 拆分）
 *
 * 工作空间校验、文件继承（SQLite backup API）、数据库完整性检查、信息查询。
 */

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

export function registerWorkspaceHandlers(ctx: IPCContext): void {
  const { workspaceService } = ctx;

  // ===== v0.8.0 P2-4: @ 文件提及 =====

  // 工作空间文件名索引（联想数据源；renderer 侧 Fuse 模糊过滤）
  ipcMain.handle('workspace:listFiles', async (_event, limit: unknown) => {
    const maxFiles =
      typeof limit === 'number' && Number.isFinite(limit) && limit > 0
        ? Math.min(5000, Math.floor(limit))
        : 2000;
    try {
      return { success: true, data: workspaceService.listFiles(maxFiles) };
    } catch (error) {
      return { success: false, error: (error as Error).message };
    }
  });

  // 读取提及文件的文本片段（路径边界 + 512KB 上限 + 二进制拒绝 + MEMORY.md 保护）
  ipcMain.handle('workspace:readFileClip', async (_event, relPath: unknown, maxBytes: unknown) => {
    if (typeof relPath !== 'string' || !relPath.trim()) {
      return { success: false, error: 'Invalid path' };
    }
    const cap =
      typeof maxBytes === 'number' && Number.isFinite(maxBytes) && maxBytes > 0
        ? Math.min(1024 * 1024, Math.floor(maxBytes))
        : 512 * 1024;
    log.info(`[WORKSPACE] readFileClip: ${relPath.slice(0, 120)} (cap=${cap})`);
    return workspaceService.readFileClip(relPath, cap);
  });

  // 校验工作空间路径：检测路径有效性 + 必需文件状态 + 数据库是否存在
  ipcMain.handle('workspace:check', async (_event, targetPath: string) => {
    if (!targetPath || typeof targetPath !== 'string') {
      return { valid: false, reason: '路径不能为空' };
    }

    const { existsSync, statSync } = await import('fs');
    const { resolve } = await import('path');

    const resolvedPath = resolve(targetPath);

    // 校验 1: 路径是否存在
    if (!existsSync(resolvedPath)) {
      return {
        valid: true,
        path: resolvedPath,
        exists: false,
        missingFiles: ['SOUL.md', 'MEMORY.md'],
        isNewWorkspace: true,
        dbExists: false,
        reason: '目录不存在，将在切换后自动创建',
      };
    }

    // 校验 2: 是否为目录
    try {
      const stat = statSync(resolvedPath);
      if (!stat.isDirectory()) {
        return { valid: false, reason: '路径不是目录' };
      }
    } catch {
      return { valid: false, reason: '无法访问路径' };
    }

    // 校验 3: 检测 2 个必需文件状态（SOUL.md + MEMORY.md）
    const requiredFiles = ['SOUL.md', 'MEMORY.md'];
    const missingFiles: string[] = [];
    for (const f of requiredFiles) {
      if (!existsSync(join(resolvedPath, f))) missingFiles.push(f);
    }

    // 校验 4: 检测 .metona/agent.db 是否存在（用于判断是否显示"继承数据库"选项）
    const dbExists = existsSync(join(resolvedPath, '.metona', 'agent.db'));

    return {
      valid: true,
      path: resolvedPath,
      exists: true,
      missingFiles,
      isNewWorkspace: missingFiles.length === requiredFiles.length,
      dbExists,
    };
  });

  // 从旧工作空间继承文件到新工作空间
  ipcMain.handle(
    'workspace:inheritFiles',
    async (
      _event,
      params: {
        targetPath: string;
        sourcePath: string;
        files: string[];
      },
    ) => {
      const { targetPath, sourcePath, files } = params;
      if (!targetPath || !sourcePath || !Array.isArray(files)) {
        return { success: false, error: '参数无效' };
      }

      const { existsSync, mkdirSync, copyFileSync } = await import('fs');
      const { resolve } = await import('path');

      const resolvedTarget = resolve(targetPath);
      const resolvedSource = resolve(sourcePath);

      // 确保目标目录存在
      if (!existsSync(resolvedTarget)) {
        mkdirSync(resolvedTarget, { recursive: true });
      }

      // 继承白名单：键为前端传入的标识，值为实际相对路径分段
      // 白名单映射防止路径遍历攻击（不直接使用用户传入的路径拼接到 fs 调用）
      const INHERIT_WHITELIST: Record<string, string[]> = {
        'SOUL.md': ['SOUL.md'],
        '.metona/agent.db': ['.metona', 'agent.db'],
      };

      const inherited: string[] = [];
      const failed: Array<{ file: string; error: string }> = [];

      for (const fileName of files) {
        const pathSegments = INHERIT_WHITELIST[fileName];
        // 不在白名单中：拒绝（防止路径遍历）
        if (!pathSegments) {
          failed.push({ file: fileName, error: '不在继承白名单中' });
          continue;
        }
        const srcFile = join(resolvedSource, ...pathSegments);
        const dstFile = join(resolvedTarget, ...pathSegments);
        try {
          // 确保目标文件的父目录存在（如 .metona/）
          const dstDir = join(resolvedTarget, ...pathSegments.slice(0, -1));
          if (!existsSync(dstDir)) {
            mkdirSync(dstDir, { recursive: true });
          }
          if (!existsSync(srcFile)) {
            failed.push({ file: fileName, error: '源文件不存在' });
            continue;
          }

          // === 数据库文件特殊处理 ===
          // agent.db 启用了 WAL 模式，直接 copyFileSync 会丢失 WAL 中未 checkpoint 的事务；
          // 用 better-sqlite3 的 backup API（自带 checkpoint + 一致性快照）
          if (fileName === '.metona/agent.db') {
            try {
              const Database = (await import('better-sqlite3')).default;
              const srcDb = new Database(srcFile, { readonly: true, fileMustExist: true });
              try {
                srcDb.backup(dstFile);
                inherited.push(fileName);
                log.info(
                  `[WORKSPACE] Inherited ${fileName} (via SQLite backup): ${resolvedSource} → ${resolvedTarget}`,
                );
              } finally {
                srcDb.close();
              }
            } catch (err) {
              // backup 失败时回退到 copyFileSync（至少保证基本可用）
              log.warn(
                `[WORKSPACE] SQLite backup failed, fallback to copyFileSync: ${(err as Error).message}`,
              );
              try {
                copyFileSync(srcFile, dstFile);
                inherited.push(fileName);
                log.info(
                  `[WORKSPACE] Inherited ${fileName} (fallback copyFileSync): ${resolvedSource} → ${resolvedTarget}`,
                );
              } catch (err2) {
                failed.push({
                  file: fileName,
                  error: `backup 和 fallback 均失败: ${(err2 as Error).message}`,
                });
              }
            }
            continue;
          }

          // === 普通文件直接复制 ===
          copyFileSync(srcFile, dstFile);
          inherited.push(fileName);
          log.info(`[WORKSPACE] Inherited ${fileName}: ${resolvedSource} → ${resolvedTarget}`);
        } catch (err) {
          failed.push({ file: fileName, error: (err as Error).message });
        }
      }

      return { success: true, inherited, failed };
    },
  );

  // #51 修复: 校验源数据库完整性，防止继承损坏的数据库导致新工作空间数据丢失
  ipcMain.handle('workspace:checkDatabaseIntegrity', async (_event, sourcePath: string) => {
    if (!sourcePath) return { success: false, error: '参数无效' };
    const { existsSync } = await import('fs');
    const { resolve } = await import('path');
    const srcFile = join(resolve(sourcePath), '.metona', 'agent.db');
    if (!existsSync(srcFile)) {
      // 源数据库不存在不算损坏（可能是新工作空间尚未创建数据库），视为校验通过
      return { success: true, ok: true, detail: 'source database not exist' };
    }
    try {
      const Database = (await import('better-sqlite3')).default;
      const db = new Database(srcFile, { readonly: true, fileMustExist: true });
      try {
        const result = db.prepare('PRAGMA integrity_check').get() as { integrity_check: string };
        const ok = result.integrity_check === 'ok';
        if (!ok) {
          log.warn(
            `[WORKSPACE] Source database integrity check failed: ${result.integrity_check} (source=${sourcePath})`,
          );
        }
        return { success: true, ok, detail: result.integrity_check };
      } finally {
        db.close();
      }
    } catch (err) {
      log.error(`[WORKSPACE] Failed to check database integrity: ${(err as Error).message}`);
      return { success: false, error: (err as Error).message };
    }
  });

  // 获取当前工作空间详情：路径 + 2 个核心文件状态 + 自动目录状态
  ipcMain.handle('workspace:getInfo', async () => {
    const { existsSync, statSync, readFileSync, readdirSync } = await import('fs');
    const workspacePath = workspaceService.getPath();
    const files = workspaceService.reload(); // 同步外部可能的手动修改

    const REQUIRED = ['SOUL.md', 'MEMORY.md'] as const;
    const AUTO_DIRS = ['logs', '.metona'] as const;

    const fileInfos = REQUIRED.map((name) => {
      const filePath = join(workspacePath, name);
      let exists = false;
      let size = 0;
      let mtime = 0;
      let preview = '';
      try {
        if (existsSync(filePath)) {
          const stat = statSync(filePath);
          exists = true;
          size = stat.size;
          mtime = stat.mtimeMs;
          // 截取前 500 字符作为预览
          const content = readFileSync(filePath, 'utf-8');
          preview = content.length > 500 ? content.slice(0, 500) + '\n...(已截断)' : content;
        }
      } catch {
        // ignore
      }
      // 文件内容映射：SOUL.md → files.soul, MEMORY.md → files.memory
      const contentKey = name.toLowerCase().replace('.md', '') as 'soul' | 'memory';
      return {
        name,
        path: filePath,
        exists,
        size,
        mtime,
        preview: exists ? preview : (files[contentKey] ?? ''),
      };
    });

    const dirInfos = AUTO_DIRS.map((name) => {
      const dirPath = join(workspacePath, name);
      let exists = false;
      let fileCount = 0;
      try {
        if (existsSync(dirPath)) {
          exists = true;
          const stat = statSync(dirPath);
          if (stat.isDirectory()) {
            fileCount = readdirSync(dirPath).length;
          }
        }
      } catch {
        // ignore
      }
      return { name, path: dirPath, exists, fileCount };
    });

    return {
      path: workspacePath,
      files: fileInfos,
      dirs: dirInfos,
    };
  });
}