refactor: add enum type for ipc channel name (#47)

* refactor: add enum type for ipc channel name

* fix: type

* refactor: 3 different IPC channels

* refactor: 3 different IPC channels

* fix: MagicStr in Renderer part

---------

Co-authored-by: Tohrusky <65994850+Tohrusky@users.noreply.github.com>

Author: NangInShell

README.md

@@ -1,4 +1,4 @@
-# VSET --Video SuperResolution Encode Tool
+# VSET
 基于*Vapoursynth*的图形化视频批量压制处理工具。
 
 ## [💬 感谢发电名单](https://github.com/NangInShell/VSET/blob/main/Thanks.md)

electron.vite.config.ts

@@ -5,6 +5,12 @@ import { defineConfig, externalizeDepsPlugin } from 'electron-vite'
 export default defineConfig({
   main: {
     plugins: [externalizeDepsPlugin()],
+    resolve: {
+      alias: {
+        '@main': resolve('src/main'),
+        '@shared': resolve('src/shared'),
+      },
+    },
   },
   preload: {
     plugins: [externalizeDepsPlugin()],
@@ -13,6 +19,7 @@ export default defineConfig({
     resolve: {
       alias: {
         '@renderer': resolve('src/renderer/src'),
+        '@shared': resolve('src/shared'),
       },
     },
     plugins: [vue()],

eslint.config.js

@@ -42,6 +42,14 @@ export default antfu(
   {
     files: ['**/*.vue'],
     rules: {
+      '@typescript-eslint/ban-ts-comment': ['error', { 'ts-ignore': 'allow-with-description' }],
+      '@typescript-eslint/explicit-function-return-type': 'error',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-empty-function': ['error', { allow: ['arrowFunctions'] }],
+      '@typescript-eslint/no-explicit-any': ['off'],
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      '@typescript-eslint/no-var-requires': 'off',
+      '@typescript-eslint/no-inferrable-types': 'off',
       'vue/require-default-prop': 'off',
       'vue/multi-word-component-names': 'off',
     },

package.json

@@ -23,16 +23,16 @@
   "dependencies": {
     "@element-plus/icons-vue": "^2.3.2",
     "electron-updater": "^6.6.2",
-    "element-plus": "^2.10.7",
+    "element-plus": "^2.11.1",
     "iconv-lite": "^0.6.3",
     "naive-ui": "^2.42.0",
     "pinia": "^3.0.3",
     "pinia-plugin-persistedstate": "^4.5.0",
     "ps-tree": "^1.2.0",
-    "systeminformation": "^5.27.7",
+    "systeminformation": "^5.27.8",
     "tree-kill": "^1.2.2",
     "vicons": "^0.0.1",
-    "vue": "^3.5.18",
+    "vue": "^3.5.20",
     "vue-router": "^4.5.1"
   },
   "devDependencies": {
@@ -48,10 +48,10 @@
     "electron": "^27.3.11",
     "electron-builder": "^26.0.12",
     "electron-vite": "^4.0.0",
-    "eslint": "^9.33.0",
+    "eslint": "^9.34.0",
     "eslint-plugin-vue": "^10.4.0",
     "typescript": "^5.9.2",
-    "vite": "^7.1.2",
+    "vite": "^7.1.3",
     "vue-tsc": "^2.2.12"
   },
   "pnpm": {

pnpm-lock.yaml

@@ -2,32 +2,56 @@ import type { ChildProcess } from 'node:child_process'
 import kill from 'tree-kill'
 import { requestStop } from './runCommand'
 
-const childProcesses: ChildProcess[] = []
+interface ManagedProc {
+  name: string
+  proc: ChildProcess
+}
+
+const childProcesses: ManagedProc[] = []
 
-export function addProcess(proc: ChildProcess): void {
-  childProcesses.push(proc)
+export function addProcess(name: string, proc: ChildProcess): void {
+  childProcesses.push({ name, proc })
 }
 
 export function removeProcess(proc: ChildProcess): void {
-  const index = childProcesses.indexOf(proc)
+  const index = childProcesses.findIndex(p => p.proc === proc)
   if (index !== -1) {
     childProcesses.splice(index, 1)
   }
 }
 
+function safeUnpipe(): void {
+  const vspipe = childProcesses.find(p => p.name === 'vspipe')
+  const ffmpeg = childProcesses.find(p => p.name === 'ffmpeg')
+
+  if (vspipe?.proc?.stdout && ffmpeg?.proc?.stdin) {
+    try {
+      vspipe.proc.stdout.unpipe(ffmpeg.proc.stdin)
+    }
+    catch {}
+    try {
+      ffmpeg.proc.stdin.end()
+    }
+    catch {}
+  }
+}
+
 // ✅ 使用 Promise 确保等待 kill 完成
 export async function killAllProcesses(): Promise<void> {
   requestStop()
-  const promises = childProcesses.map((proc) => {
+
+  // 先安全断开管道
+  safeUnpipe()
+  const promises = childProcesses.map(({ name, proc }) => {
     return new Promise<void>((resolve) => {
       if (!proc.killed && typeof proc.pid === 'number') {
-        console.log(`🔪 正在终止子进程 PID=${proc.pid}`)
+        console.log(`stop [${name}] PID=${proc.pid}`)
         kill(proc.pid, 'SIGKILL', (err) => {
           if (err) {
-            console.error(`❌ 无法终止 PID=${proc.pid}:`, err)
+            console.error(`can not stop [${name}] PID=${proc.pid}:`, err)
           }
           else {
-            console.log(`✅ 成功终止 PID=${proc.pid}`)
+            console.log(`success stop [${name}] PID=${proc.pid}`)
           }
           resolve()
         })

src/main/childProcessManager.ts

@@ -1,5 +1,6 @@
 import path from 'node:path'
 import { electronApp, is, optimizer } from '@electron-toolkit/utils'
+import { IpcChannelInvoke, IpcChannelSend } from '@shared/constant/ipc'
 import { app, BrowserWindow, ipcMain, nativeImage, shell } from 'electron'
 import appIcon from '../../resources/icon.png?asset'
 import { killAllProcesses } from './childProcessManager'
@@ -26,23 +27,23 @@ function createWindow(): BrowserWindow {
   })
 
   // ipcMain
-  ipcMain.on('execute-command', runCommand)
+  ipcMain.on(IpcChannelSend.EXECUTE_COMMAND, runCommand)
 
-  ipcMain.on('pause', PauseCommand)
+  ipcMain.on(IpcChannelSend.PAUSE, PauseCommand)
 
-  ipcMain.on('preview', preview)
+  ipcMain.on(IpcChannelSend.PREVIEW, preview)
 
-  ipcMain.on('preview-frame', previewFrame)
+  ipcMain.on(IpcChannelSend.PREVIEW_FRAME, previewFrame)
 
-  ipcMain.on('stop-all-processes', killAllProcesses)
+  ipcMain.on(IpcChannelSend.STOP_ALL_PROCESSES, killAllProcesses)
 
-  ipcMain.on('generate-json', writeSettingsJson)
+  ipcMain.on(IpcChannelSend.GENERATE_JSON, writeSettingsJson)
 
-  ipcMain.handle('open-folder-dialog', openDirectory)
+  ipcMain.handle(IpcChannelInvoke.OPEN_DIRECTORY_DIALOG, openDirectory)
 
-  ipcMain.handle('get-gpu-info', getGpuInfo)
+  ipcMain.handle(IpcChannelInvoke.GET_GPU_INFO, getGpuInfo)
 
-  ipcMain.handle('get-cpu-info', getCpuInfo)
+  ipcMain.handle(IpcChannelInvoke.GET_CPU_INFO, getCpuInfo)
 
   // mainWindow
   mainWindow.on('ready-to-show', () => {

src/main/index.ts

@@ -3,6 +3,7 @@ import type { IpcMainEvent } from 'electron'
 import { Buffer } from 'node:buffer'
 import { spawn } from 'node:child_process'
 import path from 'node:path'
+import { IpcChannelOn } from '@shared/constant/ipc'
 import iconv from 'iconv-lite'
 import { addProcess, removeProcess } from './childProcessManager'
 import { getExecPath, getGenVpyPath } from './getCorePath'
@@ -12,8 +13,8 @@ export async function preview(event: IpcMainEvent, taskConfig: TaskConfig): Prom
   const vspipePath = getExecPath().vspipe
 
   if (!taskConfig.fileList || taskConfig.fileList.length === 0) {
-    event.sender.send('ffmpeg-output', '错误: 没有提供用于预览的文件。\n')
-    event.sender.send('ffmpeg-finish')
+    event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, '错误: 没有提供用于预览的文件。\n')
+    event.sender.send(IpcChannelOn.FFMPEG_FINISHED)
     return
   }
 
@@ -38,7 +39,7 @@ export async function preview(event: IpcMainEvent, taskConfig: TaskConfig): Prom
   }
   await new Promise<void>((resolve, reject) => {
     const vspipeInfoProcess = spawn(vspipePath, ['--info', vpyPath])
-    addProcess(vspipeInfoProcess)
+    addProcess('vspipe', vspipeInfoProcess)
 
     let vspipeOut = '' // 用于保存 stdout 内容
     // eslint-disable-next-line unused-imports/no-unused-vars
@@ -47,36 +48,36 @@ export async function preview(event: IpcMainEvent, taskConfig: TaskConfig): Prom
     vspipeInfoProcess.stdout.on('data', (data: Buffer) => {
       const str = iconv.decode(data, 'gbk')
       vspipeOut += str
-      event.sender.send('ffmpeg-output', `${str}`)
+      event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `${str}`)
     })
 
     vspipeInfoProcess.stderr.on('data', (data: Buffer) => {
       const str = iconv.decode(data, 'gbk')
       stderrOut += str
-      event.sender.send('ffmpeg-output', `${str}`)
+      event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `${str}`)
     })
 
     vspipeInfoProcess.on('close', (code) => {
       removeProcess(vspipeInfoProcess)
-      event.sender.send('ffmpeg-output', `vspipe info 执行完毕，退出码: ${code}\n`)///////
+      event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `vspipe info 执行完毕，退出码: ${code}\n`)///////
       info = {
         width: vspipeOut.match(/Width:\s*(\d+)/)?.[1] || '未知',
         height: vspipeOut.match(/Height:\s*(\d+)/)?.[1] || '未知',
         frames: vspipeOut.match(/Frames:\s*(\d+)/)?.[1] || '0',
         fps: vspipeOut.match(/FPS:\s*([\d/]+)\s*\(([\d.]+) fps\)/)?.[2] || '0',
       }
 
-      event.sender.send('preview-info', info)
+      event.sender.send(IpcChannelOn.PREVIEW_INFO, info)
       resolve()
     })
 
     vspipeInfoProcess.on('error', (err) => {
-      event.sender.send('ffmpeg-output', `vspipe 执行出错: ${err.message}\n`)
+      event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `vspipe 执行出错: ${err.message}\n`)
       reject(err)
     })
   })
-  event.sender.send('preview-vpyPath', vpyPath)
-  event.sender.send('ffmpeg-finish')
+  event.sender.send(IpcChannelOn.PREVIEW_VPY_PATH, vpyPath)
+  event.sender.send(IpcChannelOn.FFMPEG_FINISHED)
 }
 
 export async function previewFrame(event: IpcMainEvent, vpyPath: string, currentFrame: number): Promise<void> {
@@ -87,7 +88,7 @@ export async function previewFrame(event: IpcMainEvent, vpyPath: string, current
   const cmd = `"${vspipePath}" -c y4m --start ${currentFrame} --end ${currentFrame} "${vpyPath}" - | "${ffmpegPath}" -y -f yuv4mpegpipe -i - -frames:v 1 -vcodec png -f image2pipe -`
 
   const vspipePreviewProcess = spawn(cmd, { shell: true })
-  addProcess(vspipePreviewProcess)
+  addProcess('vspipe', vspipePreviewProcess)
 
   const chunks: Buffer[] = []
 
@@ -97,24 +98,24 @@ export async function previewFrame(event: IpcMainEvent, vpyPath: string, current
 
   vspipePreviewProcess.stderr.on('data', (data: Buffer) => {
     const str = iconv.decode(data, 'gbk')
-    event.sender.send('ffmpeg-output', str)
+    event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, str)
   })
 
   vspipePreviewProcess.on('close', (code) => {
     removeProcess(vspipePreviewProcess)
     if (code === 0) {
       const buffer = Buffer.concat(chunks)
       const base64 = `data:image/png;base64,${buffer.toString('base64')}`
-      event.sender.send('preview-image', base64)
+      event.sender.send(IpcChannelOn.PREVIEW_IMAGE, base64)
     }
     else {
-      event.sender.send('ffmpeg-output', `预览失败，退出码: ${code}`)
-      event.sender.send('preview-image', null)
+      event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `预览失败，退出码: ${code}`)
+      event.sender.send(IpcChannelOn.PREVIEW_IMAGE, null)
     }
-    event.sender.send('ffmpeg-finish')
+    event.sender.send(IpcChannelOn.FFMPEG_FINISHED)
   })
 
   vspipePreviewProcess.on('error', (err) => {
-    event.sender.send('ffmpeg-output', `命令执行出错: ${err.message}`)
+    event.sender.send(IpcChannelOn.FFMPEG_OUTPUT, `命令执行出错: ${err.message}`)
   })
 }