独占式文件锁定3

// src/main/HandleLockManager.ts
import koffi from 'koffi'
import path from 'path'

// === 1. 定义 Windows Kernel32 API ===
const lib = koffi.load('kernel32.dll')

// 定义常量
const GENERIC_READ = 0x80000000
const GENERIC_WRITE = 0x40000000
const OPEN_EXISTING = 3
const FILE_ATTRIBUTE_NORMAL = 0x80
const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000 // 关键：允许打开文件夹句柄
const INVALID_HANDLE_VALUE = -1n // koffi 使用 BigInt 处理指针/句柄

// 定义函数签名
const CreateFileW = lib.func('CreateFileW', 'void*', [
  'str16', // lpFileName (宽字符路径)
  'uint32', // dwDesiredAccess
  'uint32', // dwShareMode (关键在这里！设为 0 表示独占)
  'void*', // lpSecurityAttributes
  'uint32', // dwCreationDisposition
  'uint32', // dwFlagsAndAttributes
  'void*' // hTemplateFile
])

const CloseHandle = lib.func('CloseHandle', 'int', ['void*'])

export class HandleLockManager {
  // 存储路径到句柄的映射
  private handles = new Map<string, any>()

  /**
   * 🔒 锁定单个文件或文件夹
   * @param targetPath 绝对路径
   */
  lock(targetPath: string) {
    if (this.handles.has(targetPath)) return true // 已经锁了

    // 1. 构造参数
    // dwShareMode = 0 (表示禁止其他进程 读、写、删除)
    const shareMode = 0 
    
    // dwFlagsAndAttributes: 如果是文件夹，必须加 BACKUP_SEMANTICS
    const flags = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS

    // 2. 调用 Windows API
    const handle = CreateFileW(
      targetPath,
      GENERIC_READ, // 我们只需要读权限来持有句柄
      shareMode,    // 【核心】0 = 独占！拒绝任何共享
      null,
      OPEN_EXISTING,
      flags,
      null
    )

    // 3. 检查是否成功
    if (BigInt(handle) === INVALID_HANDLE_VALUE) {
      console.error(`锁定失败: ${targetPath} (可能已被占用或权限不足)`)
      return false
    }

    // 4. 存入 Map
    this.handles.set(targetPath, handle)
    console.log(`🔒 已独占锁定: ${targetPath}`)
    return true
  }

  /**
   * 🔓 解锁
   */
  unlock(targetPath: string) {
    const handle = this.handles.get(targetPath)
    if (!handle) return

    CloseHandle(handle)
    this.handles.delete(targetPath)
    console.log(`🔓 已释放句柄: ${targetPath}`)
  }

  /**
   * 🔓 解锁所有 (通常在关闭工程时调用)
   */
  unlockAll() {
    for (const [path, handle] of this.handles) {
      CloseHandle(handle)
    }
    this.handles.clear()
  }
}

export const handleLockManager = new HandleLockManager()

// main.ts
import { handleLockManager } from './HandleLockManager'
import fs from 'fs'
import path from 'path'

// 当打开工程时
ipcMain.handle('open-project', async (e, projectDir) => {
  
  // 1. 锁定根文件夹 (防止根目录被重命名/删除)
  handleLockManager.lock(projectDir)

  // 2. 递归锁定所有子文件 (暴力锁定模式)
  // 注意：这会消耗系统句柄资源，文件数上万可能会有性能问题
  const lockRecursively = (dir: string) => {
    const items = fs.readdirSync(dir)
    for (const item of items) {
      if (['.git', 'node_modules'].includes(item)) continue; // 跳过黑名单
      
      const fullPath = path.join(dir, item)
      handleLockManager.lock(fullPath)
      
      if (fs.statSync(fullPath).isDirectory()) {
        lockRecursively(fullPath)
      }
    }
  }
  
  lockRecursively(projectDir)
  
  return { success: true }
})

// 当你的 IDE 需要修改文件时 (重命名/写入)
ipcMain.handle('ide-write-file', async (e, { filePath, content }) => {
  // 1. 必须先解锁！因为你自己持有的 Read 句柄也会阻止你自己的 Write 操作
  // (除非你在 CreateFile 时指定了 WRITE 权限，但为了安全通常先解锁)
  handleLockManager.unlock(filePath)
  
  try {
    // 2. 执行操作
    await fs.promises.writeFile(filePath, content)
  } finally {
    // 3. 操作完立即锁回去
    handleLockManager.lock(filePath)
  }
})

// 应用退出时释放所有
app.on('will-quit', () => {
  handleLockManager.unlockAll()
})