独占式文件锁定1

// src/main/lock-manager.ts
import fs from 'fs-extra'
import path from 'path'
import chokidar from 'chokidar'

export class LockManager {
  // 存储路径到文件描述符(fd)的映射
  private locks = new Map<string, number>()
  private watcher: chokidar.FSWatcher | null = null
  private rootPath: string = ''

  /**
   * 锁定整个文件夹
   */
  async lockDirectory(dirPath: string) {
    // 1. 先清理之前的锁
    await this.unlockAll()
    this.rootPath = dirPath

    console.log(`🔒 开始锁定目录: ${dirPath}`)

    // 2. 启动监听器，防止外部新建文件“逃逸”
    // (如果有人强行塞入新文件，我们立刻锁定它)
    this.watcher = chokidar.watch(dirPath, {
      ignored: /(^|[\/\\])\../, // 忽略隐藏文件
      persistent: true,
      ignoreInitial: false, // 初始扫描也触发 add 事件
      awaitWriteFinish: true // 等待写入完成后再锁
    })

    this.watcher.on('add', (filePath) => this.lockFile(filePath))
    this.watcher.on('addDir', (dirPath) => this.lockFile(dirPath, true))
    
    // 监听解除锁定（比如被外部强制删除了）
    this.watcher.on('unlink', (filePath) => this.releaseLock(filePath))
    this.watcher.on('unlinkDir', (dirPath) => this.releaseLock(dirPath))
  }

  /**
   * 释放所有锁 (通常在关闭项目或退出应用时调用)
   */
  async unlockAll() {
    if (this.watcher) {
      await this.watcher.close()
      this.watcher = null
    }

    for (const [filePath, fd] of this.locks.entries()) {
      try {
        fs.closeSync(fd)
      } catch (e) {
        // 忽略关闭错误的句柄
      }
    }
    this.locks.clear()
    console.log('🔓 已释放所有文件锁')
  }

  /**
   * 核心：锁定单个文件/文件夹
   */
  private lockFile(targetPath: string, isDir = false) {
    if (this.locks.has(targetPath)) return

    try {
      // ⚠️ 关键点：使用 'r+' (读写模式) 打开并不关闭
      // 对于目录，我们在 Windows 上打开句柄可以防止重命名/移动
      // Linux/Mac 对目录 open 的支持有限，通常只支持 'r'
      const flags = isDir ? 'r' : 'r+' 
      
      const fd = fs.openSync(targetPath, flags)
      this.locks.set(targetPath, fd)
      
      // console.log(`Locked: ${path.basename(targetPath)}`)
    } catch (error: any) {
      // 常见错误：EMFILE (句柄耗尽), EPERM (无权限)
      if (error.code === 'EMFILE') {
        console.error('❌ 错误：打开的文件太多，达到了系统上限！建议忽略 node_modules')
      } else {
        console.warn(`无法锁定 ${targetPath}:`, error.message)
      }
    }
  }

  private releaseLock(targetPath: string) {
    const fd = this.locks.get(targetPath)
    if (fd !== undefined) {
      try {
        fs.closeSync(fd)
      } catch (e) {}
      this.locks.delete(targetPath)
    }
  }

  // ==========================================
  //  提供给 IDE 自身的特权操作 API
  // ==========================================

  /**
   * 特权写入：复用 fd 进行写入
   */
  async writeLockedFile(filePath: string, content: string) {
    let fd = this.locks.get(filePath)

    try {
      // 如果还没锁（比如新创建的瞬间），尝试锁一下
      if (fd === undefined) {
        this.lockFile(filePath)
        fd = this.locks.get(filePath)
      }

      if (fd === undefined) throw new Error('File not locked or accessible')

      // Node.js 的 fs.writeFile 支持传入 fd ！！！
      // 但直接传 fd 可能会追加内容，所以我们需要先清空文件内容
      await fs.ftruncate(fd, 0) // 清空文件
      
      // 将内容写入 buffer
      const buffer = Buffer.from(content, 'utf-8')
      
      // 使用 writeSync 或 write 写入
      // position: 0 (从头开始写)
      fs.writeSync(fd, buffer, 0, buffer.length, 0)
      
      console.log(`✅ 特权写入成功: ${filePath}`)
      return true
    } catch (error) {
      console.error('写入失败:', error)
      throw error
    }
  }

  /**
   * 特权重命名
   */
  async renameLockedEntry(oldPath: string, newName: string) {
    const dir = path.dirname(oldPath)
    const newPath = path.join(dir, newName)

    // 1. 必须先释放锁，否则自己也无法重命名 (Windows特性)
    this.releaseLock(oldPath)

    try {
      await fs.rename(oldPath, newPath)
      // 2. 这里的锁会由 Chokidar 的 'add' 事件自动加上，或者手动加
      // this.lockFile(newPath) 
      return newPath
    } catch (error) {
      // 失败了尝试重新锁回去
      this.lockFile(oldPath)
      throw error
    }
  }

  /**
   * 特权删除
   */
  async deleteLockedEntry(targetPath: string) {
    // 1. 释放锁
    this.releaseLock(targetPath)
    
    // 如果是目录，可能需要递归释放子文件锁
    // 简单起见，这里假设外部调用逻辑会处理，或者依赖 Chokidar 的 unlink
    // 为了稳健，我们遍历一下 map 释放所有子路径
    for (const key of this.locks.keys()) {
      if (key.startsWith(targetPath)) {
        this.releaseLock(key)
      }
    }

    try {
      await fs.remove(targetPath)
    } catch (error) {
      // 恢复锁很难，因为可能删了一半
      throw error
    }
  }
  
  /**
   * 特权创建文件
   */
  async createLockedFile(folderPath: string, name: string) {
      const fullPath = path.join(folderPath, name)
      await fs.ensureFile(fullPath)
      // 创建完立刻锁
      this.lockFile(fullPath)
  }
}

// 导出单例
export const lockManager = new LockManager()

// src/main/ipc/lock-ipc.ts
import { ipcMain } from 'electron'
import { lockManager } from '../lock-manager'

export function setupLockIPC() {
  
  // 1. 打开并锁定工程
  ipcMain.handle('lock-open-project', async (_, dirPath: string) => {
    await lockManager.lockDirectory(dirPath)
    return true
  })

  // 2. 关闭工程（释放锁）
  ipcMain.handle('lock-close-project', async () => {
    await lockManager.unlockAll()
  })

  // 3. 特权写入 (替代 fs.writeFile)
  ipcMain.handle('lock-write-file', async (_, { filePath, content }) => {
    return await lockManager.writeLockedFile(filePath, content)
  })

  // 4. 特权删除
  ipcMain.handle('lock-delete', async (_, filePath: string) => {
    return await lockManager.deleteLockedEntry(filePath)
  })
  
  // 5. 特权重命名
  ipcMain.handle('lock-rename', async (_, { oldPath, newName }) => {
    return await lockManager.renameLockedEntry(oldPath, newName)
  })
}

import { setupLockIPC } from './ipc/lock-ipc'
// ...
setupLockIPC()

const lockAPI = {
  openProject: (path: string) => ipcRenderer.invoke('lock-open-project', path),
  closeProject: () => ipcRenderer.invoke('lock-close-project'),
  writeFile: (path: string, content: string) => ipcRenderer.invoke('lock-write-file', { filePath: path, content }),
  delete: (path: string) => ipcRenderer.invoke('lock-delete', path),
  rename: (oldPath: string, newName: string) => ipcRenderer.invoke('lock-rename', { oldPath, newName })
}

// expose ...