feat(export): 添加导出暂停取消控制

electron/services/exportTaskControlService.ts

@@ -0,0 +1,210 @@
+import * as path from 'path'
+import { rm, rmdir } from 'fs/promises'
+
+export type ExportTaskControlState = 'running' | 'pause_requested' | 'cancel_requested'
+
+export interface ExportTaskControlHooks {
+  shouldPause: () => boolean
+  shouldStop: () => boolean
+  recordCreatedFile: (filePath: string) => void
+  recordCreatedDir: (dirPath: string) => void
+}
+
+interface ExportTaskManifest {
+  outputDir: string
+  files: Set<string>
+  dirs: Set<string>
+}
+
+interface ExportTaskControlRecord {
+  state: ExportTaskControlState
+  manifest: ExportTaskManifest
+  createdAt: number
+  updatedAt: number
+}
+
+export interface ExportTaskCleanupResult {
+  success: boolean
+  filesDeleted: number
+  dirsDeleted: number
+  error?: string
+}
+
+class ExportTaskControlService {
+  private tasks = new Map<string, ExportTaskControlRecord>()
+
+  createControl(taskId: string, outputDir: string): ExportTaskControlHooks {
+    this.registerTask(taskId, outputDir)
+    return {
+      shouldPause: () => this.getState(taskId) === 'pause_requested',
+      shouldStop: () => this.getState(taskId) === 'cancel_requested',
+      recordCreatedFile: (filePath: string) => this.recordCreatedFile(taskId, filePath),
+      recordCreatedDir: (dirPath: string) => this.recordCreatedDir(taskId, dirPath)
+    }
+  }
+
+  registerTask(taskId: string, outputDir: string): void {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return
+
+    const normalizedOutputDir = path.resolve(String(outputDir || '').trim() || '.')
+    const existing = this.tasks.get(normalizedTaskId)
+    if (existing) {
+      existing.state = 'running'
+      existing.updatedAt = Date.now()
+      if (!existing.manifest.outputDir) {
+        existing.manifest.outputDir = normalizedOutputDir
+      }
+      return
+    }
+
+    this.tasks.set(normalizedTaskId, {
+      state: 'running',
+      manifest: {
+        outputDir: normalizedOutputDir,
+        files: new Set<string>(),
+        dirs: new Set<string>()
+      },
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    })
+  }
+
+  pauseTask(taskId: string): boolean {
+    return this.setState(taskId, 'pause_requested')
+  }
+
+  resumeTask(taskId: string): boolean {
+    return this.setState(taskId, 'running')
+  }
+
+  cancelTask(taskId: string): boolean {
+    return this.setState(taskId, 'cancel_requested')
+  }
+
+  getState(taskId: string): ExportTaskControlState | null {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return null
+    return this.tasks.get(normalizedTaskId)?.state || null
+  }
+
+  releaseTask(taskId: string): void {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return
+    this.tasks.delete(normalizedTaskId)
+  }
+
+  recordCreatedFile(taskId: string, filePath: string): void {
+    const task = this.getTaskForManifestWrite(taskId, filePath)
+    if (!task) return
+    task.manifest.files.add(path.resolve(filePath))
+    task.updatedAt = Date.now()
+  }
+
+  recordCreatedDir(taskId: string, dirPath: string): void {
+    const task = this.getTaskForManifestWrite(taskId, dirPath)
+    if (!task) return
+    task.manifest.dirs.add(path.resolve(dirPath))
+    task.updatedAt = Date.now()
+  }
+
+  async cleanupTask(taskId: string): Promise<ExportTaskCleanupResult> {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    const task = normalizedTaskId ? this.tasks.get(normalizedTaskId) : undefined
+    if (!task) {
+      return { success: true, filesDeleted: 0, dirsDeleted: 0 }
+    }
+
+    const outputDir = task.manifest.outputDir
+    let filesDeleted = 0
+    let dirsDeleted = 0
+    const errors: string[] = []
+
+    const files = Array.from(task.manifest.files)
+      .filter(filePath => this.isInsideOutputDir(filePath, outputDir))
+      .sort((a, b) => b.length - a.length)
+
+    for (const filePath of files) {
+      try {
+        await rm(filePath, { force: true, recursive: false })
+        filesDeleted++
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException | undefined)?.code
+        if (code !== 'ENOENT') {
+          errors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    }
+
+    const dirs = Array.from(task.manifest.dirs)
+      .filter(dirPath => this.isInsideOutputDir(dirPath, outputDir) || this.isSamePath(dirPath, outputDir))
+      .sort((a, b) => b.length - a.length)
+
+    for (const dirPath of dirs) {
+      try {
+        await rmdir(dirPath)
+        dirsDeleted++
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException | undefined)?.code
+        if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'EEXIST') {
+          errors.push(`${dirPath}: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    }
+
+    if (errors.length === 0) {
+      this.releaseTask(normalizedTaskId)
+      return { success: true, filesDeleted, dirsDeleted }
+    }
+
+    return {
+      success: false,
+      filesDeleted,
+      dirsDeleted,
+      error: errors.slice(0, 3).join('; ')
+    }
+  }
+
+  private setState(taskId: string, state: ExportTaskControlState): boolean {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return false
+    const task = this.tasks.get(normalizedTaskId)
+    if (!task) return false
+    task.state = state
+    task.updatedAt = Date.now()
+    return true
+  }
+
+  private getTaskForManifestWrite(taskId: string, targetPath: string): ExportTaskControlRecord | null {
+    const normalizedTaskId = this.normalizeTaskId(taskId)
+    if (!normalizedTaskId) return null
+    const task = this.tasks.get(normalizedTaskId)
+    if (!task) return null
+    if (!this.isInsideOutputDir(targetPath, task.manifest.outputDir) && !this.isSamePath(targetPath, task.manifest.outputDir)) {
+      return null
+    }
+    return task
+  }
+
+  private isInsideOutputDir(targetPath: string, outputDir: string): boolean {
+    const resolvedTarget = path.resolve(targetPath)
+    const resolvedOutputDir = path.resolve(outputDir)
+    const relativePath = path.relative(resolvedOutputDir, resolvedTarget)
+    return Boolean(relativePath) && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)
+  }
+
+  private isSamePath(left: string, right: string): boolean {
+    const resolvedLeft = path.resolve(left)
+    const resolvedRight = path.resolve(right)
+    if (process.platform === 'win32') {
+      return resolvedLeft.toLowerCase() === resolvedRight.toLowerCase()
+    }
+    return resolvedLeft === resolvedRight
+  }
+
+  private normalizeTaskId(taskId: string): string {
+    return String(taskId || '').trim()
+  }
+}
+
+export const exportTaskControlService = new ExportTaskControlService()